_socket.socket - pydoc - phpman

Help on class socket in _socket:

_socket.socket = class socket(builtins.object)
 |  socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object
 |  socket(family=-1, type=-1, proto=-1, fileno=None) -> socket object
 |
 |  Open a socket of the given type.  The family argument specifies the
 |  address family; it defaults to AF_INET.  The type argument specifies
 |  whether this is a stream (SOCK_STREAM, this is the default)
 |  or datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,
 |  specifying the default protocol.  Keyword arguments are accepted.
 |  The socket is created as non-inheritable.
 |
 |  When a fileno is passed in, family, type and proto are auto-detected,
 |  unless they are explicitly set.
 |
 |  A socket object represents one endpoint of a network connection.
 |
 |  Methods of socket objects (keyword arguments not allowed):
 |
 |  _accept() -- accept connection, returning new socket fd and client address
 |  bind(addr) -- bind the socket to a local address
 |  close() -- close the socket
 |  connect(addr) -- connect the socket to a remote address
 |  connect_ex(addr) -- connect, return an error code instead of an exception
 |  dup() -- return a new socket fd duplicated from fileno()
 |  fileno() -- return underlying file descriptor
 |  getpeername() -- return remote address [*]
 |  getsockname() -- return local address
 |  getsockopt(level, optname[, buflen]) -- get socket options
 |  gettimeout() -- return timeout or None
 |  listen([n]) -- start listening for incoming connections
 |  recv(buflen[, flags]) -- receive data
 |  recv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)
 |  recvfrom(buflen[, flags]) -- receive data and sender's address
 |  recvfrom_into(buffer[, nbytes, [, flags])
 |    -- receive data and sender's address (into a buffer)
 |  sendall(data[, flags]) -- send all data
 |  send(data[, flags]) -- send data, may not send all of it
 |  sendto(data[, flags], addr) -- send data to a given address
 |  setblocking(bool) -- set or clear the blocking I/O flag
 |  getblocking() -- return True if socket is blocking, False if non-blocking
 |  setsockopt(level, optname, value[, optlen]) -- set socket options
 |  settimeout(None | float) -- set or clear the timeout
 |  shutdown(how) -- shut down traffic in one or both directions
 |
 |   [*] not available on all platforms!
 |
 |  Methods defined here:
 |
 |  __del__(...)
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  bind(...)
 |      bind(address)
 |
 |      Bind the socket to a local address.  For IP sockets, the address is a
 |      pair (host, port); the host must refer to the local host. For raw packet
 |      sockets the address is a tuple (ifname, proto [,pkttype [,hatype [,addr]]])
 |
 |  close(...)
 |      close()
 |
 |      Close the socket.  It cannot be used after this call.
 |
 |  connect(...)
 |      connect(address)
 |
 |      Connect the socket to a remote address.  For IP sockets, the address
 |      is a pair (host, port).
 |
 |  connect_ex(...)
 |      connect_ex(address) -> errno
 |
 |      This is like connect(address), but returns an error code (the errno value)
 |      instead of raising an exception when an error occurs.
 |
 |  detach(...)
 |      detach()
 |
 |      Close the socket object without closing the underlying file descriptor.
 |      The object cannot be used after this call, but the file descriptor
 |      can be reused for other purposes.  The file descriptor is returned.
 |
 |  fileno(...)
 |      fileno() -> integer
 |
 |      Return the integer file descriptor of the socket.
 |
 |  getblocking(...)
 |      getblocking()
 |
 |      Returns True if socket is in blocking mode, or False if it
 |      is in non-blocking mode.
 |
 |  getpeername(...)
 |      getpeername() -> address info
 |
 |      Return the address of the remote endpoint.  For IP sockets, the address
 |      info is a pair (hostaddr, port).
 |
 |  getsockname(...)
 |      getsockname() -> address info
 |
 |      Return the address of the local endpoint. The format depends on the
 |      address family. For IPv4 sockets, the address info is a pair
 |      (hostaddr, port).
 |
 |  getsockopt(...)
 |      getsockopt(level, option[, buffersize]) -> value
 |
 |      Get a socket option.  See the Unix manual for level and option.
 |      If a nonzero buffersize argument is given, the return value is a
 |      string of that length; otherwise it is an integer.
 |
 |  gettimeout(...)
 |      gettimeout() -> timeout
 |
 |      Returns the timeout in seconds (float) associated with socket
 |      operations. A timeout of None indicates that timeouts on socket
 |      operations are disabled.
 |
 |  listen(...)
 |      listen([backlog])
 |
 |      Enable a server to accept connections.  If backlog is specified, it must be
 |      at least 0 (if it is lower, it is set to 0); it specifies the number of
 |      unaccepted connections that the system will allow before refusing new
 |      connections. If not specified, a default reasonable value is chosen.
 |
 |  recv(...)
 |      recv(buffersize[, flags]) -> data
 |
 |      Receive up to buffersize bytes from the socket.  For the optional flags
 |      argument, see the Unix manual.  When no data is available, block until
 |      at least one byte is available or until the remote end is closed.  When
 |      the remote end is closed and all data is read, return the empty string.
 |
 |  recv_into(...)
 |      recv_into(buffer, [nbytes[, flags]]) -> nbytes_read
 |
 |      A version of recv() that stores its data into a buffer rather than creating
 |      a new string.  Receive up to buffersize bytes from the socket.  If buffersize
 |      is not specified (or 0), receive up to the size available in the given buffer.
 |
 |      See recv() for documentation about the flags.
 |
 |  recvfrom(...)
 |      recvfrom(buffersize[, flags]) -> (data, address info)
 |
 |      Like recv(buffersize, flags) but also return the sender's address info.
 |
 |  recvfrom_into(...)
 |      recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)
 |
 |      Like recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.
 |
 |  recvmsg(...)
 |      recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)
 |
 |      Receive normal data (up to bufsize bytes) and ancillary data from the
 |      socket.  The ancbufsize argument sets the size in bytes of the
 |      internal buffer used to receive the ancillary data; it defaults to 0,
 |      meaning that no ancillary data will be received.  Appropriate buffer
 |      sizes for ancillary data can be calculated using CMSG_SPACE() or
 |      CMSG_LEN(), and items which do not fit into the buffer might be
 |      truncated or discarded.  The flags argument defaults to 0 and has the
 |      same meaning as for recv().
 |
 |      The return value is a 4-tuple: (data, ancdata, msg_flags, address).
 |      The data item is a bytes object holding the non-ancillary data
 |      received.  The ancdata item is a list of zero or more tuples
 |      (cmsg_level, cmsg_type, cmsg_data) representing the ancillary data
 |      (control messages) received: cmsg_level and cmsg_type are integers
 |      specifying the protocol level and protocol-specific type respectively,
 |      and cmsg_data is a bytes object holding the associated data.  The
 |      msg_flags item is the bitwise OR of various flags indicating
 |      conditions on the received message; see your system documentation for
 |      details.  If the receiving socket is unconnected, address is the
 |      address of the sending socket, if available; otherwise, its value is
 |      unspecified.
 |
 |      If recvmsg() raises an exception after the system call returns, it
 |      will first attempt to close any file descriptors received via the
 |      SCM_RIGHTS mechanism.
 |
 |  recvmsg_into(...)
 |      recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)
 |
 |      Receive normal data and ancillary data from the socket, scattering the
 |      non-ancillary data into a series of buffers.  The buffers argument
 |      must be an iterable of objects that export writable buffers
 |      (e.g. bytearray objects); these will be filled with successive chunks
 |      of the non-ancillary data until it has all been written or there are
 |      no more buffers.  The ancbufsize argument sets the size in bytes of
 |      the internal buffer used to receive the ancillary data; it defaults to
 |      0, meaning that no ancillary data will be received.  Appropriate
 |      buffer sizes for ancillary data can be calculated using CMSG_SPACE()
 |      or CMSG_LEN(), and items which do not fit into the buffer might be
 |      truncated or discarded.  The flags argument defaults to 0 and has the
 |      same meaning as for recv().
 |
 |      The return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).
 |      The nbytes item is the total number of bytes of non-ancillary data
 |      written into the buffers.  The ancdata item is a list of zero or more
 |      tuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary
 |      data (control messages) received: cmsg_level and cmsg_type are
 |      integers specifying the protocol level and protocol-specific type
 |      respectively, and cmsg_data is a bytes object holding the associated
 |      data.  The msg_flags item is the bitwise OR of various flags
 |      indicating conditions on the received message; see your system
 |      documentation for details.  If the receiving socket is unconnected,
 |      address is the address of the sending socket, if available; otherwise,
 |      its value is unspecified.
 |
 |      If recvmsg_into() raises an exception after the system call returns,
 |      it will first attempt to close any file descriptors received via the
 |      SCM_RIGHTS mechanism.
 |
 |  send(...)
 |      send(data[, flags]) -> count
 |
 |      Send a data string to the socket.  For the optional flags
 |      argument, see the Unix manual.  Return the number of bytes
 |      sent; this may be less than len(data) if the network is busy.
 |
 |  sendall(...)
 |      sendall(data[, flags])
 |
 |      Send a data string to the socket.  For the optional flags
 |      argument, see the Unix manual.  This calls send() repeatedly
 |      until all data is sent.  If an error occurs, it's impossible
 |      to tell how much data has been sent.
 |
 |  sendmsg(...)
 |      sendmsg(buffers[, ancdata[, flags[, address]]]) -> count
 |
 |      Send normal and ancillary data to the socket, gathering the
 |      non-ancillary data from a series of buffers and concatenating it into
 |      a single message.  The buffers argument specifies the non-ancillary
 |      data as an iterable of bytes-like objects (e.g. bytes objects).
 |      The ancdata argument specifies the ancillary data (control messages)
 |      as an iterable of zero or more tuples (cmsg_level, cmsg_type,
 |      cmsg_data), where cmsg_level and cmsg_type are integers specifying the
 |      protocol level and protocol-specific type respectively, and cmsg_data
 |      is a bytes-like object holding the associated data.  The flags
 |      argument defaults to 0 and has the same meaning as for send().  If
 |      address is supplied and not None, it sets a destination address for
 |      the message.  The return value is the number of bytes of non-ancillary
 |      data sent.
 |
 |  sendmsg_afalg(...)
 |      sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])
 |
 |      Set operation mode, IV and length of associated data for an AF_ALG
 |      operation socket.
 |
 |  sendto(...)
 |      sendto(data[, flags], address) -> count
 |
 |      Like send(data, flags) but allows specifying the destination address.
 |      For IP sockets, the address is a pair (hostaddr, port).
 |
 |  setblocking(...)
 |      setblocking(flag)
 |
 |      Set the socket to blocking (flag is true) or non-blocking (false).
 |      setblocking(True) is equivalent to settimeout(None);
 |      setblocking(False) is equivalent to settimeout(0.0).
 |
 |  setsockopt(...)
 |      setsockopt(level, option, value: int)
 |      setsockopt(level, option, value: buffer)
 |      setsockopt(level, option, None, optlen: int)
 |
 |      Set a socket option.  See the Unix manual for level and option.
 |      The value argument can either be an integer, a string buffer, or
 |      None, optlen.
 |
 |  settimeout(...)
 |      settimeout(timeout)
 |
 |      Set a timeout on socket operations.  'timeout' can be a float,
 |      giving in seconds, or None.  Setting a timeout of None disables
 |      the timeout feature and is equivalent to setblocking(1).
 |      Setting a timeout of zero is the same as setblocking(0).
 |
 |  shutdown(...)
 |      shutdown(flag)
 |
 |      Shut down the reading side of the socket (flag == SHUT_RD), the writing side
 |      of the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  family
 |      the socket family
 |
 |  proto
 |      the socket protocol
 |
 |  timeout
 |      the socket timeout
 |
 |  type
 |      the socket type