def _get_locals(): if len(sys.argv) > 1: dbuser = sys.argv[1] else: dbuser = None dbconfig.override(dbuser=dbuser) execute_zcml_for_scripts() readline.parse_and_bind('tab: complete') # Mimic the real interactive interpreter's loading of any # $PYTHONSTARTUP file. startup = os.environ.get('PYTHONSTARTUP') if startup: execfile(startup) store = IMasterStore(Person) if dbuser == 'launchpad': # Create a few variables "in case they come in handy." # Do we really use these? Are they worth carrying around? d = Distribution.get(1) p = Person.get(1) ds = DistroSeries.get(1) prod = Product.get(1) proj = ProjectGroup.get(1) b2 = Bug.get(2) b1 = Bug.get(1) s = Specification.get(1) q = Question.get(1) # Silence unused name warnings d, p, ds, prod, proj, b2, b1, s, q # Having a factory instance is handy. factory = LaunchpadObjectFactory() def browser_open(obj, *args, **kwargs): """Open a (possibly newly-created) object's view in a web browser. Accepts the same parameters as canonical_url. Performs a commit before invoking the browser, so "browser_open(factory.makeFoo())" works. """ transaction.commit() webbrowser.open(canonical_url(obj, *args, **kwargs)) # Silence unused name warnings factory, store res = {} res.update(locals()) res.update(globals()) del res['_get_locals'] return res
def getTermByToken(self, token): found_dist = Distribution.selectOneBy(name=token, official_malone=True) if found_dist is None: raise LookupError(token) return self.getTerm(found_dist)
def __len__(self): return Distribution.selectBy(official_malone=True).count()
def __iter__(self): """Return an iterator which provides the terms from the vocabulary.""" distributions_using_malone = Distribution.selectBy( official_malone=True, orderBy=self._orderBy) for distribution in distributions_using_malone: yield self.getTerm(distribution)
def _get_distro(self, name): """Return the distro database object by name.""" distro = Distribution.selectOneBy(name=name) if not distro: raise DataSetupError("Error finding distribution %r" % name) return distro
def getTermByToken(self, token): found_dist = Distribution.selectOneBy( name=token, official_malone=True) if found_dist is None: raise LookupError(token) return self.getTerm(found_dist)
def getMostTranslatedPillars(self, limit=50): """See `ITranslationsOverview`.""" # XXX Abel Deuring 2012-10-26 bug=1071751 # The expression product.information_type IS NULL can be # removed once we have the DB constraint # "Product.information_type IS NULL". query = """ SELECT LOWER(COALESCE(product_name, distro_name)) AS name, product_id, distro_id, LN(total_karma)/LN(2) AS karma FROM ( SELECT product.displayname AS product_name, product.id AS product_id, distribution.displayname AS distro_name, distribution.id AS distro_id, SUM(karmavalue) AS total_karma FROM karmacache LEFT JOIN product ON product=product.id LEFT JOIN distribution ON distribution=distribution.id WHERE category=3 AND (product IS NOT NULL OR distribution IS NOT NULL) AND (product.translations_usage = %s AND (product.information_type = %s OR product.information_type IS NULL) OR distribution.translations_usage = %s) GROUP BY product.displayname, product.id, distribution.displayname, distribution.id HAVING SUM(karmavalue) > 0 ORDER BY total_karma DESC LIMIT %s) AS something ORDER BY name""" % sqlvalues(ServiceUsage.LAUNCHPAD, InformationType.PUBLIC, ServiceUsage.LAUNCHPAD, limit) cur = cursor() cur.execute(query) all_pillars = [] # Get minimum and maximum relative karma value to be able to normalize # them to appropriate font size values. minimum = None maximum = None for (name, product_id, distro_id, relative_karma) in cur.fetchall(): if minimum is None or relative_karma < minimum: minimum = relative_karma if maximum is None or relative_karma > maximum: maximum = relative_karma if product_id is not None: pillar = Product.get(product_id) elif distro_id is not None: pillar = Distribution.get(distro_id) else: raise MalformedKarmaCacheData( "Lots of karma for non-existing product or distribution.") all_pillars.append((pillar, relative_karma)) # Normalize the relative karma values between MINIMUM_SIZE and # MAXIMUM_SIZE. return self._normalizeSizes(all_pillars, minimum, maximum)