# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Optimized C implementation for the Python pickle module. """

class PickleError(Exception):

  pass

class Pickler(object):
  """ Pickler(file, protocol=None)
  This takes a binary file for writing a pickle data stream.
  
  The optional protocol argument tells the pickler to use the
  given protocol; supported protocols are 0, 1, 2, 3.  The default
  protocol is 3; a backward-incompatible protocol designed for
  Python 3.0.
  
  Specifying a negative protocol version selects the highest
  protocol version supported.  The higher the protocol used, the
  more recent the version of Python needed to read the pickle
  produced.
  
  The file argument must have a write() method that accepts a single
  bytes argument. It can thus be a file object opened for binary
  writing, a io.BytesIO instance, or any other custom object that
  meets this interface.
  
  If fix_imports is True and protocol is less than 3, pickle will try to
  map the new Python 3.x names to the old module names used in Python
  2.x, so that the pickle data stream is readable with Python 2.x.
   """

  def __init__(self):
    pass

  bin = None

  def clear_memo(self):
    """ clear_memo() -> None. 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. """
    return None

  dispatch_table = None

  def dump(self, obj):
    """ dump(obj) -> None. Write a pickled representation of obj to the open file. """
    return None

  fast = None
  memo = property(None, None, None,
                  )

  persistent_id = property(None, None, None,
                           )


class PicklingError(PickleError):

  pass

class Unpickler(object):
  """ Unpickler(file, *, encoding='ASCII', errors='strict')
  This takes a binary file for reading a pickle data stream.
  
  The protocol version of the pickle is detected automatically, so no
  proto argument is needed.
  
  The file-like object must have two methods, a read() method
  that takes an integer argument, and a readline() method that
  requires no arguments.  Both methods should return bytes.
  Thus file-like object can be a binary file object opened for
  reading, a BytesIO object, or any other custom object that
  meets this interface.
  
  Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
  which are used to control compatiblity support for pickle stream
  generated by Python 2.x.  If *fix_imports* is True, pickle will try to
  map the old Python 2.x names to the new names used in Python 3.x.  The
  *encoding* and *errors* tell pickle how to decode 8-bit string
  instances pickled by Python 2.x; these default to 'ASCII' and
  'strict', respectively.
   """

  def __init__(self):
    pass

  def find_class(self, module_name, global_name):
    """ find_class(module_name, global_name) -> object.
    
    Return an object from a specified module, importing the module if
    necessary.  Subclasses may override this method (e.g. to restrict
    unpickling of arbitrary classes and functions).
    
    This method is called whenever a class or a function object is
    needed.  Both arguments passed are str objects.
     """
    return None

  def load(self):
    """ load() -> object. Load a pickle.
    Read a pickled object representation from the open file object given in
    the constructor, and return the reconstituted object hierarchy specified
    therein.
     """
    return None

  memo = property(None, None, None,
                  )

  persistent_load = property(None, None, None,
                             )


class UnpicklingError(PickleError):

  pass

__doc__ = 'Optimized C implementation for the Python pickle module.'
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python3.3/lib/Python.framework/Versions/3.3/lib/python3.3/lib-dynload/_pickle.so'
__loader__ = None
__name__ = '_pickle'
__package__ = ''

def dump(obj, file, protocol=None, *, fix_imports=True):
  """ dump(obj, file, protocol=None, *, fix_imports=True) -> None
  
  Write a pickled representation of obj to the open file object file.  This
  is equivalent to ``Pickler(file, protocol).dump(obj)``, but may be more
  efficient.
  
  The optional protocol argument tells the pickler to use the given protocol;
  supported protocols are 0, 1, 2, 3.  The default protocol is 3; a
  backward-incompatible protocol designed for Python 3.0.
  
  Specifying a negative protocol version selects the highest protocol version
  supported.  The higher the protocol used, the more recent the version of
  Python needed to read the pickle produced.
  
  The file argument must have a write() method that accepts a single bytes
  argument.  It can thus be a file object opened for binary writing, a
  io.BytesIO instance, or any other custom object that meets this interface.
  
  If fix_imports is True and protocol is less than 3, pickle will try to
  map the new Python 3.x names to the old module names used in Python 2.x,
  so that the pickle data stream is readable with Python 2.x.
   """
  return None

def dumps(obj, protocol=None, *, fix_imports=True):
  """ dumps(obj, protocol=None, *, fix_imports=True) -> bytes
  
  Return the pickled representation of the object as a bytes
  object, instead of writing it to a file.
  
  The optional protocol argument tells the pickler to use the given protocol;
  supported protocols are 0, 1, 2, 3.  The default protocol is 3; a
  backward-incompatible protocol designed for Python 3.0.
  
  Specifying a negative protocol version selects the highest protocol version
  supported.  The higher the protocol used, the more recent the version of
  Python needed to read the pickle produced.
  
  If fix_imports is True and *protocol* is less than 3, pickle will try to
  map the new Python 3.x names to the old module names used in Python 2.x,
  so that the pickle data stream is readable with Python 2.x.
   """
  return None

def load(file, arg0, fix_imports=True, encoding='ASCII', errors='strict'):
  """ load(file, *, fix_imports=True, encoding='ASCII', errors='strict') -> object
  
  Read a pickled object representation from the open file object file and
  return the reconstituted object hierarchy specified therein.  This is
  equivalent to ``Unpickler(file).load()``, but may be more efficient.
  
  The protocol version of the pickle is detected automatically, so no protocol
  argument is needed.  Bytes past the pickled object's representation are
  ignored.
  
  The argument file must have two methods, a read() method that takes an
  integer argument, and a readline() method that requires no arguments.  Both
  methods should return bytes.  Thus *file* can be a binary file object opened
  for reading, a BytesIO object, or any other custom object that meets this
  interface.
  
  Optional keyword arguments are fix_imports, encoding and errors,
  which are used to control compatiblity support for pickle stream generated
  by Python 2.x.  If fix_imports is True, pickle will try to map the old
  Python 2.x names to the new names used in Python 3.x.  The encoding and
  errors tell pickle how to decode 8-bit string instances pickled by Python
  2.x; these default to 'ASCII' and 'strict', respectively.
   """
  return None

def loads(input, arg0, fix_imports=True, encoding='ASCII', errors='strict'):
  """ loads(input, *, fix_imports=True, encoding='ASCII', errors='strict') -> object
  
  Read a pickled object hierarchy from a bytes object and return the
  reconstituted object hierarchy specified therein
  
  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 compatiblity support for pickle stream generated
  by Python 2.x.  If fix_imports is True, pickle will try to map the old
  Python 2.x names to the new names used in Python 3.x.  The encoding and
  errors tell pickle how to decode 8-bit string instances pickled by Python
  2.x; these default to 'ASCII' and 'strict', respectively.
   """
  return None