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

python_socks/__init__.py

@@ -1,20 +1,18 @@
-from ._version import __version__, __title__
-
-from ._types import ProxyType
-from ._helpers import parse_proxy_url
-
 from ._errors import (
+    ProxyConnectionError,
     ProxyError,
     ProxyTimeoutError,
-    ProxyConnectionError,
 )
+from ._helpers import parse_proxy_url
+from ._types import ProxyType
+from ._version import __title__, __version__
 
 __all__ = (
-    '__title__',
-    '__version__',
-    'ProxyError',
-    'ProxyTimeoutError',
-    'ProxyConnectionError',
-    'ProxyType',
-    'parse_proxy_url',
+    "ProxyConnectionError",
+    "ProxyError",
+    "ProxyTimeoutError",
+    "ProxyType",
+    "__title__",
+    "__version__",
+    "parse_proxy_url",
 )

python_socks/_abc.py

@@ -1,40 +1,53 @@
-from typing import Optional
+from __future__ import annotations
+
+import socket
+
+from ._types import ResolvedAddress
 
 
 class SyncResolver:
-    def resolve(self, host, port=0, family=0):
-        raise NotImplementedError()
+    def resolve(
+        self,
+        host: str,
+        port: int = 0,
+        family: socket.AddressFamily = socket.AF_UNSPEC,
+    ) -> ResolvedAddress:
+        raise NotImplementedError
 
 
 class AsyncResolver:
-    async def resolve(self, host, port=0, family=0):
-        raise NotImplementedError()
+    async def resolve(
+        self,
+        host: str,
+        port: int = 0,
+        family: socket.AddressFamily = socket.AF_UNSPEC,
+    ) -> ResolvedAddress:
+        raise NotImplementedError
 
 
 class SyncSocketStream:
+    def write(self, data: bytes) -> None:
+        raise NotImplementedError
 
-    def write_all(self, data: bytes):
-        raise NotImplementedError()
-
-    def read(self, max_bytes: Optional[int] = None):
-        raise NotImplementedError()
+    def read(self, max_bytes: int = ...) -> bytes:
+        raise NotImplementedError
 
-    def read_exact(self, n: int):
-        raise NotImplementedError()
+    def read_exactly(self, n: int) -> bytes:
+        raise NotImplementedError
 
-    def close(self):
-        raise NotImplementedError()
+    def close(self) -> None:
+        raise NotImplementedError
 
 
 class AsyncSocketStream:
-    async def write_all(self, data: bytes):
-        raise NotImplementedError()
+    async def write(self, data: bytes) -> None:
+        raise NotImplementedError
 
-    async def read(self, max_bytes: Optional[int] = None):
-        raise NotImplementedError()
+    async def read(self, max_bytes: int = ...) -> bytes:
+        raise NotImplementedError
 
-    async def read_exact(self, n: int):
-        raise NotImplementedError()
+    async def read_exactly(self, n: int) -> bytes:
+        raise NotImplementedError
 
-    async def close(self):
-        raise NotImplementedError()
+    async def close(self) -> None:
+        raise NotImplementedError

python_socks/_connectors/abc.py

@@ -1,4 +1,6 @@
-from .._abc import SyncSocketStream, AsyncSocketStream
+from typing import Any
+
+from .._abc import AsyncSocketStream, SyncSocketStream
 
 
 class SyncConnector:
@@ -7,7 +9,7 @@ class SyncConnector:
         stream: SyncSocketStream,
         host: str,
         port: int,
-    ):
+    ) -> Any:
         raise NotImplementedError
 
 
@@ -17,5 +19,5 @@ class AsyncConnector:
         stream: AsyncSocketStream,
         host: str,
         port: int,
-    ):
+    ) -> Any:
         raise NotImplementedError

python_socks/_connectors/factory_async.py

@@ -1,18 +1,18 @@
-from typing import Optional
+from __future__ import annotations
+
 from .._abc import AsyncResolver
 from .._types import ProxyType
-
 from .abc import AsyncConnector
-from .socks5_async import Socks5AsyncConnector
-from .socks4_async import Socks4AsyncConnector
 from .http_async import HttpAsyncConnector
+from .socks4_async import Socks4AsyncConnector
+from .socks5_async import Socks5AsyncConnector
 
 
 def create_connector(
     proxy_type: ProxyType,
-    username: Optional[str],
-    password: Optional[str],
-    rdns: Optional[bool],
+    username: str | None,
+    password: str | None,
+    rdns: bool | None,  # noqa: FBT001
     resolver: AsyncResolver,
 ) -> AsyncConnector:
     if proxy_type == ProxyType.SOCKS4:
@@ -37,4 +37,4 @@ def create_connector(
             resolver=resolver,
         )
 
-    raise ValueError(f'Invalid proxy type: {proxy_type}')
+    raise ValueError(f"Invalid proxy type: {proxy_type}")

