multiprocessing API Reference

Python Library Documentation: method Array in module multiprocessing.context

Array(typecode_or_type, size_or_initializer, *, lock=True) method of multiprocessing.context.DefaultContext instance
    Returns a synchronized shared array

Python Library Documentation: class AuthenticationError in module multiprocessing.context

class AuthenticationError(ProcessError)
 |  Method resolution order:
 |      AuthenticationError
 |      ProcessError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors inherited from ProcessError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: method Barrier in module multiprocessing.context

Barrier(parties, action=None, timeout=None) method of multiprocessing.context.DefaultContext instance
    Returns a barrier object

Python Library Documentation: method BoundedSemaphore in module multiprocessing.context

BoundedSemaphore(value=1) method of multiprocessing.context.DefaultContext instance
    Returns a bounded semaphore object

Python Library Documentation: class BufferTooShort in module multiprocessing.context

class BufferTooShort(ProcessError)
 |  Method resolution order:
 |      BufferTooShort
 |      ProcessError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors inherited from ProcessError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: method Condition in module multiprocessing.context

Condition(lock=None) method of multiprocessing.context.DefaultContext instance
    Returns a condition object

Python Library Documentation: method Event in module multiprocessing.context

Event() method of multiprocessing.context.DefaultContext instance
    Returns an event object

Python Library Documentation: method JoinableQueue in module multiprocessing.context

JoinableQueue(maxsize=0) method of multiprocessing.context.DefaultContext instance
    Returns a queue object

Python Library Documentation: method Lock in module multiprocessing.context

Lock() method of multiprocessing.context.DefaultContext instance
    Returns a non-recursive lock object

Python Library Documentation: method Manager in module multiprocessing.context

Manager() method of multiprocessing.context.DefaultContext instance
    Returns a manager associated with a running server process

    The managers methods such as `Lock()`, `Condition()` and `Queue()`
    can be used to create shared objects.

Python Library Documentation: method Pipe in module multiprocessing.context

Pipe(duplex=True) method of multiprocessing.context.DefaultContext instance
    Returns two connection object connected by a pipe

Python Library Documentation: method Pool in module multiprocessing.context

Pool(processes=None, initializer=None, initargs=(), maxtasksperchild=None) method of multiprocessing.context.DefaultContext instance
    Returns a process pool object

Python Library Documentation: class Process in module multiprocessing.context

class Process(multiprocessing.process.BaseProcess)
 |  Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
 |
 |  Method resolution order:
 |      Process
 |      multiprocessing.process.BaseProcess
 |      builtins.object
 |
 |  Methods inherited from multiprocessing.process.BaseProcess:
 |
 |  __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  close(self)
 |      Close the Process object.
 |
 |      This method releases resources held by the Process object.  It is
 |      an error to call this method if the child process is still running.
 |
 |  is_alive(self)
 |      Return whether process is alive
 |
 |  join(self, timeout=None)
 |      Wait until child process terminates
 |
 |  kill(self)
 |      Terminate process; sends SIGKILL signal or uses TerminateProcess()
 |
 |  run(self)
 |      Method to be run in sub-process; can be overridden in sub-class
 |
 |  start(self)
 |      Start child process
 |
 |  terminate(self)
 |      Terminate process; sends SIGTERM signal or uses TerminateProcess()
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from multiprocessing.process.BaseProcess:
 |
 |  exitcode
 |      Return exit code of process or `None` if it has yet to stop
 |
 |  ident
 |      Return identifier (PID) of process or `None` if it has yet to start
 |
 |  pid
 |      Return identifier (PID) of process or `None` if it has yet to start
 |
 |  sentinel
 |      Return a file descriptor (Unix) or handle (Windows) suitable for
 |      waiting for process termination.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from multiprocessing.process.BaseProcess:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  authkey
 |
 |  daemon
 |      Return whether process is a daemon
 |
 |  name

Python Library Documentation: class ProcessError in module multiprocessing.context

class ProcessError(builtins.Exception)
 |  Method resolution order:
 |      ProcessError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: method Queue in module multiprocessing.context

Queue(maxsize=0) method of multiprocessing.context.DefaultContext instance
    Returns a queue object

Python Library Documentation: method RLock in module multiprocessing.context

RLock() method of multiprocessing.context.DefaultContext instance
    Returns a recursive lock object

