Python qparser.QueryParser类代码示例

    def numeroDeCorreos2(var):
        with ix.searcher() as searcher:
            query = QueryParser("name", ix2.schema)
            qp = query.parse(unicode(var))

            with ix2.searcher() as s:
                results = s.search(qp)
                mail = results[0]["mail"]
            query = QueryParser("mailTo", ix.schema).parse(mail)
            results = searcher.search(query)
            panel = Tkinter.Toplevel()
            scrollbar = Tkinter.Scrollbar(panel)
            scrollbar.pack(side=Tkinter.RIGHT, fill=Tkinter.Y)
            listado = Tkinter.Text(panel, width=150, height=30, yscrollcommand=scrollbar.set)
            i = 1
            for result in results:
                listado.insert(Tkinter.INSERT, "Mail from: " + result["mailFrom"])
                listado.insert(Tkinter.INSERT, "Mail to: " + result["mailTo"])
                listado.insert(Tkinter.INSERT, "Subject: " + result["subject"])
                date = result["date"]
                listado.insert(Tkinter.INSERT, "Date: " + date[:4] + "-" + date[4:6] + "-" + date[6:])
                listado.insert(Tkinter.INSERT, "Content: ")
                content = re.findall("'([^']*)'", result["content"])
                last = content[-1]
                i += 1
                for line in content:
                    if line is not last:
                        line = line[:-2]
                    listado.insert(Tkinter.INSERT, line + "\n")
                listado.insert(Tkinter.INSERT, "\n")
            listado.insert(Tkinter.INSERT, "Este remitente ha enviado " + str(i - 1) + " correos.")
            scrollbar.config(command=listado.yview)
            listado.pack()

    def searchNote(self):
        """ Sorting criteria: "title > path > content"
            Search matches are organized into html source.
        """

        pattern = self.searchEdit.text()
        if not pattern:
            return
        results = []
        print("Searching using", pattern)
        with self.ix.searcher() as searcher:
            matches = []
            for f in ["title", "path", "content"]:
                queryp = QueryParser(f, self.ix.schema)
                queryp.add_plugin(RegexPlugin())
                # r"pattern" is the desired regex term format
                query = queryp.parse('r"' + pattern + '"')
                ms = searcher.search(query, limit=None) # default limit is 10!
                for m in ms:
                    if not m in matches:
                        matches.append(m)

            for r in matches:
                title = r['title']
                path = r['path']
                term = r.highlights("content")
                results.append([title, path, term])

            html = ""
            for title, path, hi in results:
                html += ("<p><a href='" + path + "'>" + title +
                         "</a><br/><span class='path'>" +
                         path + "</span><br/>" + hi + "</p>")
            self.searchView.setHtml(html)
            print("Finished searching", pattern)

def test_wildcard_existing_terms():
    s = fields.Schema(key=fields.ID, value=fields.TEXT)
    ix = RamStorage().create_index(s)

    w = ix.writer()
    w.add_document(key=u("a"), value=u("alfa bravo bear charlie delta"))
    w.add_document(key=u("a"), value=u("boggle echo render rendering renders"))
    w.commit()
    r = ix.reader()
    qp = QueryParser("value", ix.schema)

    def words(terms):
        z = []
        for t in terms:
            assert t[0] == "value"
            z.append(t[1])
        return " ".join(sorted(z))

    q = qp.parse(u("b*"))
    ts = q.existing_terms(r)
    assert_equal(ts, set())
    ts = q.existing_terms(r, expand=True)
    assert_equal(words(ts), "bear boggle bravo")

    q = qp.parse(u("[a TO f]"))
    ts = q.existing_terms(r)
    assert_equal(ts, set())
    ts = q.existing_terms(r, expand=True)
    assert_equal(words(ts), "alfa bear boggle bravo charlie delta echo")

    q = query.Variations("value", "render")
    ts = q.existing_terms(r, expand=False)
    assert_equal(ts, set())
    ts = q.existing_terms(r, expand=True)
    assert_equal(words(ts), "render rendering renders")

    def populateTable(self, searchterm=None):
        self.infoTable.clear()
        self.infoTable.setHorizontalHeaderLabels( [ "Title", "Authors", "Tags", "Year", "Read" ] )
        self.infoTable.setRowCount(0)
        self.infoTable.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
        self.infoTable.verticalHeader().hide()

        if( searchterm == None or searchterm == "" ):
            papers = KKDocument.objects.all()
            for p in papers:
                a = ', '.join([x.name for x in p.authors.all()])
                t = ', '.join([x.tag  for x in p.tags.all()])
                self.newEntry(p.title, a, t, p.year, p)
            return # were done here - all papers printed

        # only if there is a searchterm:
        # search full text with whoosh
        print "FINDING %s" % searchterm
        searcher = self.whoosh_ix.searcher()
        parser = QueryParser("content", schema = self.whoosh_schema)
        query = parser.parse(unicode(searchterm))
        whoosh_results = searcher.search(query)

        print "FOUND", len(whoosh_results), "Objects"

        for r in whoosh_results:
            p = KKDocument.objects.get(localFile=r['path'])
            a = ', '.join([x.name for x in p.authors.all()])
            t = ', '.join([x.tag  for x in p.tags.all()])
            self.newEntry(p.title, a, t, p.year, p)