python_socks/_connectors/factory_sync.py

@@ -1,18 +1,18 @@
-from typing import Optional
+from __future__ import annotations
+
 from .._abc import SyncResolver
 from .._types import ProxyType
-
 from .abc import SyncConnector
-from .socks5_sync import Socks5SyncConnector
-from .socks4_sync import Socks4SyncConnector
 from .http_sync import HttpSyncConnector
+from .socks4_sync import Socks4SyncConnector
+from .socks5_sync import Socks5SyncConnector
 
 
 def create_connector(
     proxy_type: ProxyType,
-    username: Optional[str],
-    password: Optional[str],
-    rdns: Optional[bool],
+    username: str | None,
+    password: str | None,
+    rdns: bool | None,  # noqa: FBT001
     resolver: SyncResolver,
 ) -> SyncConnector:
     if proxy_type == ProxyType.SOCKS4:
@@ -37,4 +37,4 @@ def create_connector(
             resolver=resolver,
         )
 
-    raise ValueError(f'Invalid proxy type: {proxy_type}')
+    raise ValueError(f"Invalid proxy type: {proxy_type}")

python_socks/_connectors/http_async.py

@@ -1,17 +1,17 @@
-from typing import Optional
-from .._abc import AsyncSocketStream, AsyncResolver
-from .abc import AsyncConnector
+from __future__ import annotations
 
+from .._abc import AsyncResolver, AsyncSocketStream
 from .._protocols import http
+from .abc import AsyncConnector
 
 
 class HttpAsyncConnector(AsyncConnector):
     def __init__(
         self,
-        username: Optional[str],
-        password: Optional[str],
+        username: str | None,
+        password: str | None,
         resolver: AsyncResolver,
-    ):
+    ) -> None:
         self._username = username
         self._password = password
         self._resolver = resolver
@@ -31,7 +31,7 @@ class HttpAsyncConnector(AsyncConnector):
             password=self._password,
         )
         data = conn.send(request)
-        await stream.write_all(data)
+        await stream.write(data)
 
         data = await stream.read()
         reply: http.ConnectReply = conn.receive(data)

python_socks/_connectors/http_sync.py

@@ -1,17 +1,17 @@
-from typing import Optional
-from .._abc import SyncSocketStream, SyncResolver
-from .abc import SyncConnector
+from __future__ import annotations
 
+from .._abc import SyncResolver, SyncSocketStream
 from .._protocols import http
+from .abc import SyncConnector
 
 
 class HttpSyncConnector(SyncConnector):
     def __init__(
         self,
-        username: Optional[str],
-        password: Optional[str],
+        username: str | None,
+        password: str | None,
         resolver: SyncResolver,
-    ):
+    ) -> None:
         self._username = username
         self._password = password
         self._resolver = resolver
@@ -31,7 +31,7 @@ class HttpSyncConnector(SyncConnector):
             password=self._password,
         )
         data = conn.send(request)
-        stream.write_all(data)
+        stream.write(data)
 
         data = stream.read()
         reply: http.ConnectReply = conn.receive(data)

python_socks/_connectors/socks4_async.py

@@ -1,20 +1,20 @@
-import socket
-from typing import Optional
+from __future__ import annotations
 
-from .._abc import AsyncSocketStream, AsyncResolver
-from .abc import AsyncConnector
+import socket
 
-from .._protocols import socks4
+from .._abc import AsyncResolver, AsyncSocketStream
 from .._helpers import is_ip_address
+from .._protocols import socks4
+from .abc import AsyncConnector
 
 
 class Socks4AsyncConnector(AsyncConnector):
     def __init__(
         self,
-        user_id: Optional[str],
-        rdns: Optional[bool],
+        user_id: str | None,
+        rdns: bool | None,  # noqa: FBT001
         resolver: AsyncResolver,
-    ):
+    ) -> None:
         if rdns is None:
             rdns = False
 
@@ -38,8 +38,8 @@ class Socks4AsyncConnector(AsyncConnector):
 
         request = socks4.ConnectRequest(host=host, port=port, user_id=self._user_id)
         data = conn.send(request)
-        await stream.write_all(data)
+        await stream.write(data)
 
-        data = await stream.read_exact(socks4.ConnectReply.SIZE)
+        data = await stream.read_exactly(socks4.ConnectReply.SIZE)
         reply: socks4.ConnectReply = conn.receive(data)
         return reply

python_socks/_connectors/socks4_sync.py

@@ -1,20 +1,20 @@
-import socket
-from typing import Optional
+from __future__ import annotations
 
-from .._abc import SyncSocketStream, SyncResolver
-from .abc import SyncConnector
+import socket
 
-from .._protocols import socks4
+from .._abc import SyncResolver, SyncSocketStream
 from .._helpers import is_ip_address