Python Library Documentation: method RawArray in module multiprocessing.context

RawArray(typecode_or_type, size_or_initializer) method of multiprocessing.context.DefaultContext instance
    Returns a shared array

Python Library Documentation: method RawValue in module multiprocessing.context

RawValue(typecode_or_type, *args) method of multiprocessing.context.DefaultContext instance
    Returns a shared object

Python Library Documentation: int object

class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: int object

class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: method Semaphore in module multiprocessing.context

Semaphore(value=1) method of multiprocessing.context.DefaultContext instance
    Returns a semaphore object

Python Library Documentation: method SimpleQueue in module multiprocessing.context

SimpleQueue() method of multiprocessing.context.DefaultContext instance
    Returns a queue object

Python Library Documentation: class TimeoutError in module multiprocessing.context

class TimeoutError(ProcessError)
 |  Method resolution order:
 |      TimeoutError
 |      ProcessError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors inherited from ProcessError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: method Value in module multiprocessing.context

Value(typecode_or_type, *args, lock=True) method of multiprocessing.context.DefaultContext instance
    Returns a synchronized shared object

Python Library Documentation: function active_children in module multiprocessing.process

active_children()
    Return list of process objects corresponding to live child processes

Python Library Documentation: method allow_connection_pickling in module multiprocessing.context

allow_connection_pickling() method of multiprocessing.context.DefaultContext instance
    Install support for sending connections and sockets
    between processes

Python Library Documentation: module multiprocessing.context in multiprocessing

NAME
    multiprocessing.context

MODULE REFERENCE
    https://docs.python.org/3.12/library/multiprocessing.context.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DATA
    __all__ = ()

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\multiprocessing\context.py

Python Library Documentation: method cpu_count in module multiprocessing.context

cpu_count() method of multiprocessing.context.DefaultContext instance
    Returns the number of CPUs in the system

Python Library Documentation: function current_process in module multiprocessing.process

current_process()
    Return process object representing the current process

Python Library Documentation: method freeze_support in module multiprocessing.context

freeze_support() method of multiprocessing.context.DefaultContext instance
    Check whether this is a fake forked process in a frozen executable.
    If so then run code specified by commandline and exit.

Python Library Documentation: method get_all_start_methods in module multiprocessing.context

get_all_start_methods() method of multiprocessing.context.DefaultContext instance
    Returns a list of the supported start methods, default first.

Python Library Documentation: method get_context in module multiprocessing.context

get_context(method=None) method of multiprocessing.context.DefaultContext instance

Python Library Documentation: method get_logger in module multiprocessing.context

get_logger() method of multiprocessing.context.DefaultContext instance
    Return package logger -- if it does not already exist then
    it is created.

Python Library Documentation: method get_start_method in module multiprocessing.context

get_start_method(allow_none=False) method of multiprocessing.context.DefaultContext instance

Python Library Documentation: method log_to_stderr in module multiprocessing.context

log_to_stderr(level=None) method of multiprocessing.context.DefaultContext instance
    Turn on logging and add a handler which prints to stderr

Python Library Documentation: function parent_process in module multiprocessing.process

parent_process()
    Return process object representing the parent process

Python Library Documentation: module multiprocessing.process in multiprocessing

NAME
    multiprocessing.process

MODULE REFERENCE
    https://docs.python.org/3.12/library/multiprocessing.process.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    # Module providing the `Process` class which emulates `threading.Thread`
    #
    # multiprocessing/process.py
    #
    # Copyright (c) 2006-2008, R Oudkerk
    # Licensed to PSF under a Contributor Agreement.
    #

