python-jsonpickle-1.3-bp152.2.2

- Fix build without python2

- Add PR292-Python38.patch to fix Python 3.8 incompatibilities
  (gh#jsonpickle/jsonpickle#281).

- Exclude tests failing with python 3.8 (test_thing_with_fd,
  test_list_with_fd, and test_dict_with_fd). gh#jsonpickle/jsonpickle#281

- Update to 1.2:
  * support new sqlalchemy
- Remove merged patch sqlalchemy13.patch

- Add patch to work with sqlalchemy 1.3:
  * sqlalchemy13.patch

- Update to 1.1:
  * Python 3.7 collections.Iterator deprecation warnings have been fixed. (#229).
  * Improved Pandas support for datetime and complex numbers. (#245)
  * NOTE jsonpickle no longer supports Python2.6, or Python3 < 3.4. The officially supported Python versions are now 2.7 and 3.4+.
  * Improved Pandas and Numpy support. (#227)
  * Improved support for pickling iterators. (#216)
  * Better support for the stdlib json module when simplejson is not installed. (#217)
  * jsonpickle will now output python3-style module names when pickling builtins methods or functions. (#223)
  * jsonpickle will always flatten primitives, even when max_depth is reached, which avoids encoding unicode strings into their u'string' representation.
  * Nested classes are now supported on Python 3. (#206, #176).
  * Better support for older (pre-1.9) versions of numpy (#195).

- Remove superfluous devel dependency for noarch package

- Update to version 0.9.6
  * Better support for SQLAlchemy (#180).
  * Better support for NumPy and SciKit-Learn. (#184).
- Update to version 0.9.5
  * Better support for objects that implement the reduce protocol. (#170).
- Remove no longer relevant handle_more_than_two_args.patch
- Spec file cleanups

- Implement single-spec version.
- Fix source URL.
- Update to Version 0.9.4
  * Arbitrary byte streams are now better supported.
    (`#143 <https://github.com/jsonpickle/jsonpickle/issues/143>`_).
  * Better support for NumPy data types.  The Python3 NumPy support
    is especially robust.
  * Fortran-ordered based NumPy arrays are now properly serialized.
- Update to Version 0.9.3
  * UUID objects can now be serialized
    (`#130 <https://github.com/jsonpickle/jsonpickle/issues/130>`_).
  * Added `set_decoder_options` method to allow decoder specific options
    equal to `set_encoder_options`.
  * Int keys can be encoded directly by e.g. demjson by passing
    `numeric_keys=True` and setting its backend options via
    `jsonpickle.set_encoder_options('demjson', strict=False)`.
  * Newer Numpy versions (v1.10+) are now supported.
- Update to Version 0.9.2
  * Fixes for serializing objects with custom handlers.
  * We now properly serialize deque objects constructed with a `maxlen` parameter.
  * Test suite fixes
- Update to Version 0.9.1
  * Support datetime objects with FixedOffsets.
- Update to Version 0.9.0
  * Support for Pickle Protocol v4.
  * We now support serializing defaultdict subclasses that use `self`
    as their default factory.
  * We now have a decorator syntax for registering custom handlers,
    and allow custom handlers to register themselves for all subclasses.
    (`#104 <https://github.com/jsonpickle/jsonpickle/pull/104>`_).
  * We now support serializing types with metaclasses and their
    instances (e.g., Python 3 `enum`).
  * We now support serializing bytestrings in both Python 2 and Python 3.
    In Python 2, the `str` type is decoded to UTF-8 whenever possible and
    serialized as a true bytestring elsewise; in Python 3, bytestrings
    are explicitly encoded/decoded as bytestrings. Unicode strings are
    always encoded as is in both Python 2 and Python 3.
  * Added support for serializing numpy arrays, dtypes and scalars
    (see `jsonpickle.ext.numpy` module).
- Update to Version 0.8.0
  * We now support serializing objects that contain references to
    module-level functions
    (`#77 <https://github.com/jsonpickle/jsonpickle/issues/77>`_).
  * Better Pickle Protocol v2 support
    (`#78 <https://github.com/jsonpickle/jsonpickle/issues/78>`_).
  * Support for string __slots__ and iterable __slots__
    (`#67 <https://github.com/jsonpickle/jsonpickle/issues/66>`_)
    (`#68 <https://github.com/jsonpickle/jsonpickle/issues/67>`_).
  * `encode()` now has a `warn` option that makes jsonpickle emit warnings
    when encountering objects that cannot be pickled.
  * A Javascript implementation of jsonpickle is now included
    in the jsonpickleJS directory.
- Update to Version 0.7.2
  * We now properly serialize classes that inherit from classes
    that use `__slots__` and add additional slots in the derived class.
  * jsonpickle can now serialize objects that implement `__getstate__()` but
    not `__setstate__()`.  The result of `__getstate__()` is returned as-is
    when doing a round-trip from Python objects to jsonpickle and back.
  * Better support for collections.defaultdict with custom factories.
  * Added support for `queue.Queue` objects.
- Update to Version 0.7.1
  * Added support for Python 3.4.
  * Added support for :class:`posix.stat_result`.
- Update to Version 0.7.0
  * Added ``handles`` decorator to :class:`jsonpickle.handlers.BaseHandler`,
    enabling simple declaration of a handler for a class.
  * `__getstate__()` and `__setstate__()` are now honored
    when pickling objects that subclass :class:`dict`.
  * jsonpickle can now serialize :class:`collections.Counter` objects.
  * Object references are properly handled when using integer keys.
  * Object references are now supported when using custom handlers.
  * Decimal objects are supported in Python 3.
  * jsonpickle's "fallthrough-on-error" behavior can now be disabled.
  * Simpler API for registering custom handlers.
  * A new "safe-mode" is provided which avoids eval().
    Backwards-compatible deserialization of repr-serialized objects
    is disabled in this mode.  e.g. `decode(string, safe=True)`
- Update to Version 0.6.1
  * Python 3.2 support, and additional fixes for Python 3.
- Update to Version 0.6.0
  * Python 3 support!
  * :class:`time.struct_time` is now serialized using the built-in
    :class:`jsonpickle.handlers.SimpleReduceHandler`.
- Update to Version 0.5.0
  * Non-string dictionary keys (e.g. ints, objects) are now supported
    by passing `keys=True` to :func:`jsonpickle.encode` and
    :func:`jsonpickle.decode`.
  * We now support namedtuple, deque, and defaultdict.
  * Datetimes with timezones are now fully supported.
  * Better support for complicated structures e.g.
    datetime inside dicts.
  * jsonpickle added support for references and cyclical data structures
    in 0.4.0.  This can be disabled by passing `make_refs=False` to
    :func:`jsonpickle.encode`.
- Add handle_more_than_two_args.patch
  Needed for python 3.6 compatibility. Note that only the first
  part of the upstream patch is used. The second part is travis CI
  changes.

- Buildrequire python-simplejson to fix unit tests
- Recommend simplejson instead of demjson (moved to suggests)

- Drop requirement on simplejson, the json module is part of Python-2.6
- feedparser runtime requirement was bogus
- Only suggest demjson and recommend yajl / jsonlib experimental bindings

- Update to version 0.4.0:
  * Switch build from setuptools to distutils
  * Consistent dictionary key ordering
  * Fix areas with improper support for unpicklable=False
  * Added support for cyclical data structures (#16).
  * Experimental support for jsonlib and py-yajl backends.
  * New contributers David K. Hess and Alec Thomas
- Set license to BSD-3-Clause (SPDX style)
- Run testsuite and added needed (Build)Requires

- Update to 0.3.1
  - Include tests and docs directories in sdist for distribution packages.
- Version 0.3.0 - December 11, 2009
  - Officially migrated to git from subversion. Project home now at
    http://jsonpickle.github.com/. Thanks to Michael Jone’s sphinx-to-github.
  - Fortified jsonpickle against common error conditions.
  - Added support for:
  - List and set subclasses.
  - Objects with module references.
  - Newstyle classes with __slots__.
  - Objects implementing __setstate__() and __getstate__() (follows the
    pickle protocol).
  - Improved support for Zope objects via pre-fetch.
  - Support for user-defined serialization handlers via the
    jsonpickle.handlers registry.
  - Removed cjson support per John Millikin’s recommendation.
  - General improvements to style, including PEP 257 compliance and refactored
    project layout.
  - Steps towards Python 2.3 and Python 3 support.
  - New contributors Dan Buch and Ian Schenck.
  - Thanks also to Kieran Darcy, Eoghan Murray, and Antonin Hildebrand for
    their assistance!
- Version 0.2.0 - January 10, 2009
  - Support for all major Python JSON backends (including json in Python 2.6,
    simplejson, cjson, and demjson)
  - Handle several datetime objects using the repr() of the objects (Thanks to
    Antonin Hildebrand).
  - Sphinx documentation
  - Added support for recursive data structures
  - Unicode dict-keys support
  - Support for Google App Engine and Django
  - Tons of additional testing and bug reports (Antonin Hildebrand, Sorin,
    Roberto Saccon, Faber Fedor, FirePython, and Joose)
- Version 0.1.0 - August 21, 2008
  - Added long as basic primitive (thanks Adam Fisk)
  - Prefer python-cjson to simplejson, if available
  - Major API change, use python-cjson’s decode/encode instead of simplejson’s
    load/loads/dump/dumps
  - Added benchmark.py to compare simplejson and python-cjson

- Initial release