+from .._protocols import socks4
+from .abc import SyncConnector
 
 
 class Socks4SyncConnector(SyncConnector):
     def __init__(
         self,
-        user_id: Optional[str],
-        rdns: Optional[bool],
+        user_id: str | None,
+        rdns: bool | None,  # noqa: FBT001
         resolver: SyncResolver,
-    ):
+    ) -> None:
         if rdns is None:
             rdns = False
 
@@ -38,8 +38,8 @@ class Socks4SyncConnector(SyncConnector):
 
         request = socks4.ConnectRequest(host=host, port=port, user_id=self._user_id)
         data = conn.send(request)
-        stream.write_all(data)
+        stream.write(data)
 
-        data = stream.read_exact(socks4.ConnectReply.SIZE)
+        data = stream.read_exactly(socks4.ConnectReply.SIZE)
         reply: socks4.ConnectReply = conn.receive(data)
         return reply

python_socks/_connectors/socks5_async.py

@@ -1,21 +1,21 @@
-import socket
-from typing import Optional
+from __future__ import annotations
 
-from .._abc import AsyncSocketStream, AsyncResolver
-from .abc import AsyncConnector
+import socket
 
-from .._protocols import socks5
+from .._abc import AsyncResolver, AsyncSocketStream
 from .._helpers import is_ip_address
+from .._protocols import socks5
+from .abc import AsyncConnector
 
 
 class Socks5AsyncConnector(AsyncConnector):
     def __init__(
         self,
-        username: Optional[str],
-        password: Optional[str],
-        rdns: Optional[bool],
+        username: str | None,
+        password: str | None,
+        rdns: bool | None,  # noqa: FBT001
         resolver: AsyncResolver,
-    ):
+    ) -> None:
         if rdns is None:
             rdns = True
 
@@ -38,41 +38,44 @@ class Socks5AsyncConnector(AsyncConnector):
             password=self._password,
         )
         data = conn.send(request)
-        await stream.write_all(data)
+        await stream.write(data)
 
-        data = await stream.read_exact(socks5.AuthMethodReply.SIZE)
-        reply: socks5.AuthMethodReply = conn.receive(data)
+        data = await stream.read_exactly(socks5.AuthMethodReply.SIZE)
+        reply: socks5.AuthMethodReply = conn.receive(data)  # type:ignore[assignment]
 
         # Authenticate
         if reply.method == socks5.AuthMethod.USERNAME_PASSWORD:
