-
Notifications
You must be signed in to change notification settings - Fork 14
/
CHANGES.txt
100 lines (73 loc) · 4.04 KB
/
CHANGES.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
Changes
=======
asq v.next
----------
* Adds a convenience alias for ``asq.initiators.query`` as ``asq.query``.
asq 1.3
-------
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``.
asq 1.2.1
---------
* Fixes a problem in setup.py that prevented installation on Python 2.
asq 1.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.
asq 1.1
-------
* 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.
asq 1.0
-------
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.