PySocks

import socks

import sockshandler

import socks

# Create a SOCKS-enabled socket
s = socks.socksocket()

# Configure SOCKS5 proxy with authentication
s.set_proxy(socks.SOCKS5, "localhost", 1080, username="user", password="pass")

# Use like a regular socket
s.connect(("www.example.com", 80))
s.sendall(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")
response = s.recv(4096)
s.close()

# Alternative: Use create_connection helper
try:
    conn = socks.create_connection(
        ("www.example.com", 80),
        proxy_type=socks.SOCKS5,
        proxy_addr="localhost",
        proxy_port=1080
    )
    conn.sendall(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n")
    response = conn.recv(4096)
    conn.close()
except socks.ProxyError as e:
    print(f"Proxy error: {e}")

class socksocket:
    def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0): ...
    def set_proxy(self, proxy_type=None, addr=None, port=None, rdns=True, username=None, password=None): ...
    def setproxy(self, *args, **kwargs): ...  # Legacy alias for set_proxy
    def connect(self, dest_pair): ...
    def connect_ex(self, dest_pair) -> int: ...  # Returns error code instead of raising
    def bind(self, address): ...
    def send(self, bytes, flags=0) -> int: ...
    def sendto(self, bytes, *args, **kwargs) -> int: ...
    def recv(self, bufsize, flags=0) -> bytes: ...
    def recvfrom(self, bufsize, flags=0) -> tuple[bytes, tuple[str, int]]: ...
    def close(self): ...
    def settimeout(self, timeout): ...
    def gettimeout(self) -> float | None: ...
    def setblocking(self, flag: bool): ...
    def get_proxy_sockname(self) -> tuple[str, int]: ...
    def getproxysockname(self) -> tuple[str, int]: ...  # Legacy alias
    def get_proxy_peername(self) -> tuple[str, int]: ...
    def getproxypeername(self) -> tuple[str, int]: ...  # Legacy alias
    def get_peername(self) -> tuple[str, int]: ...
    def getpeername(self) -> tuple[str, int]: ...  # Override of socket.getpeername

def create_connection(dest_pair, timeout=None, source_address=None, proxy_type=None, proxy_addr=None, proxy_port=None, proxy_rdns=True, proxy_username=None, proxy_password=None, socket_options=None) -> socksocket: ...

def set_default_proxy(proxy_type=None, addr=None, port=None, rdns=True, username=None, password=None): ...
def setdefaultproxy(*args, **kwargs): ...  # Legacy alias for set_default_proxy
def get_default_proxy() -> ProxySettings: ...
def getdefaultproxy() -> ProxySettings: ...  # Legacy alias for get_default_proxy
def wrap_module(module): ...
def wrapmodule(module): ...  # Legacy alias for wrap_module

class SocksiPyHandler:
    def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None): ...
    def http_open(self, req): ...
    def https_open(self, req): ...

PROXY_TYPE_SOCKS4: int  # SOCKS4 proxy type (value: 1)
SOCKS4: int  # Alias for PROXY_TYPE_SOCKS4

PROXY_TYPE_SOCKS5: int  # SOCKS5 proxy type (value: 2) 
SOCKS5: int  # Alias for PROXY_TYPE_SOCKS5

PROXY_TYPE_HTTP: int  # HTTP CONNECT proxy type (value: 3)
HTTP: int  # Alias for PROXY_TYPE_HTTP

# Constant dictionaries
PROXY_TYPES: dict[str, int]  # Maps proxy type names to values
PRINTABLE_PROXY_TYPES: dict[int, str]  # Maps proxy type values to names
DEFAULT_PORTS: dict[int, int]  # Default ports for each proxy type {SOCKS4: 1080, SOCKS5: 1080, HTTP: 8080}
SOCKS4_ERRORS: dict[int, str]  # SOCKS4 error code to message mappings
SOCKS5_ERRORS: dict[int, str]  # SOCKS5 error code to message mappings

# Package version
__version__: str  # Package version string

class ProxyError(IOError):
    """Base proxy error class."""
    def __init__(self, msg: str, socket_err=None): ...

class GeneralProxyError(ProxyError):
    """General proxy errors."""
    pass

class ProxyConnectionError(ProxyError):
    """Proxy connection errors."""
    pass

class SOCKS5AuthError(ProxyError):
    """SOCKS5 authentication errors."""
    pass

class SOCKS5Error(ProxyError):
    """SOCKS5 protocol errors."""
    pass

class SOCKS4Error(ProxyError):
    """SOCKS4 protocol errors."""
    pass

class HTTPError(ProxyError):
    """HTTP proxy errors."""
    pass

ProxySettings = tuple[
    int | None,     # proxy_type: SOCKS4, SOCKS5, HTTP, or None
    str | None,     # addr: proxy server address
    int | None,     # port: proxy server port
    bool,           # rdns: remote DNS resolution flag
    bytes | None,   # username: authentication username
    bytes | None    # password: authentication password
]

DestinationPair = tuple[str, int]  # (hostname/IP, port)
SocketOptions = list[tuple[int, int, int]]  # [(level, optname, value), ...]