Update jsonpickle to 1.5.2

[pyup-bot]

This PR updates jsonpickle from 1.1 to 1.5.2.

Changelog

1.5.1

======
 * The performance of the unpickler was drastically improved by
   avoiding tag checks for basic Python types.  (+340)
 * ``decode()`` documentation improvements.  (+341)
 * Serialization of Pandas DataFrame objects that contain
   timedelta64[ns] dtypes are now supported.  (+330) (331)
 * Dictionary identity is now preserved.  For example, if the same
   dictionary appears twice in a list, the reconstituted list
   will now contain two references to the same dictionary.  (255) (+332)
 * Unit tests were added to ensure that sklearn.tree.DecisionTreeClassifier
   objects are properly serialized.  (155) (+344)
 * The ``is_reducible()`` utility function used by ``encode()`` is now
   4x faster!  Objects that provide ``__getstate__()``, ``__setstate__()``,
   and ``__slots__`` benefit most from these improvements.  (+343)
 * Improved pickler ``flatten()/encode()`` performance.  (+345)

1.5.0

======
 * Previous versions of jsonpickle with `make_refs=False` would emit
   ``null`` when encountering an object it had already seen when
   traversing objects.  All instances of the object are now serialized.
   While this is arguably an improvement in the vast majority of
   scenarios, it is a change in behavior and is thus considered a
   minor-level change.  (333) (334) (337) (+338)
 * Multiple enums are now serialized correctly with `make_refs=False`.  (235)

1.4.2

======
 * Use importlib.metadata from the stdlib on Python 3.8.  (+305) (303)
 * Micro-optimize type checks to use a `set` for lookups. (+327)
 * Documentation improvements.

1.4.1

======
 * Patch release for Python 3.8 `importlib_metadata` support.
   (300)

1.4

====
 * Python 3.8 support.  (292)
 * ``jsonpickle.encode`` now supports the standard ``indent``
   and ``separators`` arguments, and passes them through to the
   active JSON backend library.  (183)
 * We now include a custom handler for `array.array` objects.  (199)
 * Dict key order is preserved when pickling dictionaries on Python3.  (193)
 * Improved serialization of dictionaries with non-string keys.
   Previously, using an enum that was both the key and a value in
   a dictionary could end up with incorrect references to other
   objects.  The references are now properly maintained for dicts
   with object keys that are also referenced in the dict's values.  (286)
 * Improved serialization of pandas.Series objects.  (287)

1.3

====
 * Improved round tripping of default dicts.  (+283) (282)

 * Better support for cyclical references when encoding with
   ``unpicklable=False``.  (+264)

1.2

====
 * Simplified JSON representation for `__reduce__` values.  (+261)

 * Improved Pandas support with new handlers for more Pandas data types.
   (+256)

 * Prevent stack overflows caused by bugs in user-defined `__getstate__`
   functions which cause infinite recursion.  (+260)
   (259)

 * Improved support for objects that contain dicts with Integer keys.
   Previously, jsonpickle could not restore objects that contained
   dicts with integer keys and provided getstate only.
   These objects are now handled robustly.  (247).

 * Support for encoding binary data in `base85`_ instead of base64 has been
   added on Python 3. Base85 produces payloads about 10% smaller than base64,
   albeit at the cost of lower throughput.  For performance and backwards
   compatibility with Python 2 the pickler uses base64 by default, but it can
   be configured to use ``base85`` with the new ``use_base85`` argument.
   (251).

 * Dynamic SQLAlchemy tables in SQLAlchemy >= 1.3 are now supported.
   (254).

.. _base85: https://en.wikipedia.org/wiki/Ascii85

Links

• PyPI: https://pypi.org/project/jsonpickle
• Changelog: https://pyup.io/changelogs/jsonpickle/
• Repo: https://github.com/jsonpickle/jsonpickle