Asq

-------

There are several minor breaking API changes in this release. Please read
carefully more details:

* Re-assigns copyright from Robert Smallshire to Sixty North AS.

* Adds ``select_with_correspondence()`` query method.

* Renames the ``indexedelement`` module to ``namedelements``.

* Renames the second element of ``IndexedElement`` from ``element`` to
``value``.

* Adds the ``KeyedElement`` ``namedtuple`` to the ``namedelements`` module.
``KeyedElement`` has two elements called ``key`` and ``value``.

* Queryable.to_dictionary() no longer raises an exception if the key_selector
produces duplicate keys. Instead, the values associated with later keys
overwrite those produced by earlier keys. This weakening of the
to_dictionary() constract allows us to maintain Liskov subsstitutability in
light of the specialised default key and value selectors for the overrides
of ``to_dictionary()`` provided for the ``Lookup`` and ``Grouping`` classes.
(See the next two changes for more details).

* Less surprising behaviour for ``Lookup.to_dictionary()``:
The default key and value selectors for ``Lookup.to_dictionary()`` are
overidden, so that the produced dictionary contains a single item for each
``Grouping`` such that the key of each item is the key of the corresponding
``Grouping`` and the value of the item is a list of the elements from the
``Grouping``.

* Less surprising behaviour for ``Grouping.to_dictionary()``:
The default key and value selectors for ``Grouping.to_dictionary()`` are
overidden, so that the produced dictionary contains a single item, such that
the key of the item is the key of the ``Grouping`` and the value of the item
is a ``list`` containing the elements from the ``Grouping``.

---------

* Fixes a problem in setup.py that prevented installation on Python 2.

-------

* The default selector for select_with_index() now produces a new IndexedElement
object for each type which is a namedtuple. As IndexedElement is a tuple this
change is backwards compatibile, but now the more readable item.index and
item.element attributes can be used instead of accessing via indexes zero and
one.

-------

* The selector factories k_(), a_() and m_() have much faster implementations
because they are now simply aliases for itemgetter, attrgetter and
methodcaller from the Python standard library operator module. As a
result, even though they remain backwards API compatible with those in
asq 1.0 their capabilities are also extended somewhat:

* k_ can optionally accept more than one argument (key) and if so, the
selector it produces will return a tuple of multiple looked-up values
rather than a single value.

* a_ can optionally accept more than one argument (key) and if so, the
selector it produces will return a tuple of multiple looked-up values
rather than a single value. Furthermore, the attribute names supplied
in each argument can now contain dots to refer to nested attributes.

* Added asq.selectors.make_selector which will create a selector directly
from a string or integer using attribute or item lookup respectively.

-------

Huge correctness and completeness changes for 1.0 since 0.9. The API now has
feature equivalence with LINQ for objects with 100% test coverage and complete
documentation.

The API has been very much reorganised with some renaming of crucial functions.
The important asq() function is now called query() to prevent a clash with the
package name itself and is found in the asq.initiators package.

For common asq usage you now need to do::

from asq.initiators import query
a = [1, 2, 3]
query(a).select(lambda x: x*x).to_list()

to get started. For more than that, consult the documentation.