cubicweb: comparison web/views/magicsearch.py

equal deleted inserted replaced

-:49075f57cf2c
+:aa09e20dd8c0
 """a query preprocesser to handle quick search shortcuts for cubicweb
 :organization: Logilab
-:copyright: 2001-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 :contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
 """
 __docformat__ = "restructuredtext en"
 from rql import RQLSyntaxError, BadRQLQuery, parse
 from rql.nodes import Relation
 from cubicweb import Unauthorized
-from cubicweb.common.appobject import Component, SingletonComponent
+from cubicweb.view import Component
 LOGGER = getLogger('cubicweb.magicsearch')
 def _get_approriate_translation(translations_found, eschema):
 """return the first (should be the only one) possible translation according
 :type translations: dict
 :param translations: the reverted l10n dict
 :type schema: `cubicweb.schema.Schema`
 :param schema: the application's schema
 """
 # var_types is used as a map : var_name / var_type
 vartypes = {}
 # ambiguous_nodes is used as a map : relation_node / (var_name, available_translations)
 ambiguous_nodes = {}
 eschema = schema.eschema(vartype)
 rtype = _get_approriate_translation(translations_found, eschema)
 if rtype is None:
 continue
 relation.r_type = rtype
 QUOTED_SRE = re.compile(r'(.*?)(["\'])(.+?)\2')
 TRANSLATION_MAPS = {}
 args = self.preprocess_query(uquery, req)
 try:
 return req.execute(*args)
 finally:
 # rollback necessary to avoid leaving the connection in a bad state
 req.cnx.rollback()
 def preprocess_query(self, uquery, req):
 raise NotImplementedError()
 """
 name = 'rql'
 priority = 0
 def preprocess_query(self, uquery, req):
 return uquery,
 class QueryTranslator(BaseQueryProcessor):
 """ parses through rql and translates into schema language entity names
 and attributes
 """
 priority = 2
 def preprocess_query(self, uquery, req):
 try:
 """Quick search preprocessor
 preprocessing query in shortcut form to their RQL form
 """
 priority = 4
 def preprocess_query(self, uquery, req):
-""""""
+"""try to get rql from an unicode query string"""
 args = None
 self.req = req
 try:
 # Process as if there was a quoted part
 args = self._quoted_words_query(uquery)
 ## No quoted part
 except BadRQLQuery:
 words = uquery.split()
 if len(words) == 1:
 args = self._one_word_query(*words)
 elif len(words) == 2:
 elif len(words) == 3:
 args = self._three_words_query(*words)
 else:
 args = self._multiple_words_query(words)
 return args
 def _get_entity_type(self, word):
 """check if the given word is matching an entity type, return it if
 it's the case or raise BadRQLQuery if not
 """
 etype = word.capitalize()
 try:
 return trmap(self.config, self.vreg.schema, self.req.lang)[etype]
 except KeyError:
 raise BadRQLQuery('%s is not a valid entity name' % etype)
 def _get_attribute_name(self, word, eschema):
 """check if the given word is matching an attribute of the given entity type,
 return it normalized if found or return it untransformed else
 """
 searchop = 'LIKE '
 searchattr = searchattr or 'has_text'
 if var is None:
 var = etype[0]
 return '%s %s %s%%(text)s' % (var, searchattr, searchop)
 def _two_words_query(self, word1, word2):
 """Specific process for two words query (case (2) of preprocess_rql)
 """
 etype = self._get_entity_type(word1)
 # this is a valid RQL query : ("Person X", or "Person TMP1")
 if len(word2) == 1 and word2.isupper():
 return '%s %s' % (etype, word2),
 # else, suppose it's a shortcut like : Person Smith
 rql = '%s %s WHERE %s' % (etype, etype[0], self._complete_rql(word2, etype))
 return rql, {'text': word2}
 def _three_words_query(self, word1, word2, word3):
 """Specific process for three words query (case (3) of preprocess_rql)
 """
 etype = self._get_entity_type(word1)
 eschema = self.schema.eschema(etype)
 elif len(left_words) == 2:
 word1, word2 = left_words
 return self._three_words_query(word1, word2, quoted_part)
 # return ori_rql
 raise BadRQLQuery("unable to handle request %r" % ori_rql)
 class FullTextTranslator(BaseQueryProcessor):
 priority = 10
 name = 'text'
 def preprocess_query(self, uquery, req):
 """suppose it's a plain text query"""
 return 'Any X WHERE X has_text %(text)s', {'text': uquery}
-class MagicSearchComponent(SingletonComponent):
+class MagicSearchComponent(Component):
 id  = 'magicsearch'
 def __init__(self, req, rset=None):
 super(MagicSearchComponent, self).__init__(req, rset)
 processors = []
 self.by_name = {}
 raise unauthorized
 else:
 # let exception propagate
 return proc.process_query(uquery, req)
 raise BadRQLQuery(req._('sorry, the server is unable to handle this query'))
-# Do not make a strong dependency on NlpTools
-try:
-from NlpTools.rqltools.client import RQLClient
-except ImportError:
-LOGGER.info('could not import RQLClient (NlpTools)')
-else:
-try:
-from Pyro.errors import NamingError
-except ImportError:
-LOGGER.warning("pyro is not installed, can't try to connect to nlp server")
-else:
-try:
-class NLPProcessor(BaseQueryProcessor):
-priority = 8
-nlp_agent = RQLClient('ivan')
-def preprocess_query(self, uquery, req):
-try:
-answer = self.nlp_agent.get_translation(uquery)
-if not answer:
-raise BadRQLQuery(uquery)
-return answer or uquery,
-except Exception, ex:
-LOGGER.exception(str(ex))
-return uquery,
-except NamingError: # NlpTools available but no server registered
-LOGGER.warning('could not find any RQLServer object named "ivan"')

changeset 1808	aa09e20dd8c0
parent 1433	091ac3ba5d51
child 1977	606923dff11b