Hello community,
here is the log from the commit of package python-natsort for openSUSE:Factory
checked in at 2018-07-18 22:52:48
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-natsort (Old)
and /work/SRC/openSUSE:Factory/.python-natsort.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-natsort"
Wed Jul 18 22:52:48 2018 rev:4 rq:621668 version:5.3.3
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-natsort/python-natsort.changes
2018-05-29 10:41:06.416936137 +0200
+++ /work/SRC/openSUSE:Factory/.python-natsort.new/python-natsort.changes
2018-07-18 22:52:57.447156379 +0200
@@ -1,0 +2,8 @@
+Sun Jul 8 03:47:00 UTC 2018 - a...@gmx.de
+
+- update to version 5.3.3:
+ * Update docs with a FAQ and quick how-it-works.
+ * Fix a StopIteration error in the testing code.
+ * Enable Python 3.7 support in Travis-CI.
+
+-------------------------------------------------------------------
Old:
----
natsort-5.3.2.tar.gz
New:
----
natsort-5.3.3.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-natsort.spec ++++++
--- /var/tmp/diff_new_pack.Qa3zyj/_old 2018-07-18 22:52:58.283153607 +0200
+++ /var/tmp/diff_new_pack.Qa3zyj/_new 2018-07-18 22:52:58.283153607 +0200
@@ -19,7 +19,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
%bcond_without test
Name: python-natsort
-Version: 5.3.2
+Version: 5.3.3
Release: 0
Summary: Natural sorting in Python
License: MIT
++++++ natsort-5.3.2.tar.gz -> natsort-5.3.3.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/.travis.yml
new/natsort-5.3.3/.travis.yml
--- old/natsort-5.3.2/.travis.yml 2018-05-15 06:06:24.000000000 +0200
+++ new/natsort-5.3.3/.travis.yml 2018-07-08 02:08:43.000000000 +0200
@@ -1,23 +1,46 @@
language: python
-python:
-- "2.7"
-- "3.4"
-- "3.5"
-- "3.6"
-
-sudo: false
-dist: trusty
-
-env:
-- WITH_EXTRAS="fast,icu"
-- WITH_EXTRAS=""
-
-addons:
- apt:
- packages:
- - libicu-dev
- - language-pack-de
- - language-pack-en
+matrix:
+ include:
+ - python: "2.7"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS=""
+ - python: "2.7"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS="fast,icu"
+ addons:
+ apt:
+ packages:
+ - libicu-dev
+ - language-pack-de
+ - language-pack-en
+ - python: "3.4"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS=""
+ - python: "3.5"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS=""
+ - python: "3.6"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS=""
+ - python: "3.6"
+ dist: trusty
+ sudo: false
+ env: WITH_EXTRAS="fast,icu"
+ addons:
+ apt:
+ packages:
+ - libicu-dev
+ - language-pack-de
+ - language-pack-en
+ - python: "3.7"
+ dist: xenial
+ sudo: true
+ env: WITH_EXTRAS=""
install:
- pip install -U pip
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/PKG-INFO new/natsort-5.3.3/PKG-INFO
--- old/natsort-5.3.2/PKG-INFO 2018-05-18 05:47:13.000000000 +0200
+++ new/natsort-5.3.3/PKG-INFO 2018-07-08 02:18:38.000000000 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: natsort
-Version: 5.3.2
+Version: 5.3.3
Summary: Simple yet flexible natural sorting in Python.
Home-page: https://github.com/SethMMorton/natsort
Author: Seth M. Morton
@@ -41,6 +41,7 @@
`this post
<https://opensource.stackexchange.com/q/5941/8999>`_ for an
explanation into why.
+ - `FAQ`_
- `Optional Dependencies`_
- `fastnumbers <https://pypi.org/project/fastnumbers>`_ >= 2.0.0
@@ -100,6 +101,9 @@
Please see `Generating a Reusable Sorting Key and Sorting In-Place`_
for
an alternate way to sort in-place naturally.
+ Examples
+ --------
+
Sorting Versions
++++++++++++++++
@@ -185,6 +189,15 @@
All of the available customizations can be found in the documentation
for
`the ns enum <http://natsort.readthedocs.io/en/master/ns_class.html>`_.
+ You can also add your own custom transformation functions with the
``key`` argument.
+ These can be used with ``alg`` if you wish.
+
+ .. code-block:: python
+
+ >>> a = ['apple2.50', '2.3apple']
+ >>> natsorted(a, key=lambda x: x.replace('apple', ''), alg=ns.REAL)
+ ['2.3apple', 'apple2.50']
+
Sorting Mixed Types
+++++++++++++++++++
@@ -251,6 +264,66 @@
- `sorting file paths correctly
<http://natsort.readthedocs.io/en/master/examples.html#path-sort>`_
- `allow custom sorting keys
<http://natsort.readthedocs.io/en/master/examples.html#custom-sort>`_
+ FAQ
+ ---
+
+ How do I debug ``natsort.natsorted()``?
+ The best way to debug ``natsorted()`` is to generate a key using
``natsort_keygen()``
+ with the same options being passed to ``natsorted``. One can take
a look at
+ exactly what is being done with their input using this key - it is
highly recommended
+ to `look at this issue describing how to debug
<https://github.com/SethMMorton/natsort/issues/13#issuecomment-50422375>`_
+ for *how* to debug, and also to review the
+ `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_
+ page for *why* ``natsort`` is doing that to your data.
+
+ If you are trying to sort custom classes and running into trouble,
please take a look at
+ https://github.com/SethMMorton/natsort/issues/60. In short,
+ custom classes are not likely to be sorted correctly if one relies
+ on the behavior of ``__lt__`` and the other rich comparison
operators in their
+ custom class - it is better to use a ``key`` function with
``natsort``, or
+ use the ``natsort`` key as part of your rich comparison operator
definition.
+
+ How *does* ``natsort`` work?
+ If you don't want to read `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_,
+ here is a quick primer.
+
+ ``natsort`` provides a `key function
<https://docs.python.org/3/howto/sorting.html#key-functions>`_
+ that can be passed to `list.sort()
<https://docs.python.org/3/library/stdtypes.html#list.sort>`_
+ or `sorted()
<https://docs.python.org/3/library/functions.html#sorted>`_ in order to
+ modify the default sorting behavior. This key is generated
on-demand with the
+ key generator ``natsort.natsort_keygen()``.
``natsort.natsorted()`` is essentially
+ a wrapper for the following code:
+
+ .. code-block:: python
+
+ >>> from natsort import natsort_keygen
+ >>> natsort_key = natsort_keygen()
+ >>> sorted(['1', '10', '2'], key=natsort_key)
+ ['1', '2', '10']
+
+ Users can further customize ``natsort`` sorting behavior with the
``key``
+ and/or ``alg`` options (see details in the `Further Customizing
Natsort`_
+ section).
+
+ The key generated by ``natsort_keygen`` *always* returns a
``tuple``. It
+ does so in the following way (*some details omitted for clarity*):
+
+ 1. Assume the input is a string, and attempt to split it into
numbers and
+ non-numbers using regular expressions. Numbers are then
converted into
+ either ``int`` or ``float``.
+ 2. If the above fails because the input is not a string, assume
the input
+ is some other sequence (e.g. ``list`` or ``tuple``), and
recursively
+ apply the key to each element of the sequence.
+ 3. If the above fails because the input is not iterable, assume
the input
+ is an ``int`` or ``float``, and just return the input in a
``tuple``.
+
+ Because a ``tuple`` is always returned, a ``TypeError`` should not
be common
+ unless one tries to do something odd like sort an ``int`` against
a ``list``.
+
+ ``natsort`` gave me results I didn't expect, and it's a terrible
library!
+ Did you try to debug using the above advice? If so, and you still
cannot figure out
+ the error, then please `file an issue
<https://github.com/SethMMorton/natsort/issues/new>`_.
+
Shell script
------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/README.rst new/natsort-5.3.3/README.rst
--- old/natsort-5.3.2/README.rst 2018-05-18 05:39:08.000000000 +0200
+++ new/natsort-5.3.3/README.rst 2018-07-03 05:52:16.000000000 +0200
@@ -33,6 +33,7 @@
`this post <https://opensource.stackexchange.com/q/5941/8999>`_ for an
explanation into why.
+ - `FAQ`_
- `Optional Dependencies`_
- `fastnumbers <https://pypi.org/project/fastnumbers>`_ >= 2.0.0
@@ -92,6 +93,9 @@
Please see `Generating a Reusable Sorting Key and Sorting In-Place`_ for
an alternate way to sort in-place naturally.
+Examples
+--------
+
Sorting Versions
++++++++++++++++
@@ -177,6 +181,15 @@
All of the available customizations can be found in the documentation for
`the ns enum <http://natsort.readthedocs.io/en/master/ns_class.html>`_.
+You can also add your own custom transformation functions with the ``key``
argument.
+These can be used with ``alg`` if you wish.
+
+.. code-block:: python
+
+ >>> a = ['apple2.50', '2.3apple']
+ >>> natsorted(a, key=lambda x: x.replace('apple', ''), alg=ns.REAL)
+ ['2.3apple', 'apple2.50']
+
Sorting Mixed Types
+++++++++++++++++++
@@ -243,6 +256,66 @@
- `sorting file paths correctly
<http://natsort.readthedocs.io/en/master/examples.html#path-sort>`_
- `allow custom sorting keys
<http://natsort.readthedocs.io/en/master/examples.html#custom-sort>`_
+FAQ
+---
+
+How do I debug ``natsort.natsorted()``?
+ The best way to debug ``natsorted()`` is to generate a key using
``natsort_keygen()``
+ with the same options being passed to ``natsorted``. One can take a look at
+ exactly what is being done with their input using this key - it is highly
recommended
+ to `look at this issue describing how to debug
<https://github.com/SethMMorton/natsort/issues/13#issuecomment-50422375>`_
+ for *how* to debug, and also to review the
+ `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_
+ page for *why* ``natsort`` is doing that to your data.
+
+ If you are trying to sort custom classes and running into trouble, please
take a look at
+ https://github.com/SethMMorton/natsort/issues/60. In short,
+ custom classes are not likely to be sorted correctly if one relies
+ on the behavior of ``__lt__`` and the other rich comparison operators in
their
+ custom class - it is better to use a ``key`` function with ``natsort``, or
+ use the ``natsort`` key as part of your rich comparison operator
definition.
+
+How *does* ``natsort`` work?
+ If you don't want to read `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_,
+ here is a quick primer.
+
+ ``natsort`` provides a `key function
<https://docs.python.org/3/howto/sorting.html#key-functions>`_
+ that can be passed to `list.sort()
<https://docs.python.org/3/library/stdtypes.html#list.sort>`_
+ or `sorted() <https://docs.python.org/3/library/functions.html#sorted>`_
in order to
+ modify the default sorting behavior. This key is generated on-demand with
the
+ key generator ``natsort.natsort_keygen()``. ``natsort.natsorted()`` is
essentially
+ a wrapper for the following code:
+
+ .. code-block:: python
+
+ >>> from natsort import natsort_keygen
+ >>> natsort_key = natsort_keygen()
+ >>> sorted(['1', '10', '2'], key=natsort_key)
+ ['1', '2', '10']
+
+ Users can further customize ``natsort`` sorting behavior with the ``key``
+ and/or ``alg`` options (see details in the `Further Customizing Natsort`_
+ section).
+
+ The key generated by ``natsort_keygen`` *always* returns a ``tuple``. It
+ does so in the following way (*some details omitted for clarity*):
+
+ 1. Assume the input is a string, and attempt to split it into numbers and
+ non-numbers using regular expressions. Numbers are then converted into
+ either ``int`` or ``float``.
+ 2. If the above fails because the input is not a string, assume the input
+ is some other sequence (e.g. ``list`` or ``tuple``), and recursively
+ apply the key to each element of the sequence.
+ 3. If the above fails because the input is not iterable, assume the input
+ is an ``int`` or ``float``, and just return the input in a ``tuple``.
+
+ Because a ``tuple`` is always returned, a ``TypeError`` should not be
common
+ unless one tries to do something odd like sort an ``int`` against a
``list``.
+
+``natsort`` gave me results I didn't expect, and it's a terrible library!
+ Did you try to debug using the above advice? If so, and you still cannot
figure out
+ the error, then please `file an issue
<https://github.com/SethMMorton/natsort/issues/new>`_.
+
Shell script
------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/docs/source/changelog.rst
new/natsort-5.3.3/docs/source/changelog.rst
--- old/natsort-5.3.2/docs/source/changelog.rst 2018-05-18 05:43:44.000000000
+0200
+++ new/natsort-5.3.3/docs/source/changelog.rst 2018-07-08 02:17:07.000000000
+0200
@@ -3,14 +3,21 @@
Changelog
---------
-05-17-2018 v. X.X.X
+07-07-2018 v. 5.3.3
++++++++++++++++++++
+
+ - Update docs with a FAQ and quick how-it-works.
+ - Fix a StopIteration error in the testing code.
+ - Enable Python 3.7 support in Travis-CI.
+
+05-17-2018 v. 5.3.2
+++++++++++++++++++
- Fix bug that prevented install on old versions of setuptools.
- Revert layout from src/natsort/ back to natsort/ to make user
testing simpler.
-05-14-2018 v. 5.3.2
+05-14-2018 v. 5.3.1
+++++++++++++++++++
- No bugfixes or features, just infrastructure and installation updates.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/docs/source/conf.py
new/natsort-5.3.3/docs/source/conf.py
--- old/natsort-5.3.2/docs/source/conf.py 2018-05-18 05:43:44.000000000
+0200
+++ new/natsort-5.3.3/docs/source/conf.py 2018-07-08 02:17:07.000000000
+0200
@@ -56,7 +56,7 @@
# built documents.
#
# The full version, including alpha/beta/rc tags.
-release = '5.3.2'
+release = '5.3.3'
# The short X.Y version.
version = '.'.join(release.split('.')[0:2])
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/docs/source/intro.rst
new/natsort-5.3.3/docs/source/intro.rst
--- old/natsort-5.3.2/docs/source/intro.rst 2018-05-18 05:39:08.000000000
+0200
+++ new/natsort-5.3.3/docs/source/intro.rst 2018-07-03 05:52:16.000000000
+0200
@@ -9,15 +9,6 @@
- Source Code: https://github.com/SethMMorton/natsort
- Downloads: https://pypi.org/project/natsort/
- Documentation: http://natsort.readthedocs.io/
-
- - :ref:`Examples and Recipes <examples>`
- - :ref:`How Does Natsort Work? <howitworks>`
- - :ref:`API <api>`
- - **NOTE**: The old documentation at pythonhosted.org has been taken down
- with no redirects. Please see
- `this post <https://opensource.stackexchange.com/q/5941/8999>`_ for an
- explanation into why.
-
- Optional Dependencies:
- `fastnumbers <https://pypi.org/project/fastnumbers>`_ >= 2.0.0
@@ -96,6 +87,9 @@
Please see `Generating a Reusable Sorting Key and Sorting In-Place`_ for
an alternate way to sort in-place naturally.
+Examples
+--------
+
Sorting Versions
++++++++++++++++
@@ -179,7 +173,16 @@
True
All of the available customizations can be found in the documentation for
-the ``ns`` enum :class:`~natsort.ns`.
+the :class:`~natsort.ns` enum.
+
+You can also add your own custom transformation functions with the ``key``
argument.
+These can be used with ``alg`` if you wish:
+
+.. code-block:: python
+
+ >>> a = ['apple2.50', '2.3apple']
+ >>> natsorted(a, key=lambda x: x.replace('apple', ''), alg=ns.REAL)
+ ['2.3apple', 'apple2.50']
Sorting Mixed Types
+++++++++++++++++++
@@ -242,10 +245,71 @@
+++++++++++++++++++
- recursively descend into lists of lists
+ - automatic unicode normalization of input data
- controlling the case-sensitivity (see :ref:`case_sort`)
- sorting file paths correctly (see :ref:`path_sort`)
- allow custom sorting keys (see :ref:`custom_sort`)
+FAQ
+---
+
+How do I debug :func:`~natsorted`?
+ The best way to debug :func:`~natsorted` is to generate a key using
:func:`~natsort_keygen`
+ with the same options being passed to :func:`~natsorted`. One can take a
look at
+ exactly what is being done with their input using this key - it is highly
recommended
+ to `look at this issue describing how to debug
<https://github.com/SethMMorton/natsort/issues/13#issuecomment-50422375>`_
+ for *how* to debug, and also to review the
+ `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_
+ page for *why* :mod:`natsort` is doing that to your data.
+
+ If you are trying to sort custom classes and running into trouble, please
take a look at
+ https://github.com/SethMMorton/natsort/issues/60. In short,
+ custom classes are not likely to be sorted correctly if one relies
+ on the behavior of ``__lt__`` and the other rich comparison operators in
their
+ custom class - it is better to use a ``key`` function with :mod:`natsort`,
or
+ use the :mod:`natsort` key as part of your rich comparison operator
definition.
+
+How *does* :mod:`natsort` work?
+ If you don't want to read `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_,
+ here is a quick primer.
+
+ :mod:`natsort` provides a `key function
<https://docs.python.org/3/howto/sorting.html#key-functions>`_
+ that can be passed to `list.sort()
<https://docs.python.org/3/library/stdtypes.html#list.sort>`_
+ or `sorted() <https://docs.python.org/3/library/functions.html#sorted>`_
in order to
+ modify the default sorting behavior. This key is generated on-demand with
the
+ key generator :func:`natsort.natsort_keygen`. :func:`natsort.natsorted`
is essentially
+ a wrapper for the following code:
+
+ .. code-block:: python
+
+ >>> from natsort import natsort_keygen
+ >>> natsort_key = natsort_keygen()
+ >>> sorted(['1', '10', '2'], key=natsort_key)
+ ['1', '2', '10']
+
+ Users can further customize :mod:`natsort` sorting behavior with the
``key``
+ and/or ``alg`` options (see details in the `Further Customizing Natsort`_
+ section).
+
+ The key generated by :func:`natsort.natsort_keygen` *always* returns a
:class:`tuple`. It
+ does so in the following way (*some details omitted for clarity*):
+
+ 1. Assume the input is a string, and attempt to split it into numbers and
+ non-numbers using regular expressions. Numbers are then converted into
+ either :class:`int` or :class:`float`.
+ 2. If the above fails because the input is not a string, assume the input
+ is some other sequence (e.g. :class:`list` or :class:`tuple`), and
recursively
+ apply the key to each element of the sequence.
+ 3. If the above fails because the input is not iterable, assume the input
+ is an :class:`int` or :class:`float`, and just return the input in a
:class:`tuple`.
+
+ Because a :class:`tuple` is always returned, a :exc:`TypeError` should not
be common
+ unless one tries to do something odd like sort an :class:`int` against a
:class:`list`.
+
+:mod:`natsort` gave me results I didn't expect, and it's a terrible library!
+ Did you try to debug using the above advice? If so, and you still cannot
figure out
+ the error, then please `file an issue
<https://github.com/SethMMorton/natsort/issues/new>`_.
+
Shell script
------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/natsort/_version.py
new/natsort-5.3.3/natsort/_version.py
--- old/natsort-5.3.2/natsort/_version.py 2018-05-18 05:43:44.000000000
+0200
+++ new/natsort-5.3.3/natsort/_version.py 2018-07-08 02:17:07.000000000
+0200
@@ -6,4 +6,4 @@
absolute_import
)
-__version__ = '5.3.2'
+__version__ = '5.3.3'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/natsort/unicode_numbers.py
new/natsort-5.3.3/natsort/unicode_numbers.py
--- old/natsort-5.3.2/natsort/unicode_numbers.py 2018-05-18
05:39:08.000000000 +0200
+++ new/natsort-5.3.3/natsort/unicode_numbers.py 2018-07-02
08:41:29.000000000 +0200
@@ -172,94 +172,119 @@
0X109F6, 0X109F7, 0X109F8, 0X109F9, 0X109FA, 0X109FB,
0X109FC, 0X109FD, 0X109FE, 0X109FF, 0X10A40, 0X10A41,
0X10A42, 0X10A43, 0X10A44, 0X10A45, 0X10A46, 0X10A47,
- 0X10A7D, 0X10A7E, 0X10A9D, 0X10A9E, 0X10A9F, 0X10AEB,
- 0X10AEC, 0X10AED, 0X10AEE, 0X10AEF, 0X10B58, 0X10B59,
- 0X10B5A, 0X10B5B, 0X10B5C, 0X10B5D, 0X10B5E, 0X10B5F,
- 0X10B78, 0X10B79, 0X10B7A, 0X10B7B, 0X10B7C, 0X10B7D,
- 0X10B7E, 0X10B7F, 0X10BA9, 0X10BAA, 0X10BAB, 0X10BAC,
- 0X10BAD, 0X10BAE, 0X10BAF, 0X10CFA, 0X10CFB, 0X10CFC,
- 0X10CFD, 0X10CFE, 0X10CFF, 0X10E60, 0X10E61, 0X10E62,
- 0X10E63, 0X10E64, 0X10E65, 0X10E66, 0X10E67, 0X10E68,
- 0X10E69, 0X10E6A, 0X10E6B, 0X10E6C, 0X10E6D, 0X10E6E,
- 0X10E6F, 0X10E70, 0X10E71, 0X10E72, 0X10E73, 0X10E74,
- 0X10E75, 0X10E76, 0X10E77, 0X10E78, 0X10E79, 0X10E7A,
- 0X10E7B, 0X10E7C, 0X10E7D, 0X10E7E, 0X11052, 0X11053,
- 0X11054, 0X11055, 0X11056, 0X11057, 0X11058, 0X11059,
- 0X1105A, 0X1105B, 0X1105C, 0X1105D, 0X1105E, 0X1105F,
- 0X11060, 0X11061, 0X11062, 0X11063, 0X11064, 0X11065,
- 0X11066, 0X11067, 0X11068, 0X11069, 0X1106A, 0X1106B,
- 0X1106C, 0X1106D, 0X1106E, 0X1106F, 0X110F0, 0X110F1,
- 0X110F2, 0X110F3, 0X110F4, 0X110F5, 0X110F6, 0X110F7,
- 0X110F8, 0X110F9, 0X11136, 0X11137, 0X11138, 0X11139,
- 0X1113A, 0X1113B, 0X1113C, 0X1113D, 0X1113E, 0X1113F,
- 0X111D0, 0X111D1, 0X111D2, 0X111D3, 0X111D4, 0X111D5,
- 0X111D6, 0X111D7, 0X111D8, 0X111D9, 0X111E1, 0X111E2,
- 0X111E3, 0X111E4, 0X111E5, 0X111E6, 0X111E7, 0X111E8,
- 0X111E9, 0X111EA, 0X111EB, 0X111EC, 0X111ED, 0X111EE,
- 0X111EF, 0X111F0, 0X111F1, 0X111F2, 0X111F3, 0X111F4,
- 0X112F0, 0X112F1, 0X112F2, 0X112F3, 0X112F4, 0X112F5,
- 0X112F6, 0X112F7, 0X112F8, 0X112F9, 0X11450, 0X11451,
- 0X11452, 0X11453, 0X11454, 0X11455, 0X11456, 0X11457,
- 0X11458, 0X11459, 0X114D0, 0X114D1, 0X114D2, 0X114D3,
- 0X114D4, 0X114D5, 0X114D6, 0X114D7, 0X114D8, 0X114D9,
- 0X11650, 0X11651, 0X11652, 0X11653, 0X11654, 0X11655,
- 0X11656, 0X11657, 0X11658, 0X11659, 0X116C0, 0X116C1,
- 0X116C2, 0X116C3, 0X116C4, 0X116C5, 0X116C6, 0X116C7,
- 0X116C8, 0X116C9, 0X11730, 0X11731, 0X11732, 0X11733,
- 0X11734, 0X11735, 0X11736, 0X11737, 0X11738, 0X11739,
- 0X1173A, 0X1173B, 0X118E0, 0X118E1, 0X118E2, 0X118E3,
- 0X118E4, 0X118E5, 0X118E6, 0X118E7, 0X118E8, 0X118E9,
- 0X118EA, 0X118EB, 0X118EC, 0X118ED, 0X118EE, 0X118EF,
- 0X118F0, 0X118F1, 0X118F2, 0X11C50, 0X11C51, 0X11C52,
- 0X11C53, 0X11C54, 0X11C55, 0X11C56, 0X11C57, 0X11C58,
- 0X11C59, 0X11C5A, 0X11C5B, 0X11C5C, 0X11C5D, 0X11C5E,
- 0X11C5F, 0X11C60, 0X11C61, 0X11C62, 0X11C63, 0X11C64,
- 0X11C65, 0X11C66, 0X11C67, 0X11C68, 0X11C69, 0X11C6A,
- 0X11C6B, 0X11C6C, 0X11D50, 0X11D51, 0X11D52, 0X11D53,
- 0X11D54, 0X11D55, 0X11D56, 0X11D57, 0X11D58, 0X11D59,
- 0X12400, 0X12401, 0X12402, 0X12403, 0X12404, 0X12405,
- 0X12406, 0X12407, 0X12408, 0X12409, 0X1240A, 0X1240B,
- 0X1240C, 0X1240D, 0X1240E, 0X1240F, 0X12410, 0X12411,
- 0X12412, 0X12413, 0X12414, 0X12415, 0X12416, 0X12417,
- 0X12418, 0X12419, 0X1241A, 0X1241B, 0X1241C, 0X1241D,
- 0X1241E, 0X1241F, 0X12420, 0X12421, 0X12422, 0X12423,
- 0X12424, 0X12425, 0X12426, 0X12427, 0X12428, 0X12429,
- 0X1242A, 0X1242B, 0X1242C, 0X1242D, 0X1242E, 0X1242F,
- 0X12430, 0X12431, 0X12432, 0X12433, 0X12434, 0X12435,
- 0X12436, 0X12437, 0X12438, 0X12439, 0X1243A, 0X1243B,
- 0X1243C, 0X1243D, 0X1243E, 0X1243F, 0X12440, 0X12441,
- 0X12442, 0X12443, 0X12444, 0X12445, 0X12446, 0X12447,
- 0X12448, 0X12449, 0X1244A, 0X1244B, 0X1244C, 0X1244D,
- 0X1244E, 0X1244F, 0X12450, 0X12451, 0X12452, 0X12453,
- 0X12454, 0X12455, 0X12456, 0X12457, 0X12458, 0X12459,
- 0X1245A, 0X1245B, 0X1245C, 0X1245D, 0X1245E, 0X1245F,
- 0X12460, 0X12461, 0X12462, 0X12463, 0X12464, 0X12465,
- 0X12466, 0X12467, 0X12468, 0X12469, 0X1246A, 0X1246B,
- 0X1246C, 0X1246D, 0X1246E, 0X16A60, 0X16A61, 0X16A62,
- 0X16A63, 0X16A64, 0X16A65, 0X16A66, 0X16A67, 0X16A68,
- 0X16A69, 0X16B50, 0X16B51, 0X16B52, 0X16B53, 0X16B54,
- 0X16B55, 0X16B56, 0X16B57, 0X16B58, 0X16B59, 0X16B5B,
- 0X16B5C, 0X16B5D, 0X16B5E, 0X16B5F, 0X16B60, 0X16B61,
+ 0X10A48, 0X10A7D, 0X10A7E, 0X10A9D, 0X10A9E, 0X10A9F,
+ 0X10AEB, 0X10AEC, 0X10AED, 0X10AEE, 0X10AEF, 0X10B58,
+ 0X10B59, 0X10B5A, 0X10B5B, 0X10B5C, 0X10B5D, 0X10B5E,
+ 0X10B5F, 0X10B78, 0X10B79, 0X10B7A, 0X10B7B, 0X10B7C,
+ 0X10B7D, 0X10B7E, 0X10B7F, 0X10BA9, 0X10BAA, 0X10BAB,
+ 0X10BAC, 0X10BAD, 0X10BAE, 0X10BAF, 0X10CFA, 0X10CFB,
+ 0X10CFC, 0X10CFD, 0X10CFE, 0X10CFF, 0X10D30, 0X10D31,
+ 0X10D32, 0X10D33, 0X10D34, 0X10D35, 0X10D36, 0X10D37,
+ 0X10D38, 0X10D39, 0X10E60, 0X10E61, 0X10E62, 0X10E63,
+ 0X10E64, 0X10E65, 0X10E66, 0X10E67, 0X10E68, 0X10E69,
+ 0X10E6A, 0X10E6B, 0X10E6C, 0X10E6D, 0X10E6E, 0X10E6F,
+ 0X10E70, 0X10E71, 0X10E72, 0X10E73, 0X10E74, 0X10E75,
+ 0X10E76, 0X10E77, 0X10E78, 0X10E79, 0X10E7A, 0X10E7B,
+ 0X10E7C, 0X10E7D, 0X10E7E, 0X10F1D, 0X10F1E, 0X10F1F,
+ 0X10F20, 0X10F21, 0X10F22, 0X10F23, 0X10F24, 0X10F25,
+ 0X10F26, 0X10F51, 0X10F52, 0X10F53, 0X10F54, 0X11052,
+ 0X11053, 0X11054, 0X11055, 0X11056, 0X11057, 0X11058,
+ 0X11059, 0X1105A, 0X1105B, 0X1105C, 0X1105D, 0X1105E,
+ 0X1105F, 0X11060, 0X11061, 0X11062, 0X11063, 0X11064,
+ 0X11065, 0X11066, 0X11067, 0X11068, 0X11069, 0X1106A,
+ 0X1106B, 0X1106C, 0X1106D, 0X1106E, 0X1106F, 0X110F0,
+ 0X110F1, 0X110F2, 0X110F3, 0X110F4, 0X110F5, 0X110F6,
+ 0X110F7, 0X110F8, 0X110F9, 0X11136, 0X11137, 0X11138,
+ 0X11139, 0X1113A, 0X1113B, 0X1113C, 0X1113D, 0X1113E,
+ 0X1113F, 0X111D0, 0X111D1, 0X111D2, 0X111D3, 0X111D4,
+ 0X111D5, 0X111D6, 0X111D7, 0X111D8, 0X111D9, 0X111E1,
+ 0X111E2, 0X111E3, 0X111E4, 0X111E5, 0X111E6, 0X111E7,
+ 0X111E8, 0X111E9, 0X111EA, 0X111EB, 0X111EC, 0X111ED,
+ 0X111EE, 0X111EF, 0X111F0, 0X111F1, 0X111F2, 0X111F3,
+ 0X111F4, 0X112F0, 0X112F1, 0X112F2, 0X112F3, 0X112F4,
+ 0X112F5, 0X112F6, 0X112F7, 0X112F8, 0X112F9, 0X11450,
+ 0X11451, 0X11452, 0X11453, 0X11454, 0X11455, 0X11456,
+ 0X11457, 0X11458, 0X11459, 0X114D0, 0X114D1, 0X114D2,
+ 0X114D3, 0X114D4, 0X114D5, 0X114D6, 0X114D7, 0X114D8,
+ 0X114D9, 0X11650, 0X11651, 0X11652, 0X11653, 0X11654,
+ 0X11655, 0X11656, 0X11657, 0X11658, 0X11659, 0X116C0,
+ 0X116C1, 0X116C2, 0X116C3, 0X116C4, 0X116C5, 0X116C6,
+ 0X116C7, 0X116C8, 0X116C9, 0X11730, 0X11731, 0X11732,
+ 0X11733, 0X11734, 0X11735, 0X11736, 0X11737, 0X11738,
+ 0X11739, 0X1173A, 0X1173B, 0X118E0, 0X118E1, 0X118E2,
+ 0X118E3, 0X118E4, 0X118E5, 0X118E6, 0X118E7, 0X118E8,
+ 0X118E9, 0X118EA, 0X118EB, 0X118EC, 0X118ED, 0X118EE,
+ 0X118EF, 0X118F0, 0X118F1, 0X118F2, 0X11C50, 0X11C51,
+ 0X11C52, 0X11C53, 0X11C54, 0X11C55, 0X11C56, 0X11C57,
+ 0X11C58, 0X11C59, 0X11C5A, 0X11C5B, 0X11C5C, 0X11C5D,
+ 0X11C5E, 0X11C5F, 0X11C60, 0X11C61, 0X11C62, 0X11C63,
+ 0X11C64, 0X11C65, 0X11C66, 0X11C67, 0X11C68, 0X11C69,
+ 0X11C6A, 0X11C6B, 0X11C6C, 0X11D50, 0X11D51, 0X11D52,
+ 0X11D53, 0X11D54, 0X11D55, 0X11D56, 0X11D57, 0X11D58,
+ 0X11D59, 0X11DA0, 0X11DA1, 0X11DA2, 0X11DA3, 0X11DA4,
+ 0X11DA5, 0X11DA6, 0X11DA7, 0X11DA8, 0X11DA9, 0X12400,
+ 0X12401, 0X12402, 0X12403, 0X12404, 0X12405, 0X12406,
+ 0X12407, 0X12408, 0X12409, 0X1240A, 0X1240B, 0X1240C,
+ 0X1240D, 0X1240E, 0X1240F, 0X12410, 0X12411, 0X12412,
+ 0X12413, 0X12414, 0X12415, 0X12416, 0X12417, 0X12418,
+ 0X12419, 0X1241A, 0X1241B, 0X1241C, 0X1241D, 0X1241E,
+ 0X1241F, 0X12420, 0X12421, 0X12422, 0X12423, 0X12424,
+ 0X12425, 0X12426, 0X12427, 0X12428, 0X12429, 0X1242A,
+ 0X1242B, 0X1242C, 0X1242D, 0X1242E, 0X1242F, 0X12430,
+ 0X12431, 0X12432, 0X12433, 0X12434, 0X12435, 0X12436,
+ 0X12437, 0X12438, 0X12439, 0X1243A, 0X1243B, 0X1243C,
+ 0X1243D, 0X1243E, 0X1243F, 0X12440, 0X12441, 0X12442,
+ 0X12443, 0X12444, 0X12445, 0X12446, 0X12447, 0X12448,
+ 0X12449, 0X1244A, 0X1244B, 0X1244C, 0X1244D, 0X1244E,
+ 0X1244F, 0X12450, 0X12451, 0X12452, 0X12453, 0X12454,
+ 0X12455, 0X12456, 0X12457, 0X12458, 0X12459, 0X1245A,
+ 0X1245B, 0X1245C, 0X1245D, 0X1245E, 0X1245F, 0X12460,
+ 0X12461, 0X12462, 0X12463, 0X12464, 0X12465, 0X12466,
+ 0X12467, 0X12468, 0X12469, 0X1246A, 0X1246B, 0X1246C,
+ 0X1246D, 0X1246E, 0X16A60, 0X16A61, 0X16A62, 0X16A63,
+ 0X16A64, 0X16A65, 0X16A66, 0X16A67, 0X16A68, 0X16A69,
+ 0X16B50, 0X16B51, 0X16B52, 0X16B53, 0X16B54, 0X16B55,
+ 0X16B56, 0X16B57, 0X16B58, 0X16B59, 0X16B5B, 0X16B5C,
+ 0X16B5D, 0X16B5E, 0X16B5F, 0X16B60, 0X16B61, 0X16E80,
+ 0X16E81, 0X16E82, 0X16E83, 0X16E84, 0X16E85, 0X16E86,
+ 0X16E87, 0X16E88, 0X16E89, 0X16E8A, 0X16E8B, 0X16E8C,
+ 0X16E8D, 0X16E8E, 0X16E8F, 0X16E90, 0X16E91, 0X16E92,
+ 0X16E93, 0X16E94, 0X16E95, 0X16E96, 0X1D2E0, 0X1D2E1,
+ 0X1D2E2, 0X1D2E3, 0X1D2E4, 0X1D2E5, 0X1D2E6, 0X1D2E7,
+ 0X1D2E8, 0X1D2E9, 0X1D2EA, 0X1D2EB, 0X1D2EC, 0X1D2ED,
+ 0X1D2EE, 0X1D2EF, 0X1D2F0, 0X1D2F1, 0X1D2F2, 0X1D2F3,
0X1D360, 0X1D361, 0X1D362, 0X1D363, 0X1D364, 0X1D365,
0X1D366, 0X1D367, 0X1D368, 0X1D369, 0X1D36A, 0X1D36B,
0X1D36C, 0X1D36D, 0X1D36E, 0X1D36F, 0X1D370, 0X1D371,
- 0X1D7CE, 0X1D7CF, 0X1D7D0, 0X1D7D1, 0X1D7D2, 0X1D7D3,
- 0X1D7D4, 0X1D7D5, 0X1D7D6, 0X1D7D7, 0X1D7D8, 0X1D7D9,
- 0X1D7DA, 0X1D7DB, 0X1D7DC, 0X1D7DD, 0X1D7DE, 0X1D7DF,
- 0X1D7E0, 0X1D7E1, 0X1D7E2, 0X1D7E3, 0X1D7E4, 0X1D7E5,
- 0X1D7E6, 0X1D7E7, 0X1D7E8, 0X1D7E9, 0X1D7EA, 0X1D7EB,
- 0X1D7EC, 0X1D7ED, 0X1D7EE, 0X1D7EF, 0X1D7F0, 0X1D7F1,
- 0X1D7F2, 0X1D7F3, 0X1D7F4, 0X1D7F5, 0X1D7F6, 0X1D7F7,
- 0X1D7F8, 0X1D7F9, 0X1D7FA, 0X1D7FB, 0X1D7FC, 0X1D7FD,
- 0X1D7FE, 0X1D7FF, 0X1E8C7, 0X1E8C8, 0X1E8C9, 0X1E8CA,
- 0X1E8CB, 0X1E8CC, 0X1E8CD, 0X1E8CE, 0X1E8CF, 0X1E950,
- 0X1E951, 0X1E952, 0X1E953, 0X1E954, 0X1E955, 0X1E956,
- 0X1E957, 0X1E958, 0X1E959, 0X1F100, 0X1F101, 0X1F102,
- 0X1F103, 0X1F104, 0X1F105, 0X1F106, 0X1F107, 0X1F108,
- 0X1F109, 0X1F10A, 0X1F10B, 0X1F10C, 0X20001, 0X20064,
- 0X200E2, 0X20121, 0X2092A, 0X20983, 0X2098C, 0X2099C,
- 0X20AEA, 0X20AFD, 0X20B19, 0X22390, 0X22998, 0X23B1B,
- 0X2626D, 0X2F890,
+ 0X1D372, 0X1D373, 0X1D374, 0X1D375, 0X1D376, 0X1D377,
+ 0X1D378, 0X1D7CE, 0X1D7CF, 0X1D7D0, 0X1D7D1, 0X1D7D2,
+ 0X1D7D3, 0X1D7D4, 0X1D7D5, 0X1D7D6, 0X1D7D7, 0X1D7D8,
+ 0X1D7D9, 0X1D7DA, 0X1D7DB, 0X1D7DC, 0X1D7DD, 0X1D7DE,
+ 0X1D7DF, 0X1D7E0, 0X1D7E1, 0X1D7E2, 0X1D7E3, 0X1D7E4,
+ 0X1D7E5, 0X1D7E6, 0X1D7E7, 0X1D7E8, 0X1D7E9, 0X1D7EA,
+ 0X1D7EB, 0X1D7EC, 0X1D7ED, 0X1D7EE, 0X1D7EF, 0X1D7F0,
+ 0X1D7F1, 0X1D7F2, 0X1D7F3, 0X1D7F4, 0X1D7F5, 0X1D7F6,
+ 0X1D7F7, 0X1D7F8, 0X1D7F9, 0X1D7FA, 0X1D7FB, 0X1D7FC,
+ 0X1D7FD, 0X1D7FE, 0X1D7FF, 0X1E8C7, 0X1E8C8, 0X1E8C9,
+ 0X1E8CA, 0X1E8CB, 0X1E8CC, 0X1E8CD, 0X1E8CE, 0X1E8CF,
+ 0X1E950, 0X1E951, 0X1E952, 0X1E953, 0X1E954, 0X1E955,
+ 0X1E956, 0X1E957, 0X1E958, 0X1E959, 0X1EC71, 0X1EC72,
+ 0X1EC73, 0X1EC74, 0X1EC75, 0X1EC76, 0X1EC77, 0X1EC78,
+ 0X1EC79, 0X1EC7A, 0X1EC7B, 0X1EC7C, 0X1EC7D, 0X1EC7E,
+ 0X1EC7F, 0X1EC80, 0X1EC81, 0X1EC82, 0X1EC83, 0X1EC84,
+ 0X1EC85, 0X1EC86, 0X1EC87, 0X1EC88, 0X1EC89, 0X1EC8A,
+ 0X1EC8B, 0X1EC8C, 0X1EC8D, 0X1EC8E, 0X1EC8F, 0X1EC90,
+ 0X1EC91, 0X1EC92, 0X1EC93, 0X1EC94, 0X1EC95, 0X1EC96,
+ 0X1EC97, 0X1EC98, 0X1EC99, 0X1EC9A, 0X1EC9B, 0X1EC9C,
+ 0X1EC9D, 0X1EC9E, 0X1EC9F, 0X1ECA0, 0X1ECA1, 0X1ECA2,
+ 0X1ECA3, 0X1ECA4, 0X1ECA5, 0X1ECA6, 0X1ECA7, 0X1ECA8,
+ 0X1ECA9, 0X1ECAA, 0X1ECAB, 0X1ECAD, 0X1ECAE, 0X1ECAF,
+ 0X1ECB1, 0X1ECB2, 0X1ECB3, 0X1ECB4, 0X1F100, 0X1F101,
+ 0X1F102, 0X1F103, 0X1F104, 0X1F105, 0X1F106, 0X1F107,
+ 0X1F108, 0X1F109, 0X1F10A, 0X1F10B, 0X1F10C, 0X20001,
+ 0X20064, 0X200E2, 0X20121, 0X2092A, 0X20983, 0X2098C,
+ 0X2099C, 0X20AEA, 0X20AFD, 0X20B19, 0X22390, 0X22998,
+ 0X23B1B, 0X2626D, 0X2F890,
)
# Convert each hex into the literal Unicode character.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/natsort.egg-info/PKG-INFO
new/natsort-5.3.3/natsort.egg-info/PKG-INFO
--- old/natsort-5.3.2/natsort.egg-info/PKG-INFO 2018-05-18 05:47:13.000000000
+0200
+++ new/natsort-5.3.3/natsort.egg-info/PKG-INFO 2018-07-08 02:18:38.000000000
+0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: natsort
-Version: 5.3.2
+Version: 5.3.3
Summary: Simple yet flexible natural sorting in Python.
Home-page: https://github.com/SethMMorton/natsort
Author: Seth M. Morton
@@ -41,6 +41,7 @@
`this post
<https://opensource.stackexchange.com/q/5941/8999>`_ for an
explanation into why.
+ - `FAQ`_
- `Optional Dependencies`_
- `fastnumbers <https://pypi.org/project/fastnumbers>`_ >= 2.0.0
@@ -100,6 +101,9 @@
Please see `Generating a Reusable Sorting Key and Sorting In-Place`_
for
an alternate way to sort in-place naturally.
+ Examples
+ --------
+
Sorting Versions
++++++++++++++++
@@ -185,6 +189,15 @@
All of the available customizations can be found in the documentation
for
`the ns enum <http://natsort.readthedocs.io/en/master/ns_class.html>`_.
+ You can also add your own custom transformation functions with the
``key`` argument.
+ These can be used with ``alg`` if you wish.
+
+ .. code-block:: python
+
+ >>> a = ['apple2.50', '2.3apple']
+ >>> natsorted(a, key=lambda x: x.replace('apple', ''), alg=ns.REAL)
+ ['2.3apple', 'apple2.50']
+
Sorting Mixed Types
+++++++++++++++++++
@@ -251,6 +264,66 @@
- `sorting file paths correctly
<http://natsort.readthedocs.io/en/master/examples.html#path-sort>`_
- `allow custom sorting keys
<http://natsort.readthedocs.io/en/master/examples.html#custom-sort>`_
+ FAQ
+ ---
+
+ How do I debug ``natsort.natsorted()``?
+ The best way to debug ``natsorted()`` is to generate a key using
``natsort_keygen()``
+ with the same options being passed to ``natsorted``. One can take
a look at
+ exactly what is being done with their input using this key - it is
highly recommended
+ to `look at this issue describing how to debug
<https://github.com/SethMMorton/natsort/issues/13#issuecomment-50422375>`_
+ for *how* to debug, and also to review the
+ `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_
+ page for *why* ``natsort`` is doing that to your data.
+
+ If you are trying to sort custom classes and running into trouble,
please take a look at
+ https://github.com/SethMMorton/natsort/issues/60. In short,
+ custom classes are not likely to be sorted correctly if one relies
+ on the behavior of ``__lt__`` and the other rich comparison
operators in their
+ custom class - it is better to use a ``key`` function with
``natsort``, or
+ use the ``natsort`` key as part of your rich comparison operator
definition.
+
+ How *does* ``natsort`` work?
+ If you don't want to read `How Does Natsort Work?
<http://natsort.readthedocs.io/en/master/howitworks.html>`_,
+ here is a quick primer.
+
+ ``natsort`` provides a `key function
<https://docs.python.org/3/howto/sorting.html#key-functions>`_
+ that can be passed to `list.sort()
<https://docs.python.org/3/library/stdtypes.html#list.sort>`_
+ or `sorted()
<https://docs.python.org/3/library/functions.html#sorted>`_ in order to
+ modify the default sorting behavior. This key is generated
on-demand with the
+ key generator ``natsort.natsort_keygen()``.
``natsort.natsorted()`` is essentially
+ a wrapper for the following code:
+
+ .. code-block:: python
+
+ >>> from natsort import natsort_keygen
+ >>> natsort_key = natsort_keygen()
+ >>> sorted(['1', '10', '2'], key=natsort_key)
+ ['1', '2', '10']
+
+ Users can further customize ``natsort`` sorting behavior with the
``key``
+ and/or ``alg`` options (see details in the `Further Customizing
Natsort`_
+ section).
+
+ The key generated by ``natsort_keygen`` *always* returns a
``tuple``. It
+ does so in the following way (*some details omitted for clarity*):
+
+ 1. Assume the input is a string, and attempt to split it into
numbers and
+ non-numbers using regular expressions. Numbers are then
converted into
+ either ``int`` or ``float``.
+ 2. If the above fails because the input is not a string, assume
the input
+ is some other sequence (e.g. ``list`` or ``tuple``), and
recursively
+ apply the key to each element of the sequence.
+ 3. If the above fails because the input is not iterable, assume
the input
+ is an ``int`` or ``float``, and just return the input in a
``tuple``.
+
+ Because a ``tuple`` is always returned, a ``TypeError`` should not
be common
+ unless one tries to do something odd like sort an ``int`` against
a ``list``.
+
+ ``natsort`` gave me results I didn't expect, and it's a terrible
library!
+ Did you try to debug using the above advice? If so, and you still
cannot figure out
+ the error, then please `file an issue
<https://github.com/SethMMorton/natsort/issues/new>`_.
+
Shell script
------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/setup.cfg new/natsort-5.3.3/setup.cfg
--- old/natsort-5.3.2/setup.cfg 2018-05-18 05:47:13.000000000 +0200
+++ new/natsort-5.3.3/setup.cfg 2018-07-08 02:18:38.000000000 +0200
@@ -1,5 +1,5 @@
[bumpversion]
-current_version = 5.3.2
+current_version = 5.3.3
commit = True
tag = True
tag_name = {new_version}
@@ -46,6 +46,8 @@
[bumpversion:file:docs/source/conf.py]
[bumpversion:file:docs/source/changelog.rst]
+search = X.X.X
+replace = {new_version}
[tool:pytest]
flakes-ignore =
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/setup.py new/natsort-5.3.3/setup.py
--- old/natsort-5.3.2/setup.py 2018-05-18 05:43:44.000000000 +0200
+++ new/natsort-5.3.3/setup.py 2018-07-08 02:17:07.000000000 +0200
@@ -3,7 +3,7 @@
from setuptools import setup, find_packages
setup(
name='natsort',
- version='5.3.2',
+ version='5.3.3',
packages=find_packages(),
install_requires=["argparse; python_version < '2.7'"],
entry_points={'console_scripts': ['natsort = natsort.__main__:main']},
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/natsort-5.3.2/test_natsort/slow_splitters.py
new/natsort-5.3.3/test_natsort/slow_splitters.py
--- old/natsort-5.3.2/test_natsort/slow_splitters.py 2018-04-21
05:11:54.000000000 +0200
+++ new/natsort-5.3.3/test_natsort/slow_splitters.py 2018-07-02
08:33:45.000000000 +0200
@@ -304,7 +304,10 @@
pairs = pairwise(iterable)
# Prime loop by handling first pair specially.
- first, second = next(pairs)
+ try:
+ first, second = next(pairs)
+ except StopIteration:
+ return
if second is None: # Only one element
yield first
elif type(first) in types and type(second) in types:
