text: # Copyright 2010 Matt Chaput. All rights reserved.
  #
  # Redistribution and use in source and binary forms, with or without
  # modification, are permitted provided that the following conditions are met:
  #
  #    1. Redistributions of source code must retain the above copyright notice,
  #       this list of conditions and the following disclaimer.
  #
  #    2. Redistributions in binary form must reproduce the above copyright
  #       notice, this list of conditions and the following disclaimer in the
  #       documentation and/or other materials provided with the distribution.
  #
  # THIS SOFTWARE IS PROVIDED BY MATT CHAPUT ``AS IS'' AND ANY EXPRESS OR
  # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  # EVENT SHALL MATT CHAPUT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  # OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  #
  # The views and conclusions contained in the software and documentation are
  # those of the authors and should not be interpreted as representing official
  # policies, either expressed or implied, of Matt Chaput.
  
  from __future__ import division
  
  from whoosh.compat import xrange
  from whoosh.matching import mcore
  
  
  class WrappingMatcher(mcore.Matcher):
      """Base class for matchers that wrap sub-matchers.
      """
  
      def __init__(self, child, boost=1.0):
          self.child = child
          self.boost = boost
  
      def __repr__(self):
          return "%s(%r, boost=%s)" % (self.__class__.__name__, self.child,
                                       self.boost)
  
      def copy(self):
          kwargs = {}
          if hasattr(self, "boost"):
              kwargs["boost"] = self.boost
          return self.__class__(self.child.copy(), **kwargs)
  
      def depth(self):
          return 1 + self.child.depth()
  
      def _replacement(self, newchild):
          return self.__class__(newchild, boost=self.boost)
  
      def replace(self, minquality=0):
          # Replace the child matcher
          r = self.child.replace(minquality)
          if r is not self.child:
              # If the child changed, return a new wrapper on the new child
              return self._replacement(r)
          else:
              return self
  
      def id(self):
          return self.child.id()
  
      def all_ids(self):
          return self.child.all_ids()
  
      def is_active(self):
          return self.child.is_active()
  
      def reset(self):
          self.child.reset()
  
      def children(self):
          return [self.child]
  
      def supports(self, astype):
          return self.child.supports(astype)
  
      def value(self):
          return self.child.value()
  
      def value_as(self, astype):
          return self.child.value_as(astype)
  
      def spans(self):
          return self.child.spans()
  
      def skip_to(self, id):
          return self.child.skip_to(id)
  
      def next(self):
          self.child.next()
  
      def supports_block_quality(self):
          return self.child.supports_block_quality()
  
      def skip_to_quality(self, minquality):
          return self.child.skip_to_quality(minquality / self.boost)
  
      def max_quality(self):
          return self.child.max_quality() * self.boost
  
      def block_quality(self):
          return self.child.block_quality() * self.boost
  
      def weight(self):
          return self.child.weight() * self.boost
  
      def score(self):
          return self.child.score() * self.boost
  
  
  class MultiMatcher(mcore.Matcher):
      """Serializes the results of a list of sub-matchers.
      """
  
      def __init__(self, matchers, idoffsets, scorer=None, current=0):
          """
          :param matchers: a list of Matcher objects.
          :param idoffsets: a list of offsets corresponding to items in the
              ``matchers`` list.
          """
  
          self.matchers = matchers
          self.offsets = idoffsets
          self.scorer = scorer
          self.current = current
          self._next_matcher()
  
      def __repr__(self):
          return "%s(%r, %r, current=%s)" % (self.__class__.__name__,
                                             self.matchers, self.offsets,
                                             self.current)
  
      def is_active(self):
          return self.current < len(self.matchers)
  
      def reset(self):
          for mr in self.matchers:
              mr.reset()
          self.current = 0
  
      def children(self):
          return [self.matchers[self.current]]
  
      def _next_matcher(self):
          matchers = self.matchers
          while (self.current < len(matchers)
                 and not matchers[self.current].is_active()):
              self.current += 1
  
      def copy(self):
          return self.__class__([mr.copy() for mr in self.matchers],
                                self.offsets, current=self.current)
  
      def depth(self):
          if self.is_active():
              return 1 + max(mr.depth() for mr in self.matchers[self.current:])
          else:
              return 0
  
      def replace(self, minquality=0):
          m = self
          if minquality:
              # Skip sub-matchers that don't have a high enough max quality to
              # contribute
              while (m.is_active()
                     and m.matchers[m.current].max_quality() < minquality):
                  m = self.__class__(self.matchers, self.offsets, self.scorer,
                                     m.current + 1)
                  m._next_matcher()
  
          if not m.is_active():
              return mcore.NullMatcher()
  
          # TODO: Possible optimization: if the last matcher is current, replace
          # this with the last matcher, but wrap it with a matcher that adds the
          # offset. Have to check whether that's actually faster, though.
          return m
  
      def id(self):
          current = self.current
          return self.matchers[current].id() + self.offsets[current]
  
      def all_ids(self):
          offsets = self.offsets
          for i, mr in enumerate(self.matchers):
              for id in mr.all_ids():
                  yield id + offsets[i]
  
      def spans(self):
          return self.matchers[self.current].spans()
  
      def supports(self, astype):
          return self.matchers[self.current].supports(astype)
  
      def value(self):
          return self.matchers[self.current].value()
  
      def value_as(self, astype):
          return self.matchers[self.current].value_as(astype)
  
      def next(self):
          if not self.is_active():
              raise mcore.ReadTooFar
  
          self.matchers[self.current].next()
          if not self.matchers[self.current].is_active():
              self._next_matcher()
  
      def skip_to(self, id):
          if not self.is_active():
              raise mcore.ReadTooFar
          if id <= self.id():
              return
  
          matchers = self.matchers
          offsets = self.offsets
          r = False
  
          while self.current < len(matchers) and id > self.id():
              mr = matchers[self.current]
              sr = mr.skip_to(id - offsets[self.current])
              r = sr or r
              if mr.is_active():
                  break
  
              self._next_matcher()
  
          return r
  
      def supports_block_quality(self):
          return all(mr.supports_block_quality() for mr
                     in self.matchers[self.current:])
  
      def max_quality(self):
          return max(m.max_quality() for m in self.matchers[self.current:])
  
      def block_quality(self):
          return self.matchers[self.current].block_quality()
  
      def weight(self):
          return self.matchers[self.current].weight()
  
      def score(self):
          return self.scorer.score(self)
  
  
  def ExcludeMatcher(child, excluded, boost=1.0):
      return FilterMatcher(child, excluded, exclude=True, boost=boost)
  
  
  class FilterMatcher(WrappingMatcher):
      """Filters the postings from the wrapped based on whether the IDs are
      present in or absent from a set.
      """
  
      def __init__(self, child, ids, exclude=False, boost=1.0):
          """
          :param child: the child matcher.
          :param ids: a set of IDs to filter by.
          :param exclude: by default, only IDs from the wrapped matcher that are
              **in** the set are used. If this argument is True, only IDs from
              the wrapped matcher that are **not in** the set are used.
          """
  
          super(FilterMatcher, self).__init__(child)
          self._ids = ids
          self._exclude = exclude
          self.boost = boost
          self._find_next()
  
      def __repr__(self):
          return "%s(%r, %r, %r, boost=%s)" % (self.__class__.__name__,
                                               self.child, self._ids,
                                               self._exclude, self.boost)
  
      def reset(self):
          self.child.reset()
          self._find_next()
  
      def copy(self):
          return self.__class__(self.child.copy(), self._ids, self._exclude,
                                boost=self.boost)
  
      def _replacement(self, newchild):
          return self.__class__(newchild, self._ids, exclude=self._exclude,
                                boost=self.boost)
  
      def _find_next(self):
          child = self.child
          ids = self._ids
          r = False
  
          if self._exclude:
              while child.is_active() and child.id() in ids:
                  r = child.next() or r
          else:
              while child.is_active() and child.id() not in ids:
                  r = child.next() or r
          return r
  
      def next(self):
          self.child.next()
          self._find_next()
  
      def skip_to(self, id):
          self.child.skip_to(id)
          self._find_next()
  
      def all_ids(self):
          ids = self._ids
          if self._exclude:
              return (id for id in self.child.all_ids() if id not in ids)
          else:
              return (id for id in self.child.all_ids() if id in ids)
  
      def all_items(self):
          ids = self._ids
          if self._exclude:
              return (item for item in self.child.all_items()
                      if item[0] not in ids)
          else:
              return (item for item in self.child.all_items() if item[0] in ids)
  
  
  class InverseMatcher(WrappingMatcher):
      """Synthetic matcher, generates postings that are NOT present in the
      wrapped matcher.
      """
  
      def __init__(self, child, limit, missing=None, weight=1.0, id=0):
          super(InverseMatcher, self).__init__(child)
          self.limit = limit
          self._weight = weight
          self.missing = missing or (lambda id: False)
          self._id = id
          self._find_next()
  
      def copy(self):
          return self.__class__(self.child.copy(), self.limit,
                                weight=self._weight, missing=self.missing,
                                id=self._id)
  
      def _replacement(self, newchild):
          return self.__class__(newchild, self.limit, missing=self.missing,
                                weight=self._weight, id=self._id)
  
      def is_active(self):
          return self._id < self.limit
  
      def reset(self):
          self.child.reset()
          self._id = 0
          self._find_next()
  
      def supports_block_quality(self):
          return False
  
      def _find_next(self):
          child = self.child
          missing = self.missing
  
          # If the current docnum isn't missing and the child matcher is
          # exhausted (so we don't have to worry about skipping its matches), we
          # don't have to do anything
          if not child.is_active() and not missing(self._id):
              return
  
          # Skip missing documents
          while self._id < self.limit and missing(self._id):
              self._id += 1
  
          # Catch the child matcher up to where this matcher is
          if child.is_active() and child.id() < self._id:
              child.skip_to(self._id)
  
          # While self._id is missing or is in the child matcher, increase it
          while child.is_active() and self._id < self.limit:
              if missing(self._id):
                  self._id += 1
                  continue
  
              if self._id == child.id():
                  self._id += 1
                  child.next()
                  continue
  
              break
  
      def id(self):
          return self._id
  
      def all_ids(self):
          return mcore.Matcher.all_ids(self)
  
      def next(self):
          if self._id >= self.limit:
              raise mcore.ReadTooFar
          self._id += 1
          self._find_next()
  
      def skip_to(self, id):
          if self._id >= self.limit:
              raise mcore.ReadTooFar
          if id < self._id:
              return
          self._id = id
          self._find_next()
  
      def weight(self):
          return self._weight
  
      def score(self):
          return self._weight
  
  
  class RequireMatcher(WrappingMatcher):
      """Matches postings that are in both sub-matchers, but only uses scores
      from the first.
      """
  
      def __init__(self, a, b):
          from whoosh.matching.binary import IntersectionMatcher
  
          self.a = a
          self.b = b
          WrappingMatcher.__init__(self, IntersectionMatcher(a, b))
  
      def copy(self):
          return self.__class__(self.a.copy(), self.b.copy())
  
      def supports_block_quality(self):
          return self.a.supports_block_quality()
  
      def replace(self, minquality=0):
          if not self.child.is_active():
              # If one of the sub-matchers is inactive, go inactive
              return mcore.NullMatcher()
          elif minquality and self.a.max_quality() < minquality:
              # If the required matcher doesn't have a high enough max quality
              # to possibly contribute, return an inactive matcher
              return mcore.NullMatcher()
  
          new_a = self.a.replace(minquality)
          new_b = self.b.replace()
          if not new_a.is_active():
              return mcore.NullMatcher()
          elif new_a is not self.a or new_b is not self.b:
              # If one of the sub-matchers changed, return a new Require
              return self.__class__(new_a, self.b)
          else:
              return self
  
      def max_quality(self):
          return self.a.max_quality()
  
      def block_quality(self):
          return self.a.block_quality()
  
      def skip_to_quality(self, minquality):
          skipped = self.a.skip_to_quality(minquality)
          self.child._find_next()
          return skipped
  
      def weight(self):
          return self.a.weight()
  
      def score(self):
          return self.a.score()
  
      def supports(self, astype):
          return self.a.supports(astype)
  
      def value(self):
          return self.a.value()
  
      def value_as(self, astype):
          return self.a.value_as(astype)
  
  
  class ConstantScoreWrapperMatcher(WrappingMatcher):
      def __init__(self, child, score=1.0):
          WrappingMatcher.__init__(self, child)
          self._score = score
  
      def copy(self):
          return self.__class__(self.child.copy(), score=self._score)
  
      def _replacement(self, newchild):
          return self.__class__(newchild, score=self._score)
  
      def max_quality(self):
          return self._score
  
      def block_quality(self):
          return self._score
  
      def score(self):
          return self._score
  
  
  class SingleTermMatcher(WrappingMatcher):
      """Makes a tree of matchers act as if they were a matcher for a single
      term for the purposes of "what terms are matching?" questions.
      """
  
      def __init__(self, child, term):
          WrappingMatcher.__init__(self, child)
          self._term = term
  
      def term(self):
          return self._term
  
      def replace(self, minquality=0):
          return self
  
  
  class CoordMatcher(WrappingMatcher):
      """Modifies the computed score to penalize documents that don't match all
      terms in the matcher tree.
  
      Because this matcher modifies the score, it may give unexpected results
      when compared to another matcher returning the unmodified score.
      """
  
      def __init__(self, child, scale=1.0):
          WrappingMatcher.__init__(self, child)
          self._termcount = len(list(child.term_matchers()))
          self._scale = scale
  
      def _replacement(self, newchild):
          return self.__class__(newchild, scale=self._scale)
  
      def _sqr(self, score, matching):
          # This is the "SQR" (Short Query Ranking) function used by Apple's old
          # V-twin search library, described in the paper "V-Twin: A Lightweight
          # Engine for Interactive Use".
          #
          # http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.56.1916
  
          # score - document score using the current weighting function
          # matching - number of matching terms in the current document
          termcount = self._termcount  # Number of terms in this tree
          scale = self._scale  # Scaling factor
  
          sqr = ((score + ((matching - 1) / (termcount - scale) ** 2)) *
                 ((termcount - 1) / termcount))
          return sqr
  
      def max_quality(self):
          return self._sqr(self.child.max_quality(), self._termcount)
  
      def block_quality(self):
          return self._sqr(self.child.block_quality(), self._termcount)
  
      def score(self):
          child = self.child
  
          score = child.score()
          matching = 0
          for _ in child.matching_terms(child.id()):
              matching += 1
  
          return self._sqr(score, matching)
  