def findsnippets(query, daterange=None, page=1,ndocs=PER_PAGE, MAX_SEARCH_RESULTS=MAX_SEARCH_RESULTS,distribution=True):
    ix = open_dir(indexdir)
    res=[]
    daycount={}
    with ix.searcher() as searcher:
        parser = QueryParser("content", ix.schema)
        myquery = parser.parse(query)
        if daterange!=None:
            datequery=DateRange("date", daterange[0],daterange[1])
            results = searcher.search(datequery & myquery,limit=MAX_SEARCH_RESULTS)
        else:
            results = searcher.search(myquery,limit=MAX_SEARCH_RESULTS)
        if distribution:
            myfacet=Facets().add_field("date",maptype=sorting.Count)
            if daterange!=None:
                datequery=DateRange("date", daterange[0],daterange[1])
                daycount_orig=searcher.search(datequery & myquery, groupedby=myfacet,limit=MAX_SEARCH_RESULTS)
            else:
                daycount_orig=searcher.search(myquery, groupedby=myfacet,limit=MAX_SEARCH_RESULTS)     
            for day in daycount_orig.groups():
                daycount[day]=daycount_orig.groups()[day]
            for result in results[(page-1)*ndocs:page*ndocs]:
                doc=PoorDoc(docidentifier=result['identifier'],date=int(result['date'].strftime("%Y%m%d")))
                snippet=result.highlights("content", text=doc.getcontent())
                res.append({'title':result['title'],'identifier':result['identifier'],'date':result['date'],'snippet':snippet})
            total_docs=results.estimated_length()
            return res, total_docs, daycount
        else:
            for result in results[(page-1)*ndocs:page*ndocs]:
                doc=PoorDoc(docidentifier=result['identifier'],date=int(result['date'].strftime("%Y%m%d")))
                snippet=result.highlights("content", text=doc.getcontent())
                res.append({'title':result['title'],'identifier':result['identifier'],'date':result['date'],'snippet':snippet})
        total_docs=results.estimated_length()
        return res, total_docs

def OnlyOneSearch(queryStr="",index=".index"):
	ix=get_index(index)
	searcher = ix.searcher()
	parser = QueryParser("name", schema = ix.schema)
	query=parser.parse(queryStr)
	results = searcher.search(query)
	return results

def crearEsquemaCorreo():
    correo1 = "1.txt"

    correoEsquema = Schema(remitente=ID(stored=True), destinatarios=KEYWORD(stored=True), fecha=DATETIME(stored=True),asunto=KEYWORD(stored=True), cuerpo=TEXT(stored=True))

    if not os.path.exists("indexCorreo"):
        os.mkdir("indexCorreo")

    iC = index.create_in("indexCorreo", correoEsquema)
    iC = open_dir("indexCorreo")
    
    writer = iC.writer()
    fecha = "20101015"
    date_email = datetime.strptime(fecha, "%Y%m%d")
    writer.add_document(remitente=u"unoarrobagmail.com", destinatarios=u"dosarrobagmail.com tresarrobagmail.com", fecha=date_email,asunto=u"Contrato de compraventa con la constructora",cuerpo=u"Estimados socios: ya hemos firmado el contrato de compraventa con el cliente preferencial. Espero noticias vuestras. Un saludo,")
    #writer.add_document(email=u"dosarrobagmail.com", name=u"Pedro Guerra")
    #writer.add_document(email=u"tresarrobagmail.com", name=u"Ana Montero")
    #writer.add_document(email=u"cuatroarrobagmail.com", name=u"Luis Pontes")
    writer.commit()
    
    qp = QueryParser("remitente", schema=iC.schema)
    q = qp.parse(u"unoarrobagmail.com")

    with iC.searcher() as s:
        results = s.search(q)
        print results[0]

