💾 Archived View for tris.fyi › pydoc › multiprocessing.reduction captured on 2023-01-29 at 04:15:16. Gemini links have been rewritten to link to archived content

View Raw

More Information

⬅️ Previous capture (2022-01-08)

-=-=-=-=-=-=-

Back to module index

Go to module by name

multiprocessing

multiprocessing.reduction

This module has no docstring.

Classes

ABCMeta

Metaclass for defining Abstract Base Classes (ABCs).

        Use this metaclass to create an ABC.  An ABC can be subclassed
        directly, and then acts as a mix-in class.  You can also register
        unrelated concrete classes (even built-in classes) and unrelated
        ABCs as 'virtual subclasses' -- these and their descendants will
        be considered subclasses of the registering ABC by the built-in
        issubclass() function, but the registering ABC won't show up in
        their MRO (Method Resolution Order) nor will method
        implementations defined by the registering ABC be callable (not
        even via super()).
        
mro(self, /)

  Return a type's method resolution order.
register(cls, subclass)

  Register a virtual subclass of an ABC.

              Returns the subclass, to allow usage as a class decorator.
            

AbstractReducer

Abstract base class for use in implementing a Reduction class
    suitable for use in replacing the standard reduction mechanism
    used in multiprocessing.

sendfds.ForkingPickler

Pickler subclass used by multiprocessing.
clear_memo(self, /)

  Clears the pickler's "memo".

  The memo is the data structure that remembers which objects the
  pickler has already seen, so that shared or recursive objects are
  pickled by reference and not by value.  This method is useful when
  re-using picklers.
dump(self, obj, /)

  Write a pickled representation of the given object to the open file.
dumps(obj, protocol=None)
loads(data, /, *, fix_imports=True, encoding='ASCII', errors='strict', buffers=())

  Read and return an object from the given pickle data.

  The protocol version of the pickle is detected automatically, so no
  protocol argument is needed.  Bytes past the pickled object's
  representation are ignored.

  Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
  which are used to control compatibility support for pickle stream
  generated by Python 2.  If *fix_imports* is True, pickle will try to
  map the old Python 2 names to the new names used in Python 3.  The
  *encoding* and *errors* tell pickle how to decode 8-bit string
  instances pickled by Python 2; these default to 'ASCII' and 'strict',
  respectively.  The *encoding* can be 'bytes' to read these 8-bit
  string instances as bytes objects.
register(type, reduce)

  Register a reduce function for a type.
bin = <member 'bin' of '_pickle.Pickler' objects>
dispatch_table = <member 'dispatch_table' of '_pickle.Pickler' objects>
fast = <member 'fast' of '_pickle.Pickler' objects>
memo = <attribute 'memo' of '_pickle.Pickler' objects>
persistent_id = <attribute 'persistent_id' of '_pickle.Pickler' objects>
DupFd(fd)

  Return a wrapper for an fd.
dump(obj, file, protocol=None)

  Replacement for pickle.dump() using ForkingPickler.
recv_handle(conn)

  Receive a handle over a local connection.
recvfds(sock, size)

  Receive an array of fds over an AF_UNIX socket.
register(type, reduce)

  Register a reduce function for a type.
send_handle(conn, handle, destination_pid)

  Send a handle over a local connection.
sendfds(sock, fds)

  Send an array of fds over an AF_UNIX socket.

ForkingPickler

Pickler subclass used by multiprocessing.
clear_memo(self, /)

  Clears the pickler's "memo".

  The memo is the data structure that remembers which objects the
  pickler has already seen, so that shared or recursive objects are
  pickled by reference and not by value.  This method is useful when
  re-using picklers.
dump(self, obj, /)

  Write a pickled representation of the given object to the open file.
dumps(obj, protocol=None)
loads(data, /, *, fix_imports=True, encoding='ASCII', errors='strict', buffers=())

  Read and return an object from the given pickle data.

  The protocol version of the pickle is detected automatically, so no
  protocol argument is needed.  Bytes past the pickled object's
  representation are ignored.

  Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
  which are used to control compatibility support for pickle stream
  generated by Python 2.  If *fix_imports* is True, pickle will try to
  map the old Python 2 names to the new names used in Python 3.  The
  *encoding* and *errors* tell pickle how to decode 8-bit string
  instances pickled by Python 2; these default to 'ASCII' and 'strict',
  respectively.  The *encoding* can be 'bytes' to read these 8-bit
  string instances as bytes objects.
register(type, reduce)

  Register a reduce function for a type.
bin = <member 'bin' of '_pickle.Pickler' objects>
dispatch_table = <member 'dispatch_table' of '_pickle.Pickler' objects>
fast = <member 'fast' of '_pickle.Pickler' objects>
memo = <attribute 'memo' of '_pickle.Pickler' objects>
persistent_id = <attribute 'persistent_id' of '_pickle.Pickler' objects>

Functions

DupFd

DupFd(fd)

  Return a wrapper for an fd.

dump

dump(obj, file, protocol=None)

  Replacement for pickle.dump() using ForkingPickler.

recv_handle

recv_handle(conn)

  Receive a handle over a local connection.

recvfds

recvfds(sock, size)

  Receive an array of fds over an AF_UNIX socket.

register

register(type, reduce)

  Register a reduce function for a type.

send_handle

send_handle(conn, handle, destination_pid)

  Send a handle over a local connection.

sendfds

sendfds(sock, fds)

  Send an array of fds over an AF_UNIX socket.

Other members

ACKNOWLEDGE = False
HAVE_SEND_HANDLE = True

Modules

array

context

copyreg

functools

io

os

pickle

socket

sys