def search(self, query, vocab_filter=None): """Return a resultset of archives. This is a helper required by `SQLObjectVocabularyBase.searchForTerms`. """ if not query: return self.emptySelectResults() query = query.lower() if query.startswith('~'): query = query.strip('~') if query.startswith('ppa:'): query = query[4:] try: query_split = query.split('/') if len(query_split) == 3: owner_name, distro_name, archive_name = query_split else: owner_name, archive_name = query_split except ValueError: search_clause = Or( fti_search(Archive, query), fti_search(Person, query)) else: search_clause = And( Person.name == owner_name, Archive.name == archive_name) clause = And( self._filter, get_enabled_archive_filter( getUtility(ILaunchBag).user, purpose=ArchivePurpose.PPA, include_public=True), search_clause) return self._table.select( clause, orderBy=self._orderBy, clauseTables=self._clauseTables)
def get_specification_filters(filter, goalstatus=True): """Return a list of Storm expressions for filtering Specifications. :param filters: A collection of SpecificationFilter and/or strings. Strings are used for text searches. """ clauses = [] # ALL is the trump card. if SpecificationFilter.ALL in filter: return clauses # Look for informational specs. if SpecificationFilter.INFORMATIONAL in filter: clauses.append(Specification.implementation_status == SpecificationImplementationStatus.INFORMATIONAL) # Filter based on completion. See the implementation of # Specification.is_complete() for more details. if SpecificationFilter.COMPLETE in filter: clauses.append(get_specification_completeness_clause()) if SpecificationFilter.INCOMPLETE in filter: clauses.append(Not(get_specification_completeness_clause())) # Filter for goal status. if goalstatus: goalstatus = None if SpecificationFilter.ACCEPTED in filter: goalstatus = SpecificationGoalStatus.ACCEPTED elif SpecificationFilter.PROPOSED in filter: goalstatus = SpecificationGoalStatus.PROPOSED elif SpecificationFilter.DECLINED in filter: goalstatus = SpecificationGoalStatus.DECLINED if goalstatus: clauses.append(Specification.goalstatus == goalstatus) if SpecificationFilter.STARTED in filter: clauses.append(get_specification_started_clause()) # Filter for validity. If we want valid specs only, then we should exclude # all OBSOLETE or SUPERSEDED specs. if SpecificationFilter.VALID in filter: clauses.append( Not( Specification.definition_status.is_in([ SpecificationDefinitionStatus.OBSOLETE, SpecificationDefinitionStatus.SUPERSEDED ]))) # Filter for specification text. for constraint in filter: if isinstance(constraint, basestring): # A string in the filter is a text search filter. clauses.append(fti_search(Specification, constraint)) return clauses
def search(self, query, vocab_filter=None): """Return a resultset of archives. This is a helper required by `SQLObjectVocabularyBase.searchForTerms`. """ if not query: return self.emptySelectResults() query = query.lower() try: owner_name, archive_name = query.split('/') except ValueError: clause = And( self._filter, Or(fti_search(Archive, query), fti_search(Person, query))) else: clause = And( self._filter, Person.name == owner_name, Archive.name == archive_name) return self._table.select( clause, orderBy=self._orderBy, clauseTables=self._clauseTables)
def get_specification_filters(filter, goalstatus=True): """Return a list of Storm expressions for filtering Specifications. :param filters: A collection of SpecificationFilter and/or strings. Strings are used for text searches. """ clauses = [] # ALL is the trump card. if SpecificationFilter.ALL in filter: return clauses # Look for informational specs. if SpecificationFilter.INFORMATIONAL in filter: clauses.append( Specification.implementation_status == SpecificationImplementationStatus.INFORMATIONAL) # Filter based on completion. See the implementation of # Specification.is_complete() for more details. if SpecificationFilter.COMPLETE in filter: clauses.append(get_specification_completeness_clause()) if SpecificationFilter.INCOMPLETE in filter: clauses.append(Not(get_specification_completeness_clause())) # Filter for goal status. if goalstatus: goalstatus = None if SpecificationFilter.ACCEPTED in filter: goalstatus = SpecificationGoalStatus.ACCEPTED elif SpecificationFilter.PROPOSED in filter: goalstatus = SpecificationGoalStatus.PROPOSED elif SpecificationFilter.DECLINED in filter: goalstatus = SpecificationGoalStatus.DECLINED if goalstatus: clauses.append(Specification.goalstatus == goalstatus) if SpecificationFilter.STARTED in filter: clauses.append(get_specification_started_clause()) # Filter for validity. If we want valid specs only, then we should exclude # all OBSOLETE or SUPERSEDED specs. if SpecificationFilter.VALID in filter: clauses.append(Not(Specification.definition_status.is_in([ SpecificationDefinitionStatus.OBSOLETE, SpecificationDefinitionStatus.SUPERSEDED]))) # Filter for specification text. for constraint in filter: if isinstance(constraint, basestring): # A string in the filter is a text search filter. clauses.append(fti_search(Specification, constraint)) return clauses
def searchBinaryPackages(self, text): """See `IDistroArchSeries`.""" from lp.soyuz.model.publishing import BinaryPackagePublishingHistory origin = [ BinaryPackageRelease, Join( BinaryPackagePublishingHistory, BinaryPackagePublishingHistory.binarypackagerelease == BinaryPackageRelease.id), Join( BinaryPackageName, BinaryPackageRelease.binarypackagename == BinaryPackageName.id)] find_spec = [BinaryPackageRelease, BinaryPackageName] archives = self.distroseries.distribution.getArchiveIDList() clauses = [ BinaryPackagePublishingHistory.distroarchseries == self, BinaryPackagePublishingHistory.archiveID.is_in(archives), BinaryPackagePublishingHistory.status.is_in( active_publishing_status)] order_by = [BinaryPackageName.name] if text: ranking = rank_by_fti(BinaryPackageRelease, text) find_spec.append(ranking) clauses.append( Or( fti_search(BinaryPackageRelease, text), BinaryPackageName.name.contains_string(text.lower()))) order_by.insert(0, ranking) result = IStore(BinaryPackageName).using(*origin).find( tuple(find_spec), *clauses).config(distinct=True).order_by( *order_by) # import here to avoid circular import problems from lp.soyuz.model.distroarchseriesbinarypackagerelease import ( DistroArchSeriesBinaryPackageRelease) # Create a function that will decorate the results, converting # them from the find_spec above into DASBPRs. def result_to_dasbpr(row): return DistroArchSeriesBinaryPackageRelease( distroarchseries=self, binarypackagerelease=row[0]) # Return the decorated result set so the consumer of these # results will only see DSPs. return DecoratedResultSet(result, result_to_dasbpr)
def searchBinaryPackages(self, text): """See `IDistroArchSeries`.""" from lp.soyuz.model.publishing import BinaryPackagePublishingHistory origin = [ BinaryPackageRelease, Join( BinaryPackagePublishingHistory, BinaryPackagePublishingHistory.binarypackagerelease == BinaryPackageRelease.id), Join( BinaryPackageName, BinaryPackageRelease.binarypackagename == BinaryPackageName.id)] find_spec = [BinaryPackageRelease, BinaryPackageName] archives = self.distroseries.distribution.getArchiveIDList() clauses = [ BinaryPackagePublishingHistory.distroarchseries == self, BinaryPackagePublishingHistory.archiveID.is_in(archives), BinaryPackagePublishingHistory.dateremoved == None] order_by = [BinaryPackageName.name] if text: ranking = rank_by_fti(BinaryPackageRelease, text) find_spec.append(ranking) clauses.append( Or( fti_search(BinaryPackageRelease, text), BinaryPackageName.name.contains_string(text.lower()))) order_by.insert(0, ranking) result = IStore(BinaryPackageName).using(*origin).find( tuple(find_spec), *clauses).config(distinct=True).order_by( *order_by) # import here to avoid circular import problems from lp.soyuz.model.distroarchseriesbinarypackagerelease import ( DistroArchSeriesBinaryPackageRelease) # Create a function that will decorate the results, converting # them from the find_spec above into DASBPRs. def result_to_dasbpr(row): return DistroArchSeriesBinaryPackageRelease( distroarchseries=self, binarypackagerelease=row[0]) # Return the decorated result set so the consumer of these # results will only see DSPs. return DecoratedResultSet(result, result_to_dasbpr)
def search(self, query, vocab_filter=None): """See `SQLObjectVocabularyBase.search`. We find specs where query is in the text of name or title, or matches the full text index and then filter out ineligible specs using `_filter_specs`. """ if not query: return CountableIterator(0, []) spec = self._spec_from_url(query) if self._is_valid_candidate(spec): return CountableIterator(1, [spec]) return Store.of(self.context).find( Specification, fti_search(Specification, query), self._exclude_blocked_query(), ).order_by(self._order_by())
def findSimilar(summary, product=None, distribution=None): """Return the FAQs similar to summary. See `IFAQTarget.findSimilarFAQs` for details. """ assert not (product and distribution), ( 'only one of product or distribution should be provided') if product: target_constraint = 'product = %s' % sqlvalues(product) elif distribution: target_constraint = 'distribution = %s' % sqlvalues(distribution) else: raise AssertionError('must provide product or distribution') phrases = nl_phrase_search(summary, FAQ, target_constraint) if not phrases: # No useful words to search on in that summary. return FAQ.select('1 = 2') return FAQ.select( And(target_constraint, fti_search(FAQ, phrases, ftq=False)), orderBy=[ rank_by_fti(FAQ, phrases, ftq=False), "-FAQ.date_created"])
def search(self, text): """See ICveSet.""" return Cve.select( fti_search(Cve, text), distinct=True, orderBy='-datemodified')