def whooshSearch(searchTerm, brandTerm):
	brandTerm = brandTerm.lower()
	
	#Open index
	ix = index.open_dir("index")
	
	#Identify which field
	parserFood = QueryParser("tag", ix.schema)
	queryFood = parserFood.parse(searchTerm)
	
	
	searcher = ix.searcher()
	#Create filter
	if brandTerm == "":
		brandTerm = "general"
		allow_q = Term("source", brandTerm)
		resultFoodGen = searcher.search(queryFood,filter = allow_q, limit = 7)
		resultFoodNoGen = searcher.search(queryFood,mask = allow_q, limit = 1000)
		resultFood = [each for each in resultFoodGen] + [each for each in resultFoodNoGen]
	
	else:
		allow_q = Term("source", brandTerm)
		resultFood = searcher.search(queryFood,filter = allow_q, limit = 1000)

	resultList = []	
	for i in resultFood:
		resultList.append(i["id"])
	searcher.close()
	return resultList

 def searchNote(self):
     pattern = self.searchEdit.text()
     qres = []
     with self.ix.searcher() as searcher:
         queryp = QueryParser("content", self.ix.schema)
         queryp.add_plugin(RegexPlugin())
         query = queryp.parse('r"' + pattern + '"')
                              # r"pattern" is the desired regex term format
         pathFacet = sorting.FieldFacet("path")
         scores = sorting.ScoreFacet()
         results = searcher.search(
             query, limit=None, sortedby=[pathFacet, scores])  # default limit is 10!
         for r in results:
             listItem = QListWidgetItem()
             title = r['title']
             text = r['path']
             term = r.highlights("content")
             qres.append([title, text, term])
         html = """
                 <style>
                     body { font-size: 14px; }
                     .path { font-size: 12px; color: #009933; }
                 </style>
                """
         for ti, te, hi in qres:
             html += ("<p><a href='" + te + "'>" + ti + 
                      "</a><br/><span class='path'>" + 
                     te + "</span><br/>" + hi + "</p>")
         self.searchView.setHtml(html)

def whoosh(q_query, raw_query, page):
	results = []
	try:
		import internal_search
		with internal_search.ix.searcher() as searcher:
			from whoosh.qparser import QueryParser
			parser = QueryParser("keywords", internal_search.ix.schema)
			myquery = parser.parse('"%s"' %raw_query)
			w_results = searcher.search(myquery)
			for r in w_results:
				s = ''
				if 'official' in r:
					s = ' official'
				if not 'twitter' in r:
					t = ''
				else:
					t = r['twitter']
				results.append({
					"style" : "internal_search%s" % s,
					"title" : r['title'],
					"url" : r['link'],
					"snippet" : r['content'],
					"display_url" :  r['link'],
					"twitter" : t
				})
	except Exception as ex:
		import traceback
		results.append({
			"style" : "error",
			"title" : "An error occured: %s" % repr(ex) + "<br/>" + traceback.format_exc().replace("\n", "<br/>"),
			"snippet" : "<pre>%s</pre>" % debug_info
		})
	return results

    def lookup(self, key, raw=True, field="entity_id"):
        if key == 'entities' or key is None:
            if raw:
                return b2u(list(self.objects.values()))
            else:
                return b2u(list(self.infos.values()))

        from whoosh.qparser import QueryParser
        # import pdb; pdb.set_trace()
        key = key.strip('+')
        key = key.replace('+', ' AND ')
        for uri, a in list(ATTRS_INV.items()):
            key = key.replace(uri, a)
        key = " {!s} ".format(key)
        key = re.sub("([^=]+)=(\S+)", "\\1:\\2", key)
        key = re.sub("{([^}]+)}(\S+)", "\\1:\\2", key)
        key = key.strip()

        qp = QueryParser("object_id", schema=self.schema)
        q = qp.parse(key)
        lst = set()
        with self.index.searcher() as searcher:
            results = searcher.search(q, limit=None)
            for result in results:
                if raw:
                    lst.add(self.objects[result['object_id']])
                else:
                    lst.add(self.infos[result['object_id']])

        return b2u(list(lst))

 def search(self, q, page = 1, size = 30):
     searcher = self.ix.searcher()
     parser = QueryParser("content", schema=self.ix.schema, group=OrGroup)
     parser_rlt = parser.parse(q)
     #print unicode(parser_rlt)
     results = searcher.search_page(parser_rlt, page, size)
     return self.parse_results(results)

