I am building an application in flask and a library called flask_tryton I do the process of creating the file init.py with the function create_app() as you see the tryton variable is used in that way that a connection to a database tryton is an api for flask, my problem is in the blueprint that does not allow using that variable to make my endpoints someone knows how I can use that variable in the party file which is a blueprint
import os
import uuid
from flask import Flask
from flask_tryton import Tryton
def create_app():
app = Flask(name)
app.config['TRYTON_DATABASE'] = os.environ.get('TRYTON_DATABASE')
app.config['TRYTON_CONFIG'] = os.environ.get('TRYTON_CONFIG')
app.config.from_mapping(
SECRET_KEY=uuid.uuid4().hex,
)
tryton = Tryton(app, configure_jinja=True)
from . import party
app.register_blueprint(party.bp)
return app
The problem I have is that it does not allow me to use the tryton variable in the party blueprint I am new to flask and I am trying to make this adaptation with tryton.
Related
I am fairly new to Flask applications, but well versed in Python. I have recently begun making web applications instead of regular application and I'm trying to gather some of them on a single server. Enter "Application Dispatching".
I was hoping to be able to develop an app locally and then deploy it on the server using dispatching. This means that locally I will have a script that launches the Flask app (wsgi.py), which imports stuff in the application. Now, once I add it to the dispatcher, I import the new application. This means that before the wsgi.py was a script and now it is a module - all hell breaks loose.
dispatcher.py:
from flask import Flask
from werkzeug.middleware.dispatcher import DispatcherMiddleware
from werkzeug.exceptions import NotFound
from app1 import app as app1
from app2 import app as app2
from app3 import app as app3
from app4 import app as app4
app = Flask(__name__)
app.wsgi_app = DispatcherMiddleware(NotFound(), {
"/app1": app1,
'/app2': app2,
'/app3': app3,
'/app4': app4,
})
if __name__ == "__main__":
app.run()
app1\__init__.py: (works like this, but merely a proof of concept / simple app)
from flask import Flask
app = Flask(__name__)
#app.route("/")
def index_one():
return "Hi im 1"
if __name__ == "__main__":
app.run()
Both of these work - the dispatcher and the app1 can be run independently. Now, let's say I need to import a module to make app1 more functional:
from flask import Flask
import db
...
Since the dispatcher is in a parent directory, in order for it to work I need to do something like this:
from . import db
# or
from app1 import db
Now the application doesn't work independently anymore. I would like to avoid either having to refactor the application every time it needs to be deployed or adding a lot of boilerplate code like this:
if __name__ == "__main__":
import db
else:
from . import db
In any case this doesn't work when configuring the app with app.config.from_object("config.Config") as it can't be forced to be relative import (?) and otherwise can't find it without explicitly telling it which module it resides in.
From the tutorial, I got the sense that I could isolate the applications from each other:
Application dispatching is the process of combining multiple Flask
applications on the WSGI level. You can combine not only Flask
applications but any WSGI application. This would allow you to run a
Django and a Flask application in the same interpreter side by side if
you want. The usefulness of this depends on how the applications work
internally.
The fundamental difference from Large Applications as Packages is that
in this case you are running the same or different Flask applications
that are entirely isolated from each other. They run different
configurations and are dispatched on the WSGI level.
What am I doing wrong and can I get it working like I describe, by being able to launch the applications isolated or on the dispatcher, without changing my code or adding a bunch of unrelated boilerplate code to make it work?
I figured it out myself and indeed was using application dispatcher wrong. It will always integrate the different applications into one server instance.
Instead, I found out that using nginx could be used to forward to different server instances, thus completely separating the applications in each virtual environment.
I am trying to login with flask-jwt but I am having problems when importing the security module,
the only install I've done to work with jwt was pip install flask-jwt. then I will leave the code, if you can help me I will be very grateful since I am just learning this micro-framework
from flask import Flask
from flask_jwt import JWT
from security import authenticate, identity
app = Flask(__name__)
app.secret_key = "security_key"
jwt = JWT(app, authenticate, identity)
if __name__ == "__main__":
app.run(debug=True, port=5500)
Do you have a module/file called security (e.g. security.py)?
The code in Flask-JWT quickstart example defines authenticate and identity methods: https://pythonhosted.org/Flask-JWT/#quickstart
I have a class that import google cloud:
StorageUtils:
from google.cloud import storage
I have a app that uses StorageUtils:
App:
import StorageUtils
Then I have a test, that I want to test my app
Test:
from app import App
I want to test my app without using google cloud. The easiest way I found is to use sys.modules:
import sys
from unittest.mock import MagicMock
sys.modules["google.cloud.storage"] = MagicMock()
I found this solution quite a work around. Are there any other way using python mock?
In this case, if the file that contains the class StorageUtils is called storage_utils.py:
#test_storage.py
#patch("storage_utils.storage")
def test_storage(st):
storage = StorageUtils()
I'm developing an API for our back-end, using python 3 and swagger + connexion (I just followed this great tutorial https://realpython.com/flask-connexion-rest-api/#using-connexion-to-add-a-rest-api-endpoint).
I was succesfully created my own API, when I run it locally the swagger ui perfectly appears (using this http://127.0.0.1:5000/api/ui/).
My problem is when I deploy it on IBM Cloud when I'm trying to access it, i have this error: 404 Not Found: Requested route does not exist).
Please see below my sample application code, my default python file.
# Sample flask app to connect to our backend
# __author__ = 'paulcaballero'
from flask import Flask, render_template
import data_connection as dc
import os
import connexion
from flask_restplus import Resource, Api
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
#Create the application instance
app = connexion.App(__name__, specification_dir='./')
# Read the swagger.yml file to configure the endpoints
app.add_api('swagger.yml')
# If we're running in stand alone mode, run the application
port = os.getenv('PORT', '5000')
if __name__ == "__main__":
`app.run(host='0.0.0.0', port=int(port))
I want my default page to show all my endpoints.
OK, so I have been through some tutorials to get a flask app onto google cloud, which is fine.
I have also been through the flask tutorial to build a flaskr blog:
http://flask.pocoo.org/docs/1.0/tutorial/
It occurred to me that a sensible thing to do would be to create a database (MySQL in mycase) on google and then modify the code so that it uses that. This is fine and I can get it to work on my local machine.
However, now that I am coming to deploying this, I have hit a problem.
The google cloud tutorials tend to use a flask app that is initiated in a single file such as main.py, eg:
from flask import Flask, render_template
app = Flask(__name__)
....
The flask tutorial mentioned above uses a package and puts the code to create_app() in the __init__.py file and at present I cannot get this to start in the same way. (see sample code).
from flask import Flask
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev'
)
Are there some adjustments that I need to make to something like the app.yaml file to get it to recognise flask as the flaskr package or do I need to rewrite the whole thing so that it uses a main.py file ?
I feel that this is one of the points in time where I could really pick up a bad habit. What in general is the preferred way to write flask apps on google cloud ?
I am using the standard environment in google.
Thanks for your advice.
Mark
Since you have an application factory, you can create the app anywhere. Just create it in main.py, since this is what App Engine expects:
from my_package import create_app
app = create_app()