-            request = socks5.AuthRequest(
+            assert self._username is not None
+            assert self._password is not None
+
+            request = socks5.AuthRequest(  # type:ignore[assignment]
                 username=self._username,
                 password=self._password,
             )
             data = conn.send(request)
-            await stream.write_all(data)
+            await stream.write(data)
 
-            data = await stream.read_exact(socks5.AuthReply.SIZE)
-            _: socks5.AuthReply = conn.receive(data)
+            data = await stream.read_exactly(socks5.AuthReply.SIZE)
+            _: socks5.AuthReply = conn.receive(data)  # type:ignore[assignment]
 
         # Connect
         if not is_ip_address(host) and not self._rdns:
-            _, host = await self._resolver.resolve(
+            _family, host = await self._resolver.resolve(
                 host,
                 family=socket.AF_UNSPEC,
             )
 
         request = socks5.ConnectRequest(host=host, port=port)
         data = conn.send(request)
-        await stream.write_all(data)
+        await stream.write(data)
 
         data = await self._read_reply(stream)
-        reply: socks5.ConnectReply = conn.receive(data)
-        return reply
+        reply: socks5.ConnectReply = conn.receive(data)  # type:ignore[assignment]
+        return reply  # type:ignore[return-value]
 
     # noinspection PyMethodMayBeStatic
     async def _read_reply(self, stream: AsyncSocketStream) -> bytes:
-        data = await stream.read_exact(3)
+        data = await stream.read_exactly(3)
         if data[0] != socks5.SOCKS_VER:
             return data
         if data[1] != socks5.ReplyCode.SUCCEEDED:
@@ -80,16 +83,16 @@ class Socks5AsyncConnector(AsyncConnector):
         if data[2] != socks5.RSV:
             return data
 
-        data += await stream.read_exact(1)
+        data += await stream.read_exactly(1)
         addr_type = data[3]
 
         if addr_type == socks5.AddressType.IPV4:
-            data += await stream.read_exact(6)
+            data += await stream.read_exactly(6)
         elif addr_type == socks5.AddressType.IPV6:
-            data += await stream.read_exact(18)
+            data += await stream.read_exactly(18)
         elif addr_type == socks5.AddressType.DOMAIN:
-            data += await stream.read_exact(1)
+            data += await stream.read_exactly(1)
             host_len = data[-1]
-            data += await stream.read_exact(host_len + 2)
+            data += await stream.read_exactly(host_len + 2)
 
         return data

python_socks/_connectors/socks5_sync.py

@@ -1,21 +1,21 @@
-import socket
-from typing import Optional
+from __future__ import annotations
 
-from .._abc import SyncSocketStream, SyncResolver
-from .abc import SyncConnector
+import socket
 
-from .._protocols import socks5
+from .._abc import SyncResolver, SyncSocketStream
 from .._helpers import is_ip_address
+from .._protocols import socks5
+from .abc import SyncConnector
 
 
 class Socks5SyncConnector(SyncConnector):
     def __init__(
         self,
-        username: Optional[str],
-        password: Optional[str],
-        rdns: Optional[bool],
+        username: str | None,
+        password: str | None,
+        rdns: bool | None,  # noqa: FBT001
         resolver: SyncResolver,
-    ):
+    ) -> None:
         if rdns is None:
             rdns = True
 
@@ -33,37 +33,45 @@ class Socks5SyncConnector(SyncConnector):
         conn = socks5.Connection()
 
         # Auth methods
-        request = socks5.AuthMethodsRequest(username=self._username, password=self._password)
+        request = socks5.AuthMethodsRequest(
+            username=self._username,
+            password=self._password,
+        )
         data = conn.send(request)
-        stream.write_all(data)
+        stream.write(data)
 
-        data = stream.read_exact(socks5.AuthMethodReply.SIZE)
-        reply: socks5.AuthMethodReply = conn.receive(data)
+        data = stream.read_exactly(socks5.AuthMethodReply.SIZE)
+        reply: socks5.AuthMethodReply = conn.receive(data)  # type:ignore[assignment]
 
         # Authenticate
         if reply.method == socks5.AuthMethod.USERNAME_PASSWORD:
-            request = socks5.AuthRequest(username=self._username, password=self._password)
+            assert self._username is not None
+            assert self._password is not None
+
+            request = socks5.AuthRequest(  # type:ignore[assignment]
+                username=self._username,
+                password=self._password,
+            )
             data = conn.send(request)
-            stream.write_all(data)
+            stream.write(data)
 
-            data = stream.read_exact(socks5.AuthReply.SIZE)
-            _: socks5.AuthReply = conn.receive(data)
+            data = stream.read_exactly(socks5.AuthReply.SIZE)
+            _: socks5.AuthReply = conn.receive(data)  # type:ignore[assignment]
 
         # Connect
         if not is_ip_address(host) and not self._rdns:
-            _, host = self._resolver.resolve(host, family=socket.AF_UNSPEC)
+            _family, host = self._resolver.resolve(host, family=socket.AF_UNSPEC)
 
         request = socks5.ConnectRequest(host=host, port=port)
         data = conn.send(request)
-        stream.write_all(data)
+        stream.write(data)
 
         data = self._read_reply(stream)
-        reply: socks5.ConnectReply = conn.receive(data)
-        return reply
+        reply: socks5.ConnectReply = conn.receive(data)  # type:ignore[assignment]
+        return reply  # type:ignore[return-value]
 
-    # noinspection PyMethodMayBeStatic
     def _read_reply(self, stream: SyncSocketStream) -> bytes:
-        data = stream.read_exact(3)
+        data = stream.read_exactly(3)
         if data[0] != socks5.SOCKS_VER:
             return data
         if data[1] != socks5.ReplyCode.SUCCEEDED:
@@ -71,16 +79,16 @@ class Socks5SyncConnector(SyncConnector):
         if data[2] != socks5.RSV:
             return data
 
-        data += stream.read_exact(1)
+        data += stream.read_exactly(1)
         addr_type = data[3]
 
         if addr_type == socks5.AddressType.IPV4:
-            data += stream.read_exact(6)
+            data += stream.read_exactly(6)
         elif addr_type == socks5.AddressType.IPV6:
-            data += stream.read_exact(18)
+            data += stream.read_exactly(18)
         elif addr_type == socks5.AddressType.DOMAIN:
-            data += stream.read_exact(1)
+            data += stream.read_exactly(1)
             host_len = data[-1]
-            data += stream.read_exact(host_len + 2)
+            data += stream.read_exactly(host_len + 2)
 
         return data

python_socks/_errors.py

@@ -1,4 +1,13 @@
-class ProxyException(Exception):
+from __future__ import annotations
+
+from typing import Any
+
+
+class IncompleteReadError(Exception):
+    pass
+
+
+class ProxyException(Exception):  # noqa: N818
     pass
 
 
@@ -11,6 +20,10 @@ class ProxyConnectionError(ProxyException, OSError):
 
 
 class ProxyError(ProxyException):
-    def __init__(self, message, error_code=None):
+    def __init__(
+        self,
+        message: Any,
+        error_code: int | None = None,
+    ) -> None:
         super().__init__(message)
         self.error_code = error_code