def fulltext_search(request, query, limit):
    # query index
    index = get_index()
    parser = QueryParser('value', index.schema)
    with index.searcher() as searcher:
        query = parser.parse(query)
        results = searcher.search(query, limit=limit)
        results = results_to_instances(request, results)

    # helper for limit
    def limited(res):
        if limit is not None:
            return res[:limit]
        return res

    # if authenticated, return all draft and published results
    authenticated = bool(authenticated_userid(request))
    if authenticated:
        return limited(
            [res for res in results if res.state in ['draft', 'published']])
    # check for submitter
    submitter = get_submitter(request)
    if submitter:
        return limited(
            [res for res in results if res.state == 'published' or
                (res.state == 'draft' and submitter == res.submitter)])
    # return only public results
    return limited([res for res in results if res.state == 'published'])

    def __init__(self, search_term):

        search_term = re.sub( and_regex, ' AND ',  search_term )
        search_term = re.sub( or_regex, ' OR ', search_term)

        parser = QueryParser("content", schema=None)
        q = parser.parse(search_term)
        invalid = self.validate_search_term(q)
        if invalid:
            raise ValueError(invalid + search_term)

        myapp.db_connector.connect()
        session = myapp.db_connector.get_session()

        subq = session.query( TourneyList.id.label("tourney_list_id"),
                              TourneyVenue.country.label("country_name"),
                              TourneyVenue.state.label("state_name"),
                              TourneyVenue.city.label("city_name"),
                              TourneyVenue.venue.label("venue_name"),
                              Tourney.tourney_type.label("tourney_type"),
                              func.group_concat( ShipPilot.ship_type.distinct()).label("ship_name" ),
                              func.group_concat( func.concat( Pilot.name, " ", Pilot.canon_name )).label("pilot_name"),
                              func.group_concat( func.concat( Upgrade.name, " ", Upgrade.canon_name ) ).label("upgrade_name") ). \
            join(Tourney).\
            join(TourneyVenue).\
            join(Ship). \
            join(ShipPilot). \
            join(Pilot). \
            outerjoin(ShipUpgrade). \
            outerjoin(Upgrade).\
            group_by( TourneyList.id).subquery()


        fn  = tree_to_expr(q, subq)
        self.query = session.query(subq.c.tourney_list_id).filter( fn )

def index_query(environ, **kwargs):
    """
    Return a generator of tiddlers that match
    the provided arguments.
    """
    logging.debug('entering with %s', environ)
    print 'getting called on index_query'
    config = environ['tiddlyweb.config']
    #store = environ['tiddlyweb.store']
    query_parts = []
    for field, value in kwargs.items():
        if field == 'tag':
            field = 'tags'
        query_parts.append('%s:%s' % (field, value))
    query_string = ' '.join(query_parts)

    print 'getting inside on index_query'
    schema = config.get('wsearch.schema', SEARCH_DEFAULTS['wsearch.schema'])
    searcher = get_searcher(config)
    parser = QueryParser('text', schema=Schema(**schema))
    query = parser.parse(query_string)
    logging.debug('query parsed to %s' % query)
    results = searcher.search(query)

    def tiddler_from_result(result):
        print 'r', result
        bag, title = result['id'].split(':', 1)
        tiddler = Tiddler(title, bag)
        return tiddler
        #return store.get(tiddler)

    for result in results:
        yield tiddler_from_result(result)
    return