from flask import Flask
app = Flask(__name__)
app.route('/game', methods=['GET'])
def attendance():
return "hello"
if __name__ == '__main__':
app.run(debug=True)
Please refer this for a minimal flask application
https://flask.palletsprojects.com/en/1.1.x/quickstart/#a-minimal-application
Your example looks something like this:
app.py
from flask import Flask
app = Flask(__name__)
#app.route('/game')
def attendance():
return 'hello'
if __name__ == "__main__":
app.run(debug=True)
run the app.py (local) and open in browser as:
http://127.0.0.1:5000/game
Related
In Flask I can generate 404 (https://flask.palletsprojects.com/en/1.1.x/errorhandling/):
#app.errorhandler(404)
def page_not_found(error):
output = render_template("404.html",
title = 'Page not found')
but how create 404 page in Dash? With 404 response status.
You could create a Flask app and pass it to your Dash app. Then you could use the Flask app for the error handling and for redirecting to your Dash app:
from flask import Flask, render_template, redirect
from dash import Dash
import dash_html_components as html
server = Flask(__name__)
app = Dash(__name__, server=server, url_base_pathname='/dash/')
app.layout = html.P("Hello World")
#server.errorhandler(404)
def page_not_found(error):
return render_template("404.html", title="Page not found")
#server.route("/dash")
def dashboard():
return redirect("/dash/")
if __name__ == "__main__":
server.run()
It appears that my simple Starlette/Uvicorn web app is serving up incorrect MIME content type for Jinja templated (served from the same server) JavaScript files. As you can see from the screen shot the uvicorn server is casting the *.js file as type (“text/plain”).
Screenshot
I have scoured the documents for both Starlette and Uvicorn and am simply stumped.
My simple web app is as follows:
from starlette.applications import Starlette
from starlette.staticfiles import StaticFiles
from starlette.responses import HTMLResponse
from starlette.templating import Jinja2Templates
from starlette.middleware.cors import CORSMiddleware
import uvicorn
from random import randint
port = randint(49152,65535)
templates = Jinja2Templates(directory='templates')
app = Starlette(debug=True)
app.mount('/static', StaticFiles(directory='statics', html=True), name='static')
app.add_middleware(
CORSMiddleware, allow_origins=["*"], allow_headers=["*"], allow_methods=["*"]
)
#app.route('/')
async def homepage(request):
template = "index.html"
context = {"request": request}
return templates.TemplateResponse(template, context, media_type='text/html')
#app.route('/error')
async def error(request):
"""
An example error. Switch the `debug` setting to see either tracebacks or 500 pages.
"""
raise RuntimeError("Oh no")
#app.exception_handler(404)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
#app.exception_handler(500)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
if __name__ == "__main__":
uvicorn.run("app-567:app", host='0.0.0.0', port=port, log_level="info", http='h11', loop='asyncio', reload=True)
The JavaScript files that are loaded in the head give the same error but load nonetheless. This is a bi-product of the new 'nosniff' default setting in Firefox (73.0 64-bit). The scripts that are loaded as module imports fail outright.
I am running Windows 10 (x64), Python 3.7, uvicorn 0.11.2, and starlette 0.13.1.
Any help is greatly appreciated.
Thank you in advance.
I was able to fix this issue by explicitly setting the mimetypes variables as follows:
from starlette.applications import Starlette
from starlette.staticfiles import StaticFiles
from starlette.responses import HTMLResponse
from starlette.templating import Jinja2Templates
from starlette.middleware.cors import CORSMiddleware
import uvicorn
from random import randint
import mimetypes
mimetypes.init()
port = randint(49152,65535)
templates = Jinja2Templates(directory='templates')
app = Starlette(debug=True)
app.mount('/static', StaticFiles(directory='statics', html=True), name='static')
app.add_middleware(
CORSMiddleware, allow_origins=["*"], allow_headers=["*"], allow_methods=["*"]
)
#app.route('/')
async def homepage(request):
mimetypes.add_type('application/javascript', '.js')
mimetypes.add_type('text/css', '.css')
mimetypes.add_type('image/svg+xml', '.svg')
template = "index.html"
context = {"request": request}
return templates.TemplateResponse(template, context, media_type='text/html')
#app.route('/error')
async def error(request):
"""
An example error. Switch the `debug` setting to see either tracebacks or 500 pages.
"""
raise RuntimeError("Oh no")
#app.exception_handler(404)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
#app.exception_handler(500)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
if __name__ == "__main__":
uvicorn.run("app-567:app", host='0.0.0.0', port=port, log_level="info", http='h11', loop='asyncio', reload=True)
with the following code I am getting a 404 resource not found error after clicking authorize button for google drive. My code is below- any ideas what I am doing incorrectly?
from __future__ import print_function
import httplib2
import os
from apiclient import discovery
from oauth2client import client
from oauth2client import tools
from oauth2client.file import Storage
from apiclient.discovery import build
from google.appengine.ext import webapp
from oauth2client.appengine import OAuth2DecoratorFromClientSecrets
import webapp2
try:
import argparse
flags = argparse.ArgumentParser(parents=[tools.argparser]).parse_args()
except ImportError:
flags = None
except SystemExit:
flags= None
#
## If modifying these scopes, delete your previously saved credentials
## at ~/.credentials/drive-python-quickstart.json
SCOPES = 'https://www.googleapis.com/auth/drive'
CLIENT_SECRET_FILE = 'client_secret.json'
APPLICATION_NAME = 'Drive API Quickstart'
decorator = OAuth2DecoratorFromClientSecrets( CLIENT_SECRET_FILE,SCOPES)
service = build('drive', 'v3')
class MainHandler(webapp.RequestHandler):
#decorator.oauth_required
def get(self):
# Get the authorized Http object created by the decorator.
http = decorator.http()
# Call the service using the authorized Http object.
request = service.files().list(q = "mimeType != 'application/vnd.google-apps.folder'", pageSize=1000, )
response = request.execute(http=http)
app = webapp.WSGIApplication([
('/', MainHandler),
], debug=True)
I have https://drive-156701.appspot.com/oauth2callback with and without a / at the end as redirects, which I thought where the correct redirect urls?
Thanks!!
You don't have a URL handler for /oauth2callback. You only have a url handler for /. Try:
app = webapp.WSGIApplication([
('/oauth2callback', Oauth2CallbackHandler),
('/', MainHandler),
], debug=True)
and make a Oauth2CallbackHandler class to handle the callback.
In addition to including the :
app = webapp2.WSGIApplication(
[
('/', MainHandler),
(decorator.callback_path, decorator.callback_handler()),
],
debug=True)
The #decorator.oauth_required handles the callbacks for you.
Check out this video: https://www.youtube.com/watch?v=HoUdWBzUZ-M
You need to create credentials for both localhost development and deployed.
And make sure you have checked out: https://cloud.google.com/appengine/docs/standard/python/tools/using-libraries-python-27
Your api imports must be handled like 3rd party imports, details here:
https://developers.google.com/api-client-library/python/start/installation
I have been racking my brain for weeks trying to get this authentication module to work under the webapp2 framework using Jinja, NDB and WTForms. I've looked online everywhere and have reached my breaking point and need to reach out to somebody for help. I've been following this tutorial (which is pretty thorough but I think leaves out some important details, especially for a newbie like me):
User Accounts with Webapp2 + Google App Engine
As far as I know I have everything setup correctly but I continually get a 404 - resources can not be found. What could I be doing wrong? Here is my code...
handlers.py:
import webapp2
import sys
from google.appengine.ext import ndb
sys.modules['ndb'] = ndb
import webapp2_extras.appengine.auth.models as auth_models
from google.appengine.api import users
from webapp2_extras import sessions, auth # we'll use auth later on
from webapp2_extras.auth import InvalidAuthIdError
from webapp2_extras.auth import InvalidPasswordError
from wtforms import Form, TextField, PasswordField, validators
from webapp2_extras.appengine.users import login_required
def jinja2_factory(app):
j = jinja2.Jinja2(app)
j.environment.filters.update({
# Set filters. (http://tinyurl.com/jinja2-factory)
# ...
})
j.environment.globals.update({
# Set global variables.
'uri_for': webapp2.uri_for,
# ...
})
return j
def login_required(handler):
def check_login(self, *args, **kwargs):
if not self.user:
return self.redirect_to('login')
else:
return handler(self, *args, **kwargs)
return check_login
class UserAwareHandler(webapp2.RequestHandler):
def dispatch(self):
try:
super(UserAwareHandler, self).dispatch()
finally:
# Save the session after each request
self.session_store.save_sessions(self.response)
#webapp2.cached_property
def session_store(self):
return sessions.get_store(request=self.request)
#webapp2.cached_property
def session(self):
return self.session_store.get_session(backend="datastore")
#webapp2.cached_property
def auth(self):
return auth.get_auth(request=self.request)
#webapp2.cached_property
def user(self):
user = self.auth.get_user_by_session()
return user
#webapp2.cached_property
def user_model(self):
user_model, timestamp = self.auth.store.user_model.get_by_auth_token(
self.user['user_id'],
self.user['token']) if self.user else (None, None)
return user_model
#webapp2.cached_property
def jinja2(self):
return jinja2.get_jinja2(factory=jinja2_factory, app=self.app)
def render_response(self, _template, **context):
ctx = {'user': self.user_model}
ctx.update(context)
rv = self.jinja2.render_template(_template, **ctx)
self.response.write(rv)
class SignupForm(Form):
email = TextField('Email',
[validators.Required(),
validators.Email()])
password = PasswordField('Password',
[validators.Required(),
validators.EqualTo('confirm_password',
message="Passwords must match.")])
password_confirm = PasswordField('Confirm Password',
[validators.Required()])
class SignupHandler(UserAwareHandler):
#Serves up a signup form, creates new users
def get(self):
self.render_response("templates/signup.html", form=SignupForm())
def post(self):
form = SignupForm(self.request.POST)
error = None
if form.validate():
success, info = self.auth.store.user_model.create_user(
"auth:" + form.email.data,
unique_properties=['email'],
email= form.password.data,
password_raw= form.password.data)
if success:
self.auth.get_user_by_password("auth:"+form.email.data,
form.password.data)
return self.redirect_to("index")
else:
error = "That email is already in use." if 'email'\
in user else "Something has gone horrible wrong."
self.render_response("templates/signup.html", form=form, error=error)
class LoginForm(Form):
email = TextField('Email',
[validators.Required(), validators.Email()])
password = PasswordField('Password',
[validators.Required()])
class LoginHandler(UserAwareHandler):
def get(self):
self.render_response("templates/index.html", form=LoginForm())
def post(self):
form = LoginForm(self.request.POST)
error = None
if form.validate():
try:
self.auth.get_user_by_password(
"auth:"+form.email.data,
form.password.data)
return self.redirect_to('secure')
except (auth.InvalidAuthIdError, auth.InvalidPasswordError):
error = "Invalid Email / Password"
self.render_response("templates/login.html", form=form, error=error)
class LogoutHandler(UserAwareHandler):
#Destroy the user session and return them to the login screen.
#login_required
def get(self):
self.auth.unset_session()
self.redirect_to('login')
class IndexHandler(UserAwareHandler):
def get(self):
ctx = {
'title1': "ALAZA",
'title2': "HOA",
'slogan': "A communication tool for the Alazan HOA.",
'message1': """
<p>The whole idea here is to show how to set up a simple static web site
on Google App Engine. I want to create an easy way to host your modest web
site on App Engine. My approach is dead simple. All I use is some boilerplate
code almost anyone can follow. You can have multiple pages and use template
variable features that are part of App Engine's WebApp Framework. Most modest
web sites don't do much more than this. Your certainly free to expand on what
you find here.</p>""",
}
self.render_response('templates/index.html', **ctx)
main.py:
import webapp2
import config
import routes
import sys
from google.appengine.ext import ndb
sys.modules['ndb'] = ndb
import webapp2_extras.appengine.auth.models as auth_models
class AwesomeUser(auth_models.User):
email = ndb.StringProperty()
webapp2_config = {}
webapp2_config['webapp2_extras.sessions'] = {
'secret_key': 'othello',}
webapp2_config['webapp2_extras.auth'] = {
'user_model': AwesomeUser,}
app = webapp2.WSGIApplication(config=config.webapp2_config)
routes.add_routes(app)
routes.py:
import handlers
import webapp2
from webapp2_extras.routes import RedirectRoute
# Using redirect route instead of simple routes since it supports strict_slash
# Simple route: http://webapp-improved.appspot.com/guide/routing.html#simple-routes
# RedirectRoute: http://webapp-improved.appspot.com/api/webapp2_extras/routes.html#webapp2_extras.routes.RedirectRoute
_routes = [
RedirectRoute('templates/login.html', handlers.LoginHandler, name='login'),
RedirectRoute('/templates/logout.html', handlers.LogoutHandler, name='logout'),
RedirectRoute('/templates/index.html', handlers.IndexHandler, name='index'),
RedirectRoute('/templates/signup.html', handlers.SignupHandler, name='signup'),]
def get_routes():
return _routes
def add_routes(app):
if app.debug:
secure_scheme = 'http'
for r in _routes:
app.router.add(r)
app.yaml:
application: alazan-hoa
version: main
runtime: python27
api_version: 1
threadsafe: true
handlers:
- url: /js
static_dir: js
- url: /images
static_dir: images
- url: /css
static_dir: css
- url: /.*
script: main.app
libraries:
- name: webapp2
version: "2.5.1"
- name: jinja2
version: "2.6"
builtins:
- appstats: on
In your routes.py file, in the RedirectRoute you specify html files, while you should specify paths that are mapped to handler methods and inside them render the html templates.
For example, in your routes.py file you should have something like this:
_routes = [
RedirectRoute('/login', handlers.LoginHandler, name='login'),
RedirectRoute('/logout', handlers.LogoutHandler, name='logout'),
RedirectRoute('/index', handlers.IndexHandler, name='index'),
RedirectRoute('/signup', handlers.SignupHandler, name='signup')
]
You can take a look at Google App Engine Boilerplate for an introduction to Google App Engine development and best practices around it.
Hope this helps!
i'm working on a task that i want to convert text file into PDF one using conversion API that is in GAE , i tried as: https://developers.google.com/appengine/docs/python/conversion/overview
This is the code that i used:
from __future__ import with_statement
from google.appengine.api import files
import cgi, cgitb ; cgitb.enable()
import StringIO
from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
import mimetypes
from google.appengine.ext import blobstore
from mimetypes import guess_type
from google.appengine.api import conversion
def mime_type(filename):
return guess_type(filename)[0]
class get(webapp.RequestHandler):
def post(self):
form = cgi.FieldStorage()
file_upload = form['file']
name=file_upload.filename
m=mimetypes.guess_type(name)[0]
data=file_upload.file.read()
buf = StringIO.StringIO()
asset = conversion.Asset("text/plain", data, file_upload.filename)
conversion_obj = conversion.ConversionRequest(asset, "application/pdf")
result = conversion.convert(conversion_obj)
if result.assets:
for asset in result.assets:
buf.write(asset.data)
else:
print "ERROR"
u_file = files.blobstore.create(mime_type="application/pdf",_blobinfo_uploaded_filename="test.pdf")
data=buf.getvalue()
with files.open(u_file, 'a') as f:
f.write(data)
files.finalize(u_file)
blob_key = files.blobstore.get_blob_key(u_file)
blob_info = blobstore.get(blob_key)
name2 = blob_info.filename
self.response.out.write("""<html><br><body style="background-color:#CC9999"><b><font size="5" face="Batang" ><center> <li ><a href="download.py?blob_key=%s" style="color:black">%s
</center></font><hr></body></html>
""" % (str(blob_key),str(name2)))
def main():
application = webapp.WSGIApplication( [(r'/get.py', get)], debug=True)
run_wsgi_app(application)
if __name__ == "__main__":
main()
download.py:
from __future__ import with_statement
from google.appengine.ext import blobstore
from google.appengine.ext import webapp
from google.appengine.ext.webapp import blobstore_handlers
from google.appengine.ext.webapp.util import run_wsgi_app
from mimetypes import guess_type
def mime_type(filename):
return guess_type(filename)[0]
class Thumbnailer(blobstore_handlers.BlobstoreDownloadHandler):
def get(self):
blob_key = self.request.get("blob_key")
if blob_key:
blob_info = blobstore.get(blob_key)
if blob_info:
save_as1 = blob_info.filename
type2=mime_type(blob_info.filename)
self.send_blob(blob_info,content_type=type2,save_as=save_as1)
return
def main():
application = webapp.WSGIApplication([
(r'/download.*', Thumbnailer),
], debug=True)
run_wsgi_app(application)
if __name__ == '__main__':
main()
EDIT:i edited the code, and when i try to print buf.getvalue(),i get :failed to load pdf document.
But when i try to open this PDF,i can't open it and the adobe reader gives error immediately that it can't open the file. Sorry i'm still beginner,any help please? Any suggestions are welcome.
Here is my working code sample(it's for Python2.7 runtime though). Good luck!
import os
import StringIO
from google.appengine.api import conversion
from google.appengine.api import files
from google.appengine.ext import blobstore
from google.appengine.ext import webapp
from google.appengine.ext.webapp import blobstore_handlers
import jinja2
template_dir = os.path.join(os.path.dirname(__file__), 'templates')
jinja2_env = jinja2.Environment(
loader=jinja2.FileSystemLoader(template_dir))
class MainHandler(webapp.RequestHandler):
def get(self):
tmpl = jinja2_env.get_template('index.jinja2')
self.response.out.write(tmpl.render())
class PostHandler(blobstore_handlers.BlobstoreDownloadHandler):
def post(self):
data = self.request.get('file')
asset = conversion.Asset('text/plain', data, 'test.txt')
conversion_obj = conversion.Conversion(asset, 'application/pdf')
result = conversion.convert(conversion_obj)
buf = StringIO.StringIO()
if result.assets:
for asset in result.assets:
buf.write(asset.data)
else:
raise Exception('Conversion failed.')
u_file = files.blobstore.create(mime_type='application/pdf',
_blobinfo_uploaded_filename='test.pdf')
with files.open(u_file, 'a') as f:
f.write(buf.getvalue())
files.finalize(u_file)
blob_key = files.blobstore.get_blob_key(u_file)
blob_info = blobstore.get(blob_key)
self.send_blob(blob_info)
app = webapp.WSGIApplication([
('/', MainHandler),
('/post_file', PostHandler),
],
debug=True)
Are you sure that your 'data' (retrieved by data=file_upload.file.read()) is correct?
Maybe you can stop using cgi module, and just use a request object that webapp creates for you like:
data = self.request.get('file')
BTW, please don't use private attributes like asset._data, use asset.data instead. Additionally, what the StringIO is for? Have you considered just writing asset.data directly to the opened file?
Update: I think I find the cause.
Just after the conversion, please do as follows:
if result.assets:
for asset in result.assets
buf.write(asset.data)