Metadata-Version: 1.1
Name: hypatia
Version: 0.1
Summary: Python package for searching and indexing
Home-page: http://pylonsproject.org
Author: Zope Foundation and Contributors
Author-email: pylons-discuss@googlegroups.com
License: ZPL 2.1
Description: 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.
        
        - The ``query.parse_query`` function now requires a ``catalog`` argument.
        
        - Query objects now supply an .execute method which returns a ResultSet.
        
        - ResultSet objects are returned from .execute.  They represent a set of
          docids; they are iterable and have various methods for obtaining single
          objects (like ``one``, ``first``) and sorting (``sort``).
        
        - All Query objects now have a ``flush`` method which accepts arbitrary
          positional and keyword arguments.  Calling the ``flush`` method of a query
          object will cause the ``flush`` method of all indexes participating in the
          query with the value passed to Query.flush with the same positional and
          keyword arguments.  This is to support Substance D upstream, which may
          require indexes to be flushed before a query happens.
        
        - Add a ``document_repr`` method to all indexes which accepts a docid and
          returns a string represnting the index's knowledge about that docid.
        
        0.1a2 (2012-07-02)
        ------------------
        
        - This version of the code is incompatible with indexes produced by 0.1a1.
          There is no upgrade script.  Shame on you for using software with a 0.1a1
          version number and expecting backwards compatibility.
        
        - Add `hypatia.catalog.CatalogQuery.sort` API for sorting external sets
          of docids based on index values.
        
        - Add ``IIndexEnumeration`` interface, which all indexes must support.
          This implied the following backwards incompatibilities:
        
          - New interface methods: docids, docids_count, indexed, indexed_count,
            not_indexed and not_indexed_count.
        
          - documentCount method renamed to indexed_count.
        
          - wordCount method renamed to word_count.
        
        - Remove unused INBest interface.
        
        - IIndexInjection interface ``clear`` method renamed to ``reset`` to prevent
          confusion with dictionary ``clear`` (catalog is often dictionarylike).
          Catalog ``clear_indexes`` method replaced with ``reset``.
        
        0.1a1
        -----
        
        - Initial release: fork of repoze.catalog and zope.index, combined.
        
        
Keywords: indexing catalog search
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