CLASSES
    builtins.object
        BaseProcess

    class BaseProcess(builtins.object)
     |  BaseProcess(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
     |
     |  Process objects represent activity that is run in a separate process
     |
     |  The class is analogous to `threading.Thread`
     |
     |  Methods defined here:
     |
     |  __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  close(self)
     |      Close the Process object.
     |
     |      This method releases resources held by the Process object.  It is
     |      an error to call this method if the child process is still running.
     |
     |  is_alive(self)
     |      Return whether process is alive
     |
     |  join(self, timeout=None)
     |      Wait until child process terminates
     |
     |  kill(self)
     |      Terminate process; sends SIGKILL signal or uses TerminateProcess()
     |
     |  run(self)
     |      Method to be run in sub-process; can be overridden in sub-class
     |
     |  start(self)
     |      Start child process
     |
     |  terminate(self)
     |      Terminate process; sends SIGTERM signal or uses TerminateProcess()
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  exitcode
     |      Return exit code of process or `None` if it has yet to stop
     |
     |  ident
     |      Return identifier (PID) of process or `None` if it has yet to start
     |
     |  pid
     |      Return identifier (PID) of process or `None` if it has yet to start
     |
     |  sentinel
     |      Return a file descriptor (Unix) or handle (Windows) suitable for
     |      waiting for process termination.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  authkey
     |
     |  daemon
     |      Return whether process is a daemon
     |
     |  name

FUNCTIONS
    active_children()
        Return list of process objects corresponding to live child processes

    current_process()
        Return process object representing the current process

    parent_process()
        Return process object representing the parent process

DATA
    __all__ = ['BaseProcess', 'current_process', 'active_children', 'paren...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\multiprocessing\process.py

Python Library Documentation: module multiprocessing.reduction in multiprocessing

NAME
    multiprocessing.reduction

MODULE REFERENCE
    https://docs.python.org/3.12/library/multiprocessing.reduction.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    # Module which deals with pickling of objects.
    #
    # multiprocessing/reduction.py
    #
    # Copyright (c) 2006-2008, R Oudkerk
    # Licensed to PSF under a Contributor Agreement.
    #

CLASSES
    _pickle.Pickler(builtins.object)
        ForkingPickler
    builtins.object
        DupHandle

    class DupHandle(builtins.object)
     |  DupHandle(handle, access, pid=None)
     |
     |  Picklable wrapper for a handle.
     |
     |  Methods defined here:
     |
     |  __init__(self, handle, access, pid=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  detach(self)
     |      Get the handle.  This should only be called once.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ForkingPickler(_pickle.Pickler)
     |  ForkingPickler(*args)
     |
     |  Pickler subclass used by multiprocessing.
     |
     |  Method resolution order:
     |      ForkingPickler
     |      _pickle.Pickler
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  dumps(obj, protocol=None)
     |
     |  register(type, reduce)
     |      Register a reduce function for a type.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  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.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from _pickle.Pickler:
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  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.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _pickle.Pickler:
     |
     |  __new__(*args, **kwargs) class method of _pickle.Pickler
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from _pickle.Pickler:
     |
     |  bin
     |
     |  dispatch_table
     |
     |  fast
     |
     |  memo
     |
     |  persistent_id

FUNCTIONS
    dump(obj, file, protocol=None)
        Replacement for pickle.dump() using ForkingPickler.

    duplicate(handle, target_process=None, inheritable=False, *, source_process=None)
        Duplicate a handle.  (target_process is a handle not a pid!)

    recv_handle(conn)
        Receive a handle over a local connection.

    register(type, reduce) class method of ForkingPickler
        Register a reduce function for a type.

    send_handle(conn, handle, destination_pid)
        Send a handle over a local connection.

    steal_handle(source_pid, handle)
        Steal a handle from process identified by source_pid.

DATA
    __all__ = ['send_handle', 'recv_handle', 'ForkingPickler', 'register',...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\multiprocessing\reduction.py

Python Library Documentation: module multiprocessing.reduction in multiprocessing

NAME
    multiprocessing.reduction

MODULE REFERENCE
    https://docs.python.org/3.12/library/multiprocessing.reduction.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    # Module which deals with pickling of objects.
    #
    # multiprocessing/reduction.py
    #
    # Copyright (c) 2006-2008, R Oudkerk
    # Licensed to PSF under a Contributor Agreement.
    #

CLASSES
    _pickle.Pickler(builtins.object)
        ForkingPickler
    builtins.object
        DupHandle

    class DupHandle(builtins.object)
     |  DupHandle(handle, access, pid=None)
     |
     |  Picklable wrapper for a handle.
     |
     |  Methods defined here:
     |
     |  __init__(self, handle, access, pid=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  detach(self)
     |      Get the handle.  This should only be called once.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ForkingPickler(_pickle.Pickler)
     |  ForkingPickler(*args)
     |
     |  Pickler subclass used by multiprocessing.
     |
     |  Method resolution order:
     |      ForkingPickler
     |      _pickle.Pickler
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  dumps(obj, protocol=None)
     |
     |  register(type, reduce)
     |      Register a reduce function for a type.
     |
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |
     |  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.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from _pickle.Pickler:
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  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.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from _pickle.Pickler:
     |
     |  __new__(*args, **kwargs) class method of _pickle.Pickler
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from _pickle.Pickler:
     |
     |  bin
     |
     |  dispatch_table
     |
     |  fast
     |
     |  memo
     |
     |  persistent_id

FUNCTIONS
    dump(obj, file, protocol=None)
        Replacement for pickle.dump() using ForkingPickler.

    duplicate(handle, target_process=None, inheritable=False, *, source_process=None)
        Duplicate a handle.  (target_process is a handle not a pid!)

    recv_handle(conn)
        Receive a handle over a local connection.

    register(type, reduce) class method of ForkingPickler
        Register a reduce function for a type.

    send_handle(conn, handle, destination_pid)
        Send a handle over a local connection.

    steal_handle(source_pid, handle)
        Steal a handle from process identified by source_pid.

DATA
    __all__ = ['send_handle', 'recv_handle', 'ForkingPickler', 'register',...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\multiprocessing\reduction.py

Python Library Documentation: method set_executable in module multiprocessing.context

set_executable(executable) method of multiprocessing.context.DefaultContext instance
    Sets the path to a python.exe or pythonw.exe binary used to run
    child processes instead of sys.executable when using the 'spawn'
    start method.  Useful for people embedding Python.

Python Library Documentation: method set_forkserver_preload in module multiprocessing.context

set_forkserver_preload(module_names) method of multiprocessing.context.DefaultContext instance
    Set list of module names to try to load in forkserver process.
    This is really just a hint.

Python Library Documentation: method set_start_method in module multiprocessing.context

set_start_method(method, force=False) method of multiprocessing.context.DefaultContext instance

Python Library Documentation: built-in module sys

NAME
    sys

MODULE REFERENCE
    https://docs.python.org/3.12/library/sys.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module provides access to some objects used or maintained by the
    interpreter and to functions that interact strongly with the interpreter.

    Dynamic objects:

    argv -- command line arguments; argv[0] is the script pathname if known
    path -- module search path; path[0] is the script directory, else ''
    modules -- dictionary of loaded modules

    displayhook -- called to show results in an interactive session
    excepthook -- called to handle any uncaught exception other than SystemExit
      To customize printing in an interactive session or to install a custom
      top-level exception handler, assign other functions to replace these.

    stdin -- standard input file object; used by input()
    stdout -- standard output file object; used by print()
    stderr -- standard error object; used for error messages
      By assigning other file objects (or objects that behave like files)
      to these, it is possible to redirect all of the interpreter's I/O.

    last_exc - the last uncaught exception
      Only available in an interactive session after a
      traceback has been printed.
    last_type -- type of last uncaught exception
    last_value -- value of last uncaught exception
    last_traceback -- traceback of last uncaught exception
      These three are the (deprecated) legacy representation of last_exc.

    Static objects:

    builtin_module_names -- tuple of module names built into this interpreter
    copyright -- copyright notice pertaining to this interpreter
    exec_prefix -- prefix used to find the machine-specific Python library
    executable -- absolute path of the executable binary of the Python interpreter
    float_info -- a named tuple with information about the float implementation.
    float_repr_style -- string indicating the style of repr() output for floats
    hash_info -- a named tuple with information about the hash algorithm.
    hexversion -- version information encoded as a single integer
    implementation -- Python implementation information.
    int_info -- a named tuple with information about the int implementation.
    maxsize -- the largest supported length of containers.
    maxunicode -- the value of the largest Unicode code point
    platform -- platform identifier
    prefix -- prefix used to find the Python library
    thread_info -- a named tuple with information about the thread implementation.
    version -- the version of this interpreter as a string
    version_info -- version information as a named tuple
    dllhandle -- [Windows only] integer handle of the Python DLL
    winver -- [Windows only] version number of the Python DLL
    _enablelegacywindowsfsencoding -- [Windows only]
    __stdin__ -- the original stdin; don't touch!
    __stdout__ -- the original stdout; don't touch!
    __stderr__ -- the original stderr; don't touch!
    __displayhook__ -- the original displayhook; don't touch!
    __excepthook__ -- the original excepthook; don't touch!

    Functions:

    displayhook() -- print an object to the screen, and save it in builtins._
    excepthook() -- print an exception and its traceback to sys.stderr
    exception() -- return the current thread's active exception
    exc_info() -- return information about the current thread's active exception
    exit() -- exit the interpreter by raising SystemExit
    getdlopenflags() -- returns flags to be used for dlopen() calls
    getprofile() -- get the global profiling function
    getrefcount() -- return the reference count for an object (plus one :-)
    getrecursionlimit() -- return the max recursion depth for the interpreter
    getsizeof() -- return the size of an object in bytes
    gettrace() -- get the global debug tracing function
    setdlopenflags() -- set the flags to be used for dlopen() calls
    setprofile() -- set the global profiling function
    setrecursionlimit() -- set the max recursion depth for the interpreter
    settrace() -- set the global debug tracing function

SUBMODULES
    monitoring

FUNCTIONS
    __breakpointhook__ = breakpointhook(...)
        breakpointhook(*args, **kws)

        This hook function is called by built-in breakpoint().

    __displayhook__ = displayhook(object, /)
        Print an object to sys.stdout and also save it in builtins._

    __excepthook__ = excepthook(exctype, value, traceback, /)
        Handle an exception by displaying it with a traceback on sys.stderr.

    __unraisablehook__ = unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

    activate_stack_trampoline(backend, /)
        Activate stack profiler trampoline *backend*.

    addaudithook(hook)
        Adds a new audit hook callback.

    audit(...)
        audit(event, *args)

        Passes the event to any audit hooks that are attached.

    breakpointhook(...)
        breakpointhook(*args, **kws)

        This hook function is called by built-in breakpoint().

    call_tracing(func, args, /)
        Call func(*args), while tracing is enabled.

        The tracing state is saved, and restored afterwards.  This is intended
        to be called from a debugger from a checkpoint, to recursively debug
        some other code.

    deactivate_stack_trampoline()
        Deactivate the current stack profiler trampoline backend.

        If no stack profiler is activated, this function has no effect.

    displayhook(object, /)
        Print an object to sys.stdout and also save it in builtins._

    exc_info()
        Return current exception information: (type, value, traceback).

        Return information about the most recent exception caught by an except
        clause in the current stack frame or in an older stack frame.

    excepthook(exctype, value, traceback, /)
        Handle an exception by displaying it with a traceback on sys.stderr.

    exception()
        Return the current exception.

        Return the most recent exception caught by an except clause
        in the current stack frame or in an older stack frame, or None
        if no such exception exists.

    exit(status=None, /)
        Exit the interpreter by raising SystemExit(status).

        If the status is omitted or None, it defaults to zero (i.e., success).
        If the status is an integer, it will be used as the system exit status.
        If it is another kind of object, it will be printed and the system
        exit status will be one (i.e., failure).

    get_asyncgen_hooks()
        Return the installed asynchronous generators hooks.

        This returns a namedtuple of the form (firstiter, finalizer).

    get_coroutine_origin_tracking_depth()
        Check status of origin tracking for coroutine objects in this thread.

    get_int_max_str_digits()
        Return the maximum string digits limit for non-binary int<->str conversions.

    getallocatedblocks()
        Return the number of memory blocks currently allocated.

    getdefaultencoding()
        Return the current default encoding used by the Unicode implementation.

    getfilesystemencodeerrors()
        Return the error mode used Unicode to OS filename conversion.

    getfilesystemencoding()
        Return the encoding used to convert Unicode filenames to OS filenames.

    getprofile()
        Return the profiling function set with sys.setprofile.

        See the profiler chapter in the library manual.

    getrecursionlimit()
        Return the current value of the recursion limit.

        The recursion limit is the maximum depth of the Python interpreter
        stack.  This limit prevents infinite recursion from causing an overflow
        of the C stack and crashing Python.

    getrefcount(object, /)
        Return the reference count of object.

        The count returned is generally one higher than you might expect,
        because it includes the (temporary) reference as an argument to
        getrefcount().

    getsizeof(...)
        getsizeof(object [, default]) -> int

        Return the size of object in bytes.

    getswitchinterval()
        Return the current thread switch interval; see sys.setswitchinterval().

    gettrace()
        Return the global debug tracing function set with sys.settrace.

        See the debugger chapter in the library manual.

    getunicodeinternedsize()
        Return the number of elements of the unicode interned dictionary

    getwindowsversion()
        Return info about the running version of Windows as a named tuple.

        The members are named: major, minor, build, platform, service_pack,
        service_pack_major, service_pack_minor, suite_mask, product_type and
        platform_version. For backward compatibility, only the first 5 items
        are available by indexing. All elements are numbers, except
        service_pack and platform_type which are strings, and platform_version
        which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
        workstation, 2 for a domain controller, 3 for a server.
        Platform_version is a 3-tuple containing a version number that is
        intended for identifying the OS rather than feature detection.

    intern(string, /)
        ``Intern'' the given string.

        This enters the string in the (global) table of interned strings whose
        purpose is to speed up dictionary lookups. Return the string itself or
        the previously interned string object with the same value.

    is_finalizing()
        Return True if Python is exiting.

    is_stack_trampoline_active()
        Return *True* if a stack profiler trampoline is active.

    set_asyncgen_hooks(...)
        set_asyncgen_hooks([firstiter] [, finalizer])

        Set a finalizer for async generators objects.

    set_coroutine_origin_tracking_depth(depth)
        Enable or disable origin tracking for coroutine objects in this thread.

        Coroutine objects will track 'depth' frames of traceback information
        about where they came from, available in their cr_origin attribute.

        Set a depth of 0 to disable.

    set_int_max_str_digits(maxdigits)
        Set the maximum string digits limit for non-binary int<->str conversions.

    setprofile(...)
        setprofile(function)

        Set the profiling function.  It will be called on each function call
        and return.  See the profiler chapter in the library manual.

    setrecursionlimit(limit, /)
        Set the maximum depth of the Python interpreter stack to n.

        This limit prevents infinite recursion from causing an overflow of the C
        stack and crashing Python.  The highest possible limit is platform-
        dependent.

    setswitchinterval(interval, /)
        Set the ideal thread switching delay inside the Python interpreter.

        The actual frequency of switching threads can be lower if the
        interpreter executes long sequences of uninterruptible code
        (this is implementation-specific and workload-dependent).

        The parameter must represent the desired switching delay in seconds
        A typical value is 0.005 (5 milliseconds).

    settrace(...)
        settrace(function)

        Set the global debug tracing function.  It will be called on each
        function call.  See the debugger chapter in the library manual.

    unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

DATA
    __stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1...
    __stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
    __stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1...
    api_version = 1013
    argv = [r'f:\JoeyCodes\PyDocs\py_docs.py', '--worker', 'multiprocessin...
    base_exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Pyth...
    base_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
    builtin_module_names = ('_abc', '_ast', '_bisect', '_blake2', '_codecs...
    byteorder = 'little'
    copyright = 'Copyright (c) 2001-2023 Python Software Foundati...ematis...
    dllhandle = 140727031824384
    dont_write_bytecode = False
    exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
    executable = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
    flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ding=0, saf...
    float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
    float_repr_style = 'short'
    hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash1...
    hexversion = 51119856
    implementation = namespace(name='cpython', cache_tag='cpython-312...as...
    int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4, ..._str_dig...
    maxsize = 9223372036854775807
    maxunicode = 1114111
    meta_path = [<_distutils_hack.DistutilsMetaFinder object>, <class '_fr...
    modules = {'__future__': <module '__future__' from 'C:\\Users\\Youse\\...
    orig_argv = [r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
    path = [r'f:\JoeyCodes\PyDocs', r'C:\Users\Youse\AppData\Local\Program...
    path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
    path_importer_cache = {r'C:\Users\Youse\AppData\Local\Programs\Python\...
    platform = 'win32'
    platlibdir = 'DLLs'
    prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312'
    pycache_prefix = None
    stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1252'...
    stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
    stdlib_module_names = frozenset({'__future__', '_abc', '_aix_support',...
    stdout = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'...
    thread_info = sys.thread_info(name='nt', lock=None, version=None)
    version = '3.12.6 (tags/v3.12.6:a4a2d2b, Sep  6 2024, 20:11:23) [MSC v...
    version_info = sys.version_info(major=3, minor=12, micro=6, releaselev...
    warnoptions = []
    winver = '3.12'

FILE
    (built-in)