def inner(self, *argv, **kwargv): if modules.get_current_module_name() != tap.config.BACKEND_NAME: cache = yield self.has_cache_async(expire, temporary=temporary) if cache: return ndb.toplevel(func)(self, *argv, **kwargv) if self.response.status_int == 200: if empty or len(self.response.body) > 0: self.put_cache(period, temporary=temporary)
def inner(self, *argv, **kwargv): ndb.toplevel(func)(self, *argv, **kwargv) if self.response._app_iter is None: index = 0 else: index = len(self.response._app_iter) self.response.write(AHEAD_HTML5) if len(packages): self.response.write(get_resource_code(packages)) if self.response._app_iter is not None: self.response._app_iter = self.response._app_iter[index:] + self.response._app_iter[:index]
def test_is_acceptable(self): with pytest.raises(ValueError): utils.TokenBucket(rate=3, size=10) b = utils.TokenBucket(rate=1, size=2) b.is_acceptable = ndb.toplevel(utils.make_synctasklet(b.is_acceptable_async)) assert b.is_acceptable() is True assert b.is_acceptable() is True assert b.is_acceptable() is False b = utils.TokenBucket(rate=1, size=1, prefix="test") b.is_acceptable = ndb.toplevel(utils.make_synctasklet(b.is_acceptable_async)) assert b.is_acceptable() is True assert b.is_acceptable() is False assert b.is_acceptable(key="test") is True assert b.is_acceptable(key="test") is False
def test_is_acceptable(self): with pytest.raises(ValueError): tap.TokenBucket(rate=3, size=10) b = tap.TokenBucket(rate=1, size=2) b.is_acceptable = ndb.toplevel(tap.make_synctasklet(b.is_acceptable_async)) assert b.is_acceptable() is True assert b.is_acceptable() is True assert b.is_acceptable() is False b = tap.TokenBucket(rate=1, size=1, prefix="test") b.is_acceptable = ndb.toplevel(tap.make_synctasklet(b.is_acceptable_async)) assert b.is_acceptable() is True assert b.is_acceptable() is False assert b.is_acceptable(key="test") is True assert b.is_acceptable(key="test") is False
def run_wsgi_app(application_or_mapping): """This wrapped version of run_wsgi_app accepts an instance of either WSGIApplication or list""" from google.appengine.ext.webapp import WSGIApplication as _WSGIApplication if isinstance(application_or_mapping, list): application = _WSGIApplication(application_or_mapping, debug=True) from google.appengine.ext.webapp.util import run_wsgi_app as _run_wsgi_app from google.appengine.ext import ndb _run_wsgi_app(ndb.toplevel(application))
def inner(self, *argv, **kwargv): ndb.toplevel(func)(self, *argv, **kwargv) if origin is None: allow_origin = self.request.headers.get("Origin") if allow_origin is None and self.request.referer: allow_origin = "{0}://{1}".format(*urlparse(self.request.referer)[:2]) else: if callable(origin): allow_origin = origin() if allow_origin: self.response.headers["Access-Control-Allow-Origin"] = allow_origin if security.compare_hashes(self.request.method, "OPTIONS"): self.response.headers["Access-Control-Max-Age"] = tap.config.CORS_Access_Control_Max_Age method = self.request.headers.get("Access-Control-Request-Method") if method: self.response.headers["Access-Control-Allow-Methods"] = method headers = self.request.headers.get("Access-Control-Request-Headers") if headers: self.response.headers["Access-Control-Allow-Headers"] = headers
def decorator(fn): fn = adapt_exceptions(fn) fn = auth.public(fn) fn = endpoints_decorator(fn) ts_mon_time = lambda: utils.datetime_to_timestamp(utils.utcnow()) / 1e6 fn = gae_ts_mon.instrument_endpoint(time_fn=ts_mon_time)(fn) # ndb.toplevel must be the last one. # See also the comment in endpoint decorator in api.py return ndb.toplevel(fn)
def decorator(fn): fn = catch_errors(fn, response_message_class) fn = endpoints_decorator(fn) fn = ndb.toplevel(fn) def ts_mon_time(): return utils.datetime_to_timestamp(utils.utcnow()) / 1000000.0 fn = gae_ts_mon.instrument_endpoint(time_fn=ts_mon_time)(fn) return fn
def decorator(fn): fn = auth.public(fn) fn = endpoints_decorator(fn) fn = ndb.toplevel(fn) def ts_mon_time(): return utils.datetime_to_timestamp(utils.utcnow()) / 1000000.0 fn = gae_ts_mon.instrument_endpoint(time_fn=ts_mon_time)(fn) return fn
def toplevel_wrapper(*args, **kwargs): """Enables a WSGI application to not exit until all its asynchronous requests have finished. For more information, see https://developers.google.com/appengine/docs/python/ndb/async#intro Args: *args: Variable length argument list. **kwargs: Arbitrary keyword arguments. """ return ndb.toplevel(*args, **kwargs)
def decorator(fn): fn = catch_errors(fn, response_message_class) fn = init_auth(fn) ts_mon_time = lambda: utils.datetime_to_timestamp(utils.utcnow()) / 1e6 fn = gae_ts_mon.instrument_endpoint(time_fn=ts_mon_time)(fn) # ndb.toplevel must be the last one. # We use it because codebase uses the following pattern: # results = [f.get_result() for f in futures] # without ndb.Future.wait_all. # If a future has an exception, get_result won't be called successive # futures, and thus may be left running. return ndb.toplevel(fn)
def __init__(self, *argv, **kwargv): for method_name in METHOD_NAMES: method = getattr(self, method_name, None) if method: method = ndb.toplevel(method) setattr(self, method_name, method) super(RequestHandler, self).__init__(*argv, **kwargv) if self.use_zipfile: setattr(self.response, "flush", self._response_flush) setattr(self.response, "tell", self._response_tell) self.dispatch = tap.set_urlfetch_deadline(self.urlfetch_deadline)(self.dispatch) namespace = inspect.getmodule(self).__dict__.get(tap.NAMESPACE_KEY) if namespace is not None: self.dispatch = tap.in_namespace(namespace)(self.dispatch) self.context["USERS"] = self.users = Users(self)
def clear_event_queue(app): """Clear ndb event queue. Some Futures complete and get their job done, triggering completion callbacks to be stuck in the event queue. However, since we just writing regular NDB code (not tasklets), there is no guarantee that the event queue will be emptied when the request finishes. This leaves Futures stuck in the thread-local cache, in each thread, uselessly between requests. There is no way to disable this like with an NDB cache. However, You can solve this by wrapping *any* code that uses NDB objects with `@ndb.toplevel`. The documentation mentions this only in the context of being useful for tasklet code this should be run for *ALL* code that uses NDB libraries. In fact, given the nature of what it does, can be done in a wrapper around the wsgi library in the appengine runtime, similar to what is done with the threadlocal variables in `appengine.runtime`’s management of `request_environment.current_request`. """ return ndb.toplevel(app)
app = ndb.toplevel( webapp2.WSGIApplication( [ ('/', MainHandler), ('(.*)/$', SlashMurdererApp), ('/privacy', PrivacyHandler), ('/privacy-policy', PrivacyHandler), ('/terms', TermsHandler), ('/facebook', FbHandler), ('/about', AboutHandler), ('/contact', ContactHandler), ('/versus', VersusHandler), ('/timed', TimedHandler), ('/multiplayer', FriendsHandler), ('/games-multiplayer', GameMultiplayerHandler), ('/games', GamesHandler), ('/learn-english', LearnEnglishHandler), ('/learn-english/(.*)', EnglishLevelHandler), ('/campaign', CampaignHandler), # need js rendering (r'/campaign/..*', MainHandler), (r'/campaign/..*/..*', MainHandler), (r'/versus/..*', MainHandler), (r'/tests', TestsHandler), ('/buy', BuyHandler), ('/sitemap', SitemapHandler), ] + gameon.routes, debug=ws.debug, config=config))
# if result_msg != '': # row_log_msg.append(result_msg) # if result_vcmsg is not None: # for key, value in result_vcmsg.iteritems(): # #row_log_msg.extend(value) # row_log_msg.extend(['[' + key + ']' + msg for msg in value]) # # # オペレーションログ出力 # operation_log_detail = {} # operation_log_detail['fields'] = [{'key':'user_id', 'before':src_user_id, 'after':dst_user_id}] # UCFMDLOperationLog.addLog(login_operator_mail_address, login_operator_unique_id, UcfConfig.SCREEN_USER, UcfConfig.OPERATION_TYPE_CHANGEID, vo.get('user_id', ''), vo.get('unique_id', ''), login_operator_client_ip, JSONEncoder().encode(operation_log_detail), is_async=True) # # # except BaseException, e: # self.outputErrorLog(e) # code = '500' # row_log_msg.append(self._formatLogRecord('system error.')) # # # エラーメッセージ処理 # if code != '': # #row_log_msg.append(self._formatLogRecord('[row:' + UcfUtil.nvl(record_cnt) + ',code=' + code + ']')) # row_log_msg.insert(0, self._formatLogRecord('[row:' + UcfUtil.nvl(record_cnt) + ',code=' + code + ']')) # return deal_type, code, row_log_msg #app = webapp2.WSGIApplication([('/a/([^/]*)/([^/]*)/queue_csv_import', Page)], debug=sateraito_inc.debug_mode, config=sateraito_func.wsgi_config) app = ndb.toplevel( webapp2.WSGIApplication([('/a/([^/]*)/([^/]*)/queue_csv_import', Page)], debug=sateraito_inc.debug_mode, config=sateraito_func.wsgi_config))
# temporary image for location report from android until I figure out how to upload an image from android image_url = 'https://00e9e64baca7129fd93c9b3c8fae1d3ae5001f077dd61bb04b-apidata.googleusercontent.com/download/storage/v1/b/pick-up-sports-images/o/android-p1.jpg?qk=AD5uMEuOyI7kIsV5921fxnl-gWsfZOKuVbNlQ0Lw7LKG2rLUpSqfQ_ZjHI4SP_N-qxx9SwFXvYFeY2UHR6teOmaFpbnbAlxefv_QNBTITsAd_cZAN9uFhEmS4UIn902NXs0tkffM3cpqLGIEd6tGuDXZXWRVhcpRKbhDzFCKrsV3k-EXamjkg1nJpghP2qD97tgcUSZ_2SPeGpWSpxHP8GXpb-035YggBqcNFQg0g3feGprHlIEWBgdogaggLIrnURw25xif4ZeRNuntjt1qGHvaqr5UJ-FGxannzHDze963-nxCnLPCNpPFFmLFcEP6I8TuT2zg9gzCKo_T-V6SgxpDbqsop3tDBiKllOF916BcA1CNoJz-GmIBZuWh0R1YilaLGLItENa_NrUtLo4yW86ZipTiXH9lAccvQv44Zw1cr-CukEOo639n-evNOMCNTRqAWzkNTeSsT3CrAtunzzwcMF1B3_D8M1M6Vq-n9Dnv9qMOpPcpe8DhqqHyjFrd_p2-vlenyTXda8SLapI0i77hTfVfSBQMOUn6p5mL-OaoSb_a9xUFIom6ey8fehPVIFClvkNGeAR833Y8vu6DCeifvoUlZnI5tjRKjLTy4AR7Y3umvRUEznJOFJfD9r_txOjI4emW_7pYPn78SxoSMZfro4zqQlrWMKWJ0sC-DlJgIjANvVEKA6dkcGoBKGHNoq9bM9Noz1aCeA-X_MK_bP0n9xK6nZLrGbDsSwAzTofEqV8Scd2dhs4' location_name = self.request.get('location_name') address = self.request.get('address') sport_theme_name = self.request.get('sport_theme_name') tag_names_string = self.request.get('tags') tag_name_list = tag_names_string.split() create_location_report(location_name, address, sport_theme_name, email, tag_name_list, image_url) else: self.response.write('signed in user is ' + email + result) # [START app] app = ndb.toplevel( webapp2.WSGIApplication([('/', HomePage), ('/add_location_report', HomePage), ('/mobile/home_page', HomePageMobile)], debug=True)) def main(): app.run() if __name__ == "__main__": main() # [END app]
def get(self): self.render('templates/contact.jinja2') class TermsHandler(BaseHandler): def get(self): self.render('templates/terms.jinja2') class SitemapHandler(webapp2.RequestHandler): def get(self): self.response.headers['Content-Type'] = 'text/xml' template_values = {} template = JINJA_ENVIRONMENT.get_template('templates/sitemap.xml') self.response.write(template.render(template_values)) app = ndb.toplevel( webapp2.WSGIApplication( [ ('/', MainHandler), ('/tests', TestHandler), ('/privacy', PrivacyHandler), ('/terms', TermsHandler), # ('/about', AboutHandler), ('/contact', ContactHandler), ('/sitemap', SitemapHandler), ] + gameon.routes, debug=ws.debug, config=config))
zip_file = fetch_as_zip(zip_path) posts = [post for post in _extract_posts(zip_file)] Post.delete_all() Post.put_all(posts) def serve_post(request): post_url = request.path_info post = Post.get_by_id(post_url) if not post: webapp.abort(404) return render('post.html', dict(post = post)) def tagged(request, tag): return render('index.html', dict(posts = Post.query(Post.tags == tag).order(-Post.date), without_intro = True)) def feed(request): response = render('feed.xml', dict(posts = Post.query().order(-Post.date))) response.headers['Content-Type'] = 'application/rss+xml' return response def index(request): return render('index.html', dict(posts = Post.query().order(-Post.date))) application = ndb.toplevel(webapp.WSGIApplication([ webapp.SimpleRoute('/_refresh/', handler = refresh), webapp.Route('/tags/<tag>', handler = tagged, name = 'by-tag'), webapp.SimpleRoute('/_ah/warmup', handler = index), webapp.SimpleRoute('/feed', handler = feed), webapp.SimpleRoute('/', handler = index), webapp.SimpleRoute('/.*', handler = serve_post) ], debug=True).__call__)
def inner(self, *argv, **kwargv): self.set_session_store() ndb.toplevel(func)(self, *argv, **kwargv)
# read upload data, save it in GCS and a zip archive file_data = self.request.get("file", default_value=None) if file_data: filename = self.request.POST["file"].filename bf = blob_files.BlobFiles.new(filename, folder=GCS_UPLOAD_FOLDER) if bf: bf.blob_write(file_data) bf.put_async() logging.info('Uploaded and saved in default GCS bucket : ' + bf.gcs_filename) # update zip archive. make sure this (new) bf will be archived bzf = blob_files.blob_archive(new_bf=bf) context.update(dict(failed=None, bzf_url=bzf.serving_url, bzf_name=bzf.filename, bf_url=bf.serving_url, bf_name=bf.filename)) else: context.update(dict(failed='Overwrite blocked. The GCS file already exists in another bucket and/or folder')) else: logging.warning('No file data') self.render_template('blob_links.html', **context) routes = [ webapp2.Route(r'/blob_upload', handler=BlobUpload), webapp2.Route(r'/readme', handler='blob_upload.BlobUpload:readme'), ('/use_blobstore/([^/]+)?', blob_serve.UseBlobstore), ] app = ndb.toplevel(webapp2.WSGIApplication(routes=routes, debug=True))
''' Created on Apr 26, 2016 @author: abhi ''' import webapp2 from google.appengine.ext import ndb from recording import RecordingsAPI from recording import RecordingsDownloadAPI from recording import RecordingsListAPI app = ndb.toplevel( webapp2.WSGIApplication([('/recording', RecordingsAPI), ('/recording/list', RecordingsListAPI), ('/recording/download', RecordingsDownloadAPI)], debug=False))
# self.add_topic(topics, snapshots) ndb.put_multi_async(topics) ndb.put_multi_async(snapshots) memcache.set(counting_mc_key, counting) # memcache.set(last_id_mc_key, str(item['last_id_current_page'])) task.last_id = str(item['last_id_current_page']) task.counting = counting task.put_async() # page += 1 # not implement yet, counting is hard payload[0] = (payload[0][0], task.last_id) # payload[-1] = (payload[-1][0], page) res = requests.post(url, payload, headers=headers) j = res.json() item = j['item'] # counted = memcache.get(counting_mc_key) # tag_key = ndb.Key(Tag, tag) # tag = tag_key.get() # tag.counting = counted # tag.put() # memcache.delete(counting_mc_key) memcache.delete(last_id_mc_key) memcache.delete(item_mc_key) app = ndb.toplevel( webapp2.WSGIApplication( [('/crons/set_announcement', SetAnnouncementHandler), ('/tasks/send_confirmation_email', SendConfirmationEmailHandler), ('/tasks/collect_topic_tag', CollectTopicTagHandler)], debug=True))
template_path = os.path.dirname(__file__) + '/templates' locale_path = os.path.dirname(__file__) + '/locale' logging.info('setting template path to %s' % template_path) webapp2_config['webapp2_extras.jinja2'] = { 'template_path': template_path, 'filters': jinja_filters, 'environment_args': jinja_environment_args } webapp2_config['webapp2_extras.i18n'] = { 'translations_path': locale_path, 'default_locale': 'en', 'default_timezone': 'America/Montreal', } webapp2_config['webapp2_extras.sessions'] = { 'secret_key': '82374y6ii899hy8-89308847-21u9x676', } webapp2_config['webapp2_extras.auth'] = { 'user_model': User, } routes = create_routes() application = ndb.toplevel(webapp2.WSGIApplication(routes, debug=True, config=webapp2_config))
#!/usr/bin/env python from sys import path from os import listdir path.append('./') import webapp2 from google.appengine.ext import ndb from lib.utils import DEBUG routes = [] for file_name in listdir('api'): if not file_name.startswith('.') and file_name.endswith( '.py') and file_name != '__init__.py': api_name = file_name[:-3] api_module = __import__('api.%s' % api_name).__getattribute__(api_name) routes += api_module.routes app = ndb.toplevel(webapp2.WSGIApplication(routes, debug=DEBUG))
class uploadPixel(webapp2.RequestHandler): """Upload an image handler used in the /upload-image form""" def get(self): upload_url = blobstore.create_upload_url('/upload-image2') template_values = {'upload_url' : upload_url } template = JINJA_ENVIRONMENT.get_template('upload-image.html') self.response.write(template.render(template_values)) class BlobStoreHandler(blobstore_handlers.BlobstoreUploadHandler): """ get the image upload to datastore, called on submit of /upload-image form""" def post(self): image = self.get_uploads('img') blob_info = image[0] print blob_info pixel = Pixel(id="image") pixel.img = blob_info.key() pixel.put() self.redirect('/') application = ndb.toplevel(webapp2.WSGIApplication([ ('/', MainPage), ('/main.png', ImageRequest), ('/landing-page', LandingPage), ('/upload-image', uploadPixel), ('/upload-image2',BlobStoreHandler) ], debug=True))
and statistic about this click is saved. All invalid clicks (e.g. for non existing campaigns, platforms) users are redirected to http://outfit7.com. """ # cast campaign_id, type checking is done through route definition try: campaign_id = int(campaign_id) except ValueError: return webapp2.redirect("http://outfit7.com", permanent=True) platform_id = "%d-%s" % (campaign_id, platform_name) platform = Platform.get_by_id(platform_id) if platform: memcache.incr(platform_id, 1, namespace="counters", initial_value=0) try: deferred.defer(Platform.increment, platform_id, _countdown=TRACKER_COUNTER_UPDATE_INTERVAL_LENGTH, _name="%s-%d" % (platform_id, get_interval_index())) except (taskqueue.TaskAlreadyExistsError, taskqueue.TombstonedTaskError), e: pass # TODO: optimize with async operations campaign = Campaign.get_by_id(campaign_id) return webapp2.redirect(campaign.link.encode("utf8")) else: return webapp2.redirect("http://outfit7.com", permanent=True) app = ndb.toplevel(webapp2.WSGIApplication([ routes.PathPrefixRoute('/api', [ webapp2.Route(r'/campaign/<campaign_id>/platform/<platform_name>', ClickHandler), ]) ], debug=False))
self.write_column(stat.victory_points_yesterday) self.write_column(stat.victory_points_last_week) self.write_column(stat.victory_points_total) self.response.out.write('\n') def totals(self): # For now just spit out CSV self.response.headers['Content-Type'] = 'text/plain' qry = TotalStat.query().order(-TotalStat.date) self.response.out.write("date,killsYesterday,killsLastWeek,killsTotal,victoryPointsYesterday,victoryPointsLastWeek,victoryPointsTotal\n") for stat in qry.fetch(): self.response.out.write(stat.date) self.write_column(stat.kills_yesterday) self.write_column(stat.kills_last_week) self.write_column(stat.kills_total) self.write_column(stat.victory_points_yesterday) self.write_column(stat.victory_points_last_week) self.write_column(stat.victory_points_total) self.response.out.write('\n') app = ndb.toplevel(webapp2.WSGIApplication([ ('/', MainHandler), ('/cron', CronHandler), ('/cruncher', CruncherHandler), webapp2.Route('/feed/factions', handler='main.FeedHandler:factions'), webapp2.Route('/feed/totals', handler='main.FeedHandler:totals'), ], debug=True))
import logging import webapp2 from webapp2_extras.routes import PathPrefixRoute from google.appengine.ext import ndb import app.config from app import tasks from app.tasks import webhooks config = {} config['webapp2_extras.sessions'] = { 'secret_key': 'ezAK4re16aXlKG80cAMz' } application = ndb.toplevel(webapp2.WSGIApplication([ PathPrefixRoute('/_webhooks', [ webapp2.Route('/thonkify', webhooks.ThonkifyEndpoint), webapp2.Route('/debug', tasks.LogParams) ]), (r'.*', tasks.NotFound), ], debug=app.config.DEBUG, config=config)) def main(): logging.getLogger().setLevel(logging.INFO) application.run() if __name__ == "__main__": main()
# NOTICE: THIS FILE HAS BEEN MODIFIED BY MOBICAGE NV IN ACCORDANCE WITH THE APACHE LICENSE VERSION 2.0 # Copyright 2018 GIG Technology NV # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # @@license_version:1.5@@ import webapp2 from google.appengine.ext import ndb from framework.handlers.login import AuthenticationRequiredHandler from framework.utils.plugins import get_handlers_for_auth, Handler from framework.wsgi import WSGIApplication, AUTH_LVL_PRIVATE handlers = [ webapp2.Route('/login_required', AuthenticationRequiredHandler) ] handlers.extend(get_handlers_for_auth(Handler.AUTH_AUTHENTICATED)) app = ndb.toplevel(WSGIApplication(handlers, name="main_authenticated", auth=AUTH_LVL_PRIVATE))
# distributed under the License is distributed on an 'AS IS' BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from google.appengine.api import users from google.appengine.ext import ndb import webapp2 class Account(ndb.Model): view_counter = ndb.IntegerProperty() class MyRequestHandler(webapp2.RequestHandler): @ndb.toplevel def get(self): acct = Account.get_by_id(users.get_current_user().user_id()) acct.view_counter += 1 acct.put_async() # Ignoring the Future this returns # ...read something else from Datastore... self.response.out.write('Content of the page') # This is actually redundant, since the `get` decorator already handles it, but # for demonstration purposes, you can also make the entire app toplevel with # the following. app = ndb.toplevel(webapp2.WSGIApplication([('/', MyRequestHandler)]))
vote=t['votes'], comment=t['comments'], author=t['author'], disp_topic=t['disp_topic'], topic_type=str(t['topic_type']), utime=datetime.strptime(t['utime'], '%m/%d/%Y %H:%M:%S'), tags=tags) topics.append(topic) # counting += 1 ndb.put_multi_async(topics) # task.put_async() looping += 1 last_id = str(item['last_id_current_page']) payload[0] = (payload[0][0], last_id) res = requests.post(url, payload, headers=headers) j = res.json() item = j['item'] class TestHandler(webapp2.RequestHandler): def post(self): pass app = ndb.toplevel( webapp2.WSGIApplication( [('/collect_topics/forum', CollectTopicsForumHandler), ('/collect_topics/tag', CollectTopicsTagHandler), ('/test', TestHandler)], debug=True))
# ndb.toplevel makes sure that all *_async() functions that we didn't wait for # with get_result() finish before the handler returns. application = ndb.toplevel( webapp2.WSGIApplication( [ ('/rest/ratingHistory', RatingHistoryHandler), ('/rest/rate', RateHandler), ('/rest/extendedPageDetails', ExtendedPageDetailsHandler), ('/rest/recommendations', RecommendationsHandler), ('/rest/pastRecommendations', PastRecommendationsHandler), ('/rest/markUnread', MarkUnreadHandler), ('/rest/popularPages', PopularPagesHandler), ('/rest/deleteRating', DeleteRatingHandler), ('/rest/getConfig', GetConfigHandler), ('/rest/categories', CategoriesHandler), ('/rest/addCategory', AddCategoryHandler), ('/rest/renameCategory', RenameCategoryHandler), ('/rest/removeCategory', RemoveCategoryHandler), ('/rest/suggestCategory', SuggestCategoryHandler), ('/rest/setPageCategory', SetPageCategoryHandler), ('/rest/requestExportRatings', RequestExportRatingsHandler), ('/rest/exportStatus', ExportStatusHandler), ('/rest/deleteAccount', DeleteAccountHandler), # Admin actions. ('/rest/admin/actions', AdminActionsHandler), ('/rest/admin/executeAction', AdminExecuteActionHandler), ('/download_history', DownloadHistoryHandler), ('/', MainPageHandler) ], debug=config.IsDev()))
def decorator(fn): fn = catch_errors(fn, response_message_class) fn = endpoints_decorator(fn) fn = ndb.toplevel(fn) return fn
# central tree end # # if not 'COE' in analyze_value_map: # return 'forms/analyze/coe.html' # COE = analyze_value_map['COE'] # if COE == VALUE_UP: # return 'forms/result/ahz.html' # if not 'RBC' in analyze_value_map: # return 'forms/analyze/rbc.html' # RBC = analyze_value_map['RBC'] # if RBC == VALUE_DOWN: # return 'forms/result/aplastich_anemia.html' return 'forms/result/unknown.html' application = ndb.toplevel(webapp2.WSGIApplication([ ('/', HomePage), ('/pacients', PacientsPage), ('/stats', AppPage), ('/cabinet', AppPage), ('/pacient-create', PacientCreate), ('/pacient/(\d+)', PacientPage), ('/save-analyze', SaveAnalyzePage), ('/remove-analyze/(\d+)/(\w+)', RemoveAnalyzePage), ], debug=True))
from handler.dumps import DumperHandler class TasksHandler(webapp2.RequestHandler): def get(self): logging.info("Get request to notification page.") self.response.write("Welcome to the tasks module.") routes = [ (r'/tasks/parsecsv', ParseCSVHandler), (r'/tasks/schedule', ScheduleHandler), (r'/tasks/delete_resources', GCSResourcesDeleteHandler), (r'/tasks/delete_schedule', ScheduleDeleteHandler), (r'/tasks/check_schedule_delete', ScheduleDeleteCheckHandler), (r'/tasks/retry_check', RetryCheckHandler), # (r'/tasks/recipient_queue_data_health_check', RecipientQueueDataHealthCheckHandler), webapp2.Route('/tasks/_cb/deferred/<module>/<name>', tasks.DeferredHandler), # debug only (r'/tasks/clear_retry', ClearReTryHandler), (r'/tasks/clear_recipient_queue_data', ClearRecipientQueueDataHandler), (r'/tasks/dump', DumperHandler), (r'/.*', TasksHandler) ] router = ndb.toplevel(webapp2.WSGIApplication(routes, debug=True))
application = ndb.toplevel(webapp2.WSGIApplication([ webapp2.Route('/', app.views.user.Landing, 'landing'), webapp2.Route('/login', app.views.simple.Login, 'login'), webapp2.Route('/logout', app.views.simple.Logout, 'logout'), webapp2.Route('/signup', app.views.user.Signup, 'signup'), webapp2.Route('/guidelines', app.views.user.Guidelines, 'guidelines'), webapp2.Route('/missions/create', app.views.mission.Create, 'create_mission'), webapp2.Route('/missions/<guid>', app.views.mission.View, 'view_mission'), webapp2.Route('/missions/<guid>/update', app.views.mission.Update, 'update_mission'), webapp2.Route('/queue', app.views.mission.Queue, 'mission_queue'), webapp2.Route('/manage', app.views.manage.Root, 'manage_root'), webapp2.Route('/manage/', app.views.manage.Root, 'manage_root_s'), webapp2.Route('/manage/users', app.views.manage.Users, 'manage_users'), webapp2.Route('/manage/users/', app.views.manage.Users, 'manage_users_s'), webapp2.Route('/_cron/reap-empty-missions', app.cron.ReapEmptyMissions, 'cron_reap'), #webapp2.Route('/_tasks/geocode-mission', app.tasks.GeocodeMission, 'task_geocode'), webapp2.Route('/_tasks/reap-empty-missions', app.tasks.ReapEmptyMissions, 'task_reap'), (r'.*', app.views.simple.NotFound), ], debug=DEBUG_MODE))
if user: ndb.Key(urlsafe=userUrlSafe).delete() self.redirect('/customers') else: self.redirect('/customers') app = ndb.toplevel(webapp2.WSGIApplication([ ('/', DashboardHandler), ('/stores/delete/(.*?)', StoresDeleteHandler), ('/users/delete/(.*?)', DbUsersDeleteHandler), ('/customers/delete/(.*?)', CustomersDeleteHandler), ('/stores', StoresHandler), ('/users', DbUsersHandler), ('/customers', CustomersHandler), ('/items', ItemsHandler), ('/transactions/invoices', TransactionInvoicesHandler), ('/transactions/loans', TransactionLoansHandler), ('/transactions/receipts', TransactionReceiptsHandler), ('/transactions/redeems', TransactionRedeemsHandler), ('/transactions/stocks', TransactionStocksHandler), ('/transactions', TransactionsHandler), ('/reports', ReportsHandler), ('/settings', SettingsHandler), ], debug=True))
"""Main.py for twittertorss app.""" import logging import os os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' # Force Django to reload its settings. from django.conf import settings from django.core.handlers import wsgi from django.core import signals from django import db from django import dispatch from google.appengine.ext import ndb def log_exception(*args, **kwargs): logging.exception('Exception in request:') signal = dispatch.Signal() # Log errors. signal.connect(log_exception, signals.got_request_exception) # Unregister the rollback event handler. signal.disconnect(db._rollback_on_exception, signals.got_request_exception) # Wrapping the WSGI application in ndb.toplevel ensures that all async # operations complete before returning. app = ndb.toplevel(wsgi.WSGIHandler())
from web import errors from lib import basehandler app = webapp2.WSGIApplication(debug=basehandler.IS_DEV, config=config.webapp2_config, routes=routes.get_routes()) # If you want dynamic custom error handlers use below # or just comment it out. This is useful for gracefully showing errors to users # with all your layout in place if not basehandler.IS_BACKEND: # defined custom error handlers class Webapp2HandlerAdapter(webapp2.BaseHandlerAdapter): def __call__(self, request, response, exception): request.route_args = { 'exception': exception } logging.exception(exception) handler = self.handler(request, response) return handler.get() app.error_handlers[403] = Webapp2HandlerAdapter(errors.Error403Handler) app.error_handlers[404] = Webapp2HandlerAdapter(errors.Error404Handler) app.error_handlers[503] = Webapp2HandlerAdapter(errors.Error503Handler) app.error_handlers[500] = Webapp2HandlerAdapter(errors.Error500Handler) # Make sure all ndb async futures finish app = ndb.toplevel(app)
template_path = os.path.dirname(__file__) + '/templates' locale_path = os.path.dirname(__file__) + '/locale' logging.info('setting template path to %s' % template_path) webapp2_config['webapp2_extras.jinja2'] = { 'template_path': template_path, 'filters': jinja_filters, 'environment_args': jinja_environment_args } webapp2_config['webapp2_extras.i18n'] = { 'translations_path': locale_path, 'default_locale': 'en', 'default_timezone': 'America/Montreal', } webapp2_config['webapp2_extras.sessions'] = { 'secret_key': '82374y6ii899hy8-89308847-21u9x676', } webapp2_config['webapp2_extras.auth'] = { 'user_model': User, } routes = create_routes() application = ndb.toplevel( webapp2.WSGIApplication(routes, debug=True, config=webapp2_config))
# -*- coding:utf-8 -*- import os import webapp2 from google.appengine.ext import ndb from naziscore.handlers import ( RefreshOutdatedProfileHandler, CleanupRepeatedProfileHandler, ) DEBUG = os.environ.get('SERVER_SOFTWARE', '').startswith('Dev') app = webapp2.WSGIApplication([ webapp2.Route('/_ah/cron/refresh', RefreshOutdatedProfileHandler, name='calculation_handler_legacy_v1'), webapp2.Route('/_ah/cron/cleanup', CleanupRepeatedProfileHandler, name='cleanup_handler_v1'), ], debug=DEBUG) app = ndb.toplevel(app)
self.response.headers['Content-Type'] = 'text/plain' if not users.is_current_user_admin(): self.response.set_status(401) self.response.out.write('unauthorized') return user = users.get_current_user() desc = user.email() token = auth.create_auth_token(desc) lines = [ 'save the following to .fileset.json:', '', '{"token": "%s"}' % token, '', ] payload = '\n'.join(lines) self.response.out.write(payload) app = ndb.toplevel(webapp2.WSGIApplication([ webapp2.Route('/_fs/api/blob.exists', handler=BlobExistsHandler), webapp2.Route('/_fs/api/blob.upload', handler=BlobUploadHandler), webapp2.Route('/_fs/api/branch.get_manifest', handler=BranchGetManifestHandler), webapp2.Route('/_fs/api/branch.set_manifest', handler=BranchSetManifestHandler), webapp2.Route('/_fs/api/cron.timed_deploy', handler=CronTimedDeployHandler), webapp2.Route('/_fs/api/manifest.upload', handler=ManifestUploadHandler), webapp2.Route('/_fs/token', handler=TokenHandler), ]))
for timeseries in data['timeseries']: points = [] fields = [] for point in timeseries['points']: points.append( Point(time=float(point['time']), value=float(point['value']))) for field in timeseries['fields']: fields.append(Field(key=field['key'], value=field['value'])) tsList.append( TimeSeries(points=points, fields=fields, metric=timeseries['metric'])) futures = [timeseries_query(t) for t in tsList] ndb.Future.wait_all(futures) for future in futures: future.get_result() return message_types.VoidMessage() handlers = [ ('/tasks/clean_outdated_graphs', CronHandler), ('/timeseries_update', TimeSeriesHandler), ] WEBAPP = add_appstats(webapp2.WSGIApplication(handlers, debug=True)) APPLICATION = add_appstats( ndb.toplevel(endpoints.api_server([ConsoleAppApi, UIApi, config.ConfigApi])))
self.response.out.write("<em>* Indicates a Type with multiple parent Types</em>") global treeline if not HelpCache.get('Tree'): logging.debug("HelpCache MISS: Tree") self.getTypesAndTree() self.response.out.write("<table class=\"type-table\">\n") if not HelpCache.get('DataType'): treeline = "" walkTree("http://schema.org/DataType",0,True) HelpCache['DataType'] = treeline self.response.out.write(HelpCache['DataType']) self.response.out.write("</table>\n") self.response.out.write("<table class=\"type-table\">\n") if not HelpCache.get('Thing'): treeline = "" walkTree("http://schema.org/Thing",0,True) HelpCache['Thing'] = treeline self.response.out.write(HelpCache.get('Thing')) self.response.out.write("</table>\n") else: self.error(404) self.response.out.write("<h3>Sorry, the page you requested isn't available.</h2>") self.response.out.write("<h3>You can <a href='/schemas'>browse the Schemas page </a> as a way to get started using the site.</h3>") self.response.out.write("<br/><hr width='80%'/>") self.response.out.write(api.ShowUnit.getVersion()) self.response.out.write(headers.footers) app = ndb.toplevel(webapp2.WSGIApplication([("/(.*)", MainPage)]))
class SendActivity(webapp2.RequestHandler): def get(self): for ui in UserInfo.query(): if ui.daily: deferred.defer(util.daily_digest, ui.key) class cron_trash(webapp2.RequestHandler): def get(self): delta = datetime.timedelta(days=7) now = datetime.datetime.now() period = now - delta bmq = Bookmarks.query(Bookmarks.trashed == True, Bookmarks.data < period) ndb.delete_multi([bm.key for bm in bmq]) app = ndb.toplevel(webapp2.WSGIApplication([ routes.RedirectRoute('/admin/', AdminPage, name='Admin', strict_slash=True), routes.PathPrefixRoute('/admin', [ webapp2.Route('/digest', SendDigest), webapp2.Route('/activity', SendActivity), webapp2.Route('/check', CheckFeeds), webapp2.Route('/cron_trash', cron_trash), ]) ], debug=util.debug, config=util.config)) if __name__ == "__main__": app.run()
class ContactHandler(BaseHandler): def get(self): self.render('templates/contact.jinja2') class TermsHandler(BaseHandler): def get(self): self.render('templates/terms.jinja2') class SitemapHandler(webapp2.RequestHandler): def get(self): self.response.headers['Content-Type'] = 'text/xml' template_values = { } template = JINJA_ENVIRONMENT.get_template('templates/sitemap.xml') self.response.write(template.render(template_values)) app = ndb.toplevel(webapp2.WSGIApplication([ ('/', MainHandler), ('/tests', TestHandler), ('/privacy', PrivacyHandler), ('/terms', TermsHandler), # ('/about', AboutHandler), ('/contact', ContactHandler), ('/sitemap', SitemapHandler), ] + gameon.routes, debug=ws.debug, config=config))
logging.debug("HelpCache MISS: Tree") self.getTypesAndTree() self.response.out.write("<table class=\"type-table\">\n") if not HelpCache.get('DataType'): treeline = "" walkTree("http://schema.org/DataType", 0, True) HelpCache['DataType'] = treeline self.response.out.write(HelpCache['DataType']) self.response.out.write("</table>\n") self.response.out.write("<table class=\"type-table\">\n") if not HelpCache.get('Thing'): treeline = "" walkTree("http://schema.org/Thing", 0, True) HelpCache['Thing'] = treeline self.response.out.write(HelpCache.get('Thing')) self.response.out.write("</table>\n") else: self.error(404) self.response.out.write( "<h3>Sorry, the page you requested isn't available.</h2>") self.response.out.write( "<h3>You can <a href='/schemas'>browse the Schemas page </a> as a way to get started using the site.</h3>" ) self.response.out.write("<br/><hr width='80%'/>") self.response.out.write(api.ShowUnit.getVersion()) self.response.out.write(headers.footers) app = ndb.toplevel(webapp2.WSGIApplication([("/(.*)", MainPage)]))
application = ndb.toplevel(webapp2.WSGIApplication( [('/', MainPage), ### /appointment/make/POST_DATA ('/appointment/make/', MakeAppointment), ### /appointment/query/timeline/DOCTOR/DATE ('/appointment/query/timeline/(.*)/(.*)', ShowAvailableTimeline), ### /api/query/token ('/api/query/(.*)', GetPatientInfo), ### mockup ('/mockup', MockData), ### /snail_admin ('/snail_admin', MainAdmin), ### /snail_admin/appointment/modify/urlsafe_entity_key/appointment_status/value ('/snail_admin/appointment/modify/(.*)/(.*)/(.*)', ModifyAppointment), ### /snail_admin/search/patient/email/[email protected] ('/snail_admin/search/patient/(.*)', GetPatient), ### /snail_admin/modify/patient/check_in/patient_uuid ('/snail_admin/modify/patient/check_in/(.*)', ModifyPatientCheckIn), ### /snail_admin/create/patient ('/snail_admin/create/patient', AddPatient), ], debug=True, config=session_config))
def __unicode__(self): return (u'%s: %s' % (self.designator, self.summary))[:40] def get_absolute_url(self): return "/tasks/o%s/" % self.key.id() @property def designator(self): return 'o%s' % self.key.id() class TasklistHandler(gaetk.handler.BasicHandler): def get(self): user = users.get_current_user() tasks = Task.query().fetch(100) Task(account=user, summary='Software screiben', description='Unklar', to='*****@*****.**').put() self.render(dict(title=u"Tasks", tasks=tasks, ), 'taskmaster2/main.html') urls = [('^/tasks/$', TasklistHandler)] app = ndb.toplevel(webapp.WSGIApplication(urls)) def main(): util.run_wsgi_app(app) if __name__ == '__main__': main()
schemasInitialized = False def read_schemas(): """Read/parse/ingest schemas from data/*.rdfa. Also alsodata/*examples.txt""" import os.path import glob global schemasInitialized if (not schemasInitialized): files = glob.glob("data/*.rdfa") file_paths = [] for f in files: file_paths.append(full_path(f)) parser = parsers.MakeParserOfType('rdfa', None) items = parser.parse(file_paths) files = glob.glob("data/*examples.txt") example_contents = [] for f in files: example_content = read_file(f) example_contents.append(example_content) parser = parsers.ParseExampleFile(None) parser.parse(example_contents) schemasInitialized = True read_schemas() app = ndb.toplevel(webapp2.WSGIApplication([("/(.*)", ShowUnit)]))
#!/usr/bin/env python from sys import path from os import listdir path.append('./') import webapp2 from google.appengine.ext import ndb from lib.utils import DEBUG routes = [] for file_name in listdir('api'): if not file_name.startswith('.') and file_name.endswith('.py') and file_name != '__init__.py': api_name = file_name[:-3] api_module = __import__('api.%s' % api_name).__getattribute__(api_name) routes += api_module.routes app = ndb.toplevel(webapp2.WSGIApplication(routes, debug=DEBUG))
#!/usr/bin/python2.7 """ Web module """ __author__ = '[email protected] (Abhijit Kalamkar)' import webapp2 from google.appengine.ext import ndb from web.chart import EventChart from web.poll import Poll app = ndb.toplevel(webapp2.WSGIApplication([ ('/chart/events', EventChart), ('/poll/.*', Poll) ], debug=False))
self.response.write(self.AddCachedText(node, self.outputStrings)) def read_file (filename): import os.path folder = os.path.dirname(os.path.realpath(__file__)) file_path = os.path.join(folder, filename) strs = [] for line in open(file_path, 'r').readlines(): strs.append(line) return "".join(strs) schemasInitialized = False def read_schemas(): import os.path global schemasInitialized if (not schemasInitialized): schema_content = read_file('data/schema.rdfa') example_content = read_file('data/examples.txt') ft = 'rdfa' parser = parsers.MakeParserOfType(ft, None) items = parser.parse(schema_content) parser = parsers.ParseExampleFile(None) parser.parse(example_content) schemasInitialized = True read_schemas() app = ndb.toplevel(webapp2.WSGIApplication([("/(.*)", ShowUnit)]))
def inner(self, *argv, **kwargv): self.set_session_store() try: ndb.toplevel(func)(self, *argv, **kwargv) finally: self.session_store.save_sessions(self.response)
url = users.create_login_url(self.request.uri) url_linktext = 'Login' # create dictionary that we pass to the template template_values = { 'user': current_user, 'location_reports': location_reports, 'url': url, 'url_linktext': url_linktext, 'all_tag_names': json.dumps(all_tag_names), # 'addresses': json.dumps(addresses) 'location_reports_list': json.dumps(location_reports_lists) } template = JINJA_ENVIRONMENT.get_template('views/map.html') self.response.write(template.render(template_values)) # [START app] app = ndb.toplevel(webapp2.WSGIApplication([ ('/map', MapPage), ], debug=True)) def main(): app.run() if __name__ == "__main__": main() # [END app]
import urls allowed = ( re.compile("^.*$"), # Match a regex ) cors = CrossOriginResourceSharing(app) cors.set_allowed_origins(*allowed) # GAEMiniProfiler(app) # Flask-DebugToolbar (only enabled when DEBUG=True) # toolbar = DebugToolbarExtension(app) ADNTokenAuthMiddleware(app) # Werkzeug Debugger (only enabled when DEBUG=True) if app.debug: app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True) else: import logging # import email_logger root_logger = logging.getLogger() root_logger.setLevel(logging.INFO) #requests_log = logging.getLogger("requests") #requests_log.setLevel(logging.WARNING) #email_logger.register_logger(app.config['ADMIN_EMAIL']) app.wsgi_app = recording.appstats_wsgi_middleware(app.wsgi_app) app.__call__ = ndb.toplevel(app.__call__)