hypatia

HomePage: http://pylonsproject.org

Author: Zope Foundation and Contributors

Download: https://pypi.python.org/packages/source/h/hypatia/hypatia-0.1.tar.gz

        Hypatia
=======

A Python indexing and searching system.

See http://github.com/Pylons/hypatia for more information while this package
is in alpha development.


0.1 (2014-02-09)
----------------

- Fix a typo in the Sphinx docs, which causes intersphinx references to
  fail.

0.1a7 (2013-10-08)
------------------

- Add a ``unique_values`` API to field index.

- Sometimes an ``index`` attribute could not be found to resolve a result 
  set when deeply nesting boolean operations (like And and Or).  See 
  https://github.com/Pylons/hypatia/pull/5

- Throw an Unsortable properly when a field index without any docids is used as
  a sort index and ``raise_unsortable`` is ``True``.

0.1a6 (2013-05-30)
------------------

- Add ``check_query`` method to text index to allow for checking if a search
  term is parseable.

0.1a5 (2013-05-06)
------------------

- Added support for Python 3.2 / 3.3.

- Fix signature of TextIndex.sort (it would fail when e.g. raise_unsortable was
  passed).

- Add the a ``sort_type`` keyword argument to ``IIndexSort.sort`` and
  ``IResultSet.sort`` methods.  This value can be passed by calling code to
  control the type of sorting used.

- Add two constants: ``hypatia.interfaces.STABLE`` and
  ``hypatia.interfaces.OPTIMAL``.  These can be used as explicit arguments to
  the ``IIndexSort.sort`` and ``IResultSet.sort`` ``sort_type`` parameter to
  control the stability of sorting.

- The constructor of ``IResultSet`` now accepts a ``sort_type`` keyword
  argument.

- The ResultSet constructed by ``IResultSet.sort`` will be passed the value
  ``hypatia.interfaces.STABLE`` in its constructor to ensure that the second
  and subsequent sorts of the result set will be done as a stable sort, unless
  an explicit ``sort_type`` value is passed to that second sort.

0.1a4 (2013-04-28)
------------------

- Add IResultSet interface definition.

- Normalize keyword argument ordering of IIndexSort.sort and IResultSet.sort.

- Add an argument ``raise_unsortable`` to IIndexSort.sort and IResultSet.sort
  methods.  By default this is ``True``.  It means that iterating over the
  results returned by one of these methods *may* raise a
  ``hypatia.exc.Unsortable`` exception when a member of the docids passed in
  cannot be sorted by the index used to do the sort (e.g. a value for the docid
  is not present in the index).  It defaults to ``True``, which changes the
  default behavior of indexes.  To get the old default behavior back, pass
  ``False`` for this value.  Alternately, write code like this::

     from hypatia.exc import Unsortable

     ids = []
     results = resultset.sort(someindex)
     try:
         for id in results:
             ids.append(id)
     except Unsortable as e:
         unsorted = e.docids
         ids.extend(unsorted)

0.1a3 (2013-01-10)
------------------

- Optimize ``index_doc`` implementations of field and keyword index in cases
  where the discriminator returns the default.

- Remove code from ``hypatia.path``.  This package no longer supports
  PathIndex.

- Remove ``interfaces.IIndexQuery`` interface.  It was never relevant, as
  indices cannot be expected to implement all of its methods, only the ones
  which apply to each index.

- ``BaseIndexMixin`` no longer supplies default implementation of applyFoo
  methods which raise NotImplementedError.  Each index is now responsible for
  implementing all of its own applyFoo methods.  This is in the interest of
  fidelity with new query methods such as ``eq``, which are similarly not
  implemented in the base.

- Indexes are now compelled to implement a ``qname`` method for use by
  queries.

- ``DoesNotContain`` query renamed to ``NotContains`` for symmetry with other
  negated query names.

- New index methods: ``eq``, ``noteq``, ``ge``, ``le``, ``lt``, ``gt``,
  ``any``, ``notany``, ``all``, ``notall``, ``inrange``, ``notinrange``,
  ``contains``, ``notcontains``.  These methods return query objects.  Ex::

      catalog['flavors'].eq('peach')

- Query objects refactored internally to deal in index objects rather than
  index names.