a flask profiler which watches endpoint calls and tries to make some analysis.

Overview

Flask-profiler

version: 1.8 Build Status

Flask-profiler measures endpoints defined in your flask application; and provides you fine-grained report through a web interface.

It gives answers to these questions:

  • Where are the bottlenecks in my application?
  • Which endpoints are the slowest in my application?
  • Which are the most frequently called endpoints?
  • What causes my slow endpoints? In which context, with what args and kwargs are they slow?
  • How much time did a specific request take?

In short, if you are curious about what your endpoints are doing and what requests they are receiving, give a try to flask-profiler.

With flask-profiler's web interface, you can monitor all your endpoints' performance and investigate endpoints and received requests by drilling down through filters.

Screenshots

Dashboard view displays a summary.

Alt text

You can create filters to investigate certain type requests.

Alt text

Alt text

You can see all the details of a request. Alt text

Quick Start

It is easy to understand flask-profiler going through an example. Let's dive in.

Install flask-profiler by pip.

pip install flask_profiler

Edit your code where you are creating Flask app.

# your app.py
from flask import Flask
import flask_profiler

app = Flask(__name__)
app.config["DEBUG"] = True

# You need to declare necessary configuration to initialize
# flask-profiler as follows:
app.config["flask_profiler"] = {
    "enabled": app.config["DEBUG"],
    "storage": {
        "engine": "sqlite"
    },
    "basicAuth":{
        "enabled": True,
        "username": "admin",
        "password": "admin"
    },
    "ignore": [
	    "^/static/.*"
	]
}


@app.route('/product/<id>', methods=['GET'])
def getProduct(id):
    return "product id is " + str(id)


@app.route('/product/<id>', methods=['PUT'])
def updateProduct(id):
    return "product {} is being updated".format(id)


@app.route('/products', methods=['GET'])
def listProducts():
    return "suppose I send you product list..."

@app.route('/static/something/', methods=['GET'])
def staticSomething():
    return "this should not be tracked..."

# In order to active flask-profiler, you have to pass flask
# app as an argument to flask-profiler.
# All the endpoints declared so far will be tracked by flask-profiler.
flask_profiler.init_app(app)


# endpoint declarations after flask_profiler.init_app() will be
# hidden to flask_profiler.
@app.route('/doSomething', methods=['GET'])
def doSomething():
    return "flask-profiler will not measure this."


# But in case you want an endpoint to be measured by flask-profiler,
# you can specify this explicitly by using profile() decorator
@app.route('/doSomethingImportant', methods=['GET'])
@flask_profiler.profile()
def doSomethingImportant():
    return "flask-profiler will measure this request."

if __name__ == '__main__':
    app.run(host="127.0.0.1", port=5000)

Now run your app.py

python app.py

And make some requests like:

curl http://127.0.0.1:5000/products
curl http://127.0.0.1:5000/product/123
curl -X PUT -d arg1=val1 http://127.0.0.1:5000/product/123

If everything is okay, Flask-profiler will measure these requests. You can see the result heading to http://127.0.0.1:5000/flask-profiler/ or get results as JSON http://127.0.0.1:5000/flask-profiler/api/measurements?sort=elapsed,desc

If you like to initialize your extensions in other files or use factory apps pattern, you can also create a instance of the Profiler class, this will register all your endpoints once you app run by first time. E.g:

from flask import Flask
from flask_profiler import Profiler

profiler = Profiler()

app = Flask(__name__)

app.config["DEBUG"] = True

# You need to declare necessary configuration to initialize
# flask-profiler as follows:
app.config["flask_profiler"] = {
    "enabled": app.config["DEBUG"],
    "storage": {
        "engine": "sqlite"
    },
    "basicAuth":{
        "enabled": True,
        "username": "admin",
        "password": "admin"
    },
    "ignore": [
        "^/static/.*"
    ]
}

profiler = Profiler()  # You can have this in another module
profiler.init_app(app)
# Or just Profiler(app)

@app.route('/product/<id>', methods=['GET'])
def getProduct(id):
    return "product id is " + str(id)

Using with different database system

You can use flaskprofiler with SqlLite, MongoDB, Postgresql, Mysql or MongoDB database systems. However, it is easy to support other database systems. If you would like to have others, please go to contribution documentation. (It is really easy.)

SQLite

In order to use SQLite, just specify it as the value of storage.engine directive as follows.

app.config["flask_profiler"] = {
    "storage": {
        "engine": "sqlite",
    }
}

Below the other options are listed.

Filter key Description Default
storage.FILE SQLite database file name flask_profiler.sql
storage.TABLE table name in which profiling data will reside measurements

MongoDB

In order to use MongoDB, just specify it as the value of storage.engine directive as follows.

app.config["flask_profiler"] = {
    "storage": {
        "engine": "mongodb",
    }
}

SQLAchemy

In order to use SQLAchemy, just specify it as the value of storage.engine directive as follows. Also first create an empty database with the name "flask_profiler".

app.config["flask_profiler"] = {
    "storage": {
        "engine": "sqlalchemy",
        "db_url": "postgresql://user:[email protected]:5432/flask_profiler"  # optional, if no db_url specified then sqlite will be used.
    }
}

Custom database engine

Specify engine as string module and class path.

app.config["flask_profiler"] = {
    "storage": {
        "engine": "custom.project.flask_profiler.mysql.MysqlStorage",
        "MYSQL": "mysql://user:[email protected]/flask_profiler"
    }
}

The other options are listed below.

Filter key Description Default
storage.MONGO_URL mongodb connection string mongodb://localhost
storage.DATABASE database name flask_profiler
storage.COLLECTION collection name measurements

Sampling

Control the number of samples taken by flask-profiler

You would want control over how many times should the flask profiler take samples while running in production mode. You can supply a function and control the sampling according to your business logic.

Example 1: Sample 1 in 100 times with random numbers

app.config["flask_profiler"] = {
    "sampling_function": lambda: True if random.sample(list(range(1, 101)), 1) == [42] else False
}

Example 2: Sample for specific users

app.config["flask_profiler"] = {
    "sampling_function": lambda: True if user is 'divyendu' else False
}

If sampling function is not present, all requests will be sampled.

Changing flask-profiler endpoint root

By default, we can access flask-profiler at /flask-profiler

app.config["flask_profiler"] = {
        "endpointRoot": "secret-flask-profiler"
}

Ignored endpoints

Flask-profiler will try to track every endpoint defined so far when init_app() is invoked. If you want to exclude some of the endpoints, you can define matching regex for them as follows:

app.config["flask_profiler"] = {
        "ignore": [
	        "^/static/.*",
	        "/api/users/\w+/password"
        ]
}

Contributing

Contributions are welcome!

Review the Contributing Guidelines for details on how to:

  • Submit issues
  • Add solutions to existing challenges
  • Add new challenges

Authors

License

MIT

Comments
  • Allow deletion of profiling from UI and/or profiling session

    Allow deletion of profiling from UI and/or profiling session

    Are you considering adding some functionality to start a profiling session. As information marked without it is difficult to process ?

    Also, one easy way of doing that would be to have buttons like :-

    1. delete all data (to start over)
    2. Save and delete all data (to save a session or all data so far and start over)

    If you guys agree on this, I can start working on a PR for the same :)

    Thanks

    enhancement 
    opened by divyenduz 12
  • Optimizing for production profiling like XHGui

    Optimizing for production profiling like XHGui

    Is there a feature where we can limit the number of samples probabilistic and use profile in production with huge load ?

    If such a feature is not present, we can create one like :-

    This is done in one of php profilers named XHGui | https://github.com/perftools/xhgui

    The following example configures XHGui to profile 1 in 100 requests, excluding requests with the /blog URL path:

    opened by divyenduz 10
  • No info in dashboard

    No info in dashboard

    I installed flask-profiler today and seems to work alright, except I don't get any methods info in the dashboard screen, what am I doing wrong?

    Filtering page seems to work alright.

    Please check the screenshots:

    dashboard: http://imgur.com/OfnCqU0 filtering: http://i.imgur.com/TdZkmgY

    bug 
    opened by alejoar 9
  • Flask crashes when static files are served (ProgrammingError: Recursive use of cursors not allowed)

    Flask crashes when static files are served (ProgrammingError: Recursive use of cursors not allowed)

    When I enable the flask-profiler, the app crashes when files from the static folder are served:

    Traceback (most recent call last):
      File "flask\app.py", line 1836, in __call__
        return self.wsgi_app(environ, start_response)
      File "flask\app.py", line 1820, in wsgi_app
        response = self.make_response(self.handle_exception(e))
      File "flask\app.py", line 1403, in handle_exception
        reraise(exc_type, exc_value, tb)
      File "flask\app.py", line 1817, in wsgi_app
        response = self.full_dispatch_request()
      File "flask\app.py", line 1477, in full_dispatch_request
        rv = self.handle_user_exception(e)
      File "flask\app.py", line 1381, in handle_user_exception
        reraise(exc_type, exc_value, tb)
      File "flask\app.py", line 1475, in full_dispatch_request
        rv = self.dispatch_request()
      File "flask\app.py", line 1461, in dispatch_request
        return self.view_functions[rule.endpoint](**req.view_args)
      File "flask_profiler\flask_profiler.py", line 91, in wrapper
        return wrapped(*args, **kwargs)
      File "flask_profiler\flask_profiler.py", line 72, in wrapper
        collection.insert(measurement.__json__())
      File "flask_profiler\storage\sqlite.py", line 128, in insert
        name))
    ProgrammingError: Recursive use of cursors not allowed.
    Traceback (most recent call last):
      File "flask\app.py", line 1836, in __call__
        return self.wsgi_app(environ, start_response)
      File "flask\app.py", line 1820, in wsgi_app
        response = self.make_response(self.handle_exception(e))
      File "flask\app.py", line 1403, in handle_exception
        reraise(exc_type, exc_value, tb)
      File "flask\app.py", line 1817, in wsgi_app
        response = self.full_dispatch_request()
      File "flask\app.py", line 1477, in full_dispatch_request
        rv = self.handle_user_exception(e)
      File "flask\app.py", line 1381, in handle_user_exception
        reraise(exc_type, exc_value, tb)
      File "flask\app.py", line 1475, in full_dispatch_request
        rv = self.dispatch_request()
      File "flask\app.py", line 1461, in dispatch_request
        return self.view_functions[rule.endpoint](**req.view_args)
      File "flask_profiler\flask_profiler.py", line 91, in wrapper
        return wrapped(*args, **kwargs)
      File "flask_profiler\flask_profiler.py", line 72, in wrapper
        collection.insert(measurement.__json__())
      File "flask_profiler\storage\sqlite.py", line 128, in insert
        name))
    ProgrammingError: Recursive use of cursors not allowed.
    

    I first though that this is, because requests to /static are not mentioned in the app routes, but also with a route with return app.send_static_file('index.html') I get the same error. All other routes (none are serving files from static) run fine.

    I am using:

    • Python 2.7.5
    • Flask 0.10.1
    • Flask-Profiler 0.5

    I am happy to provide more information if needed.

    opened by nlohmann 7
  • Image asset being counted on each page

    Image asset being counted on each page

    Whenever we load one of our pages, our logo (located at /static/assets/img/logo.png) is being counted in the flask-profiler as a GET with a name of "/static/path:filename" and is throwing off our Method distribution graph.

    Is there a way to remove this or make flask-profiler ignore this?

    screen shot 2017-02-15 at 2 24 22 pm

    question feature 
    opened by josiahtillman 6
  • Feature addition: ability to dump and delete database content

    Feature addition: ability to dump and delete database content

    • Ability to dump db
      • Used the getSummary interface for taking a dump, we can introduce an import functionality later.
    • Ability to remove db data
      • Made collection.truncate() to return uniformly for mongodb, sqlite collection. We need to make an interface for this should we need to add support for more databases.
    opened by divyenduz 5
  • use flask-profiler in wsgi production environment

    use flask-profiler in wsgi production environment

    Hi, for my flask application https://github.com/zimmerst/DmpWorkflow, i started using your brilliant profiler -- first off, thanks a lot for doing all the hard work for me. But I seem to be unable to use the flask profiler in the wsgi-production environment but only when i initialize the application by hand typing "python core/manage.py runserver"

    For reference, here's the relevant code piece that includes the profiler:

    from DmpWorkflow.config.defaults import cfg
    import flask_profiler
    from DmpWorkflow import version
    from socket import getfqdn
    kind = cfg.get("global", "installation")
    
    if kind == 'server':    
        from flask import Flask
        from flask.ext.mongoengine import MongoEngine
        app = Flask(__name__)
        app.config.update(LOGGER_NAME="core")
        app.config['MONGODB_DB'] = cfg.get("database", "name")
        app.config['MONGODB_USERNAME'] = cfg.get("database", "user")
        app.config['MONGODB_PASSWORD'] = cfg.get("database", "password")
        app.config['MONGODB_HOST'] = cfg.get("database", "host")
        app.config['MONGODB_PORT'] = int(cfg.get("database", "port"))
        # make connection numbers unbound
        app.config['MONGODB_MAXPOOLSIZE'] = None 
        # time out after 100ms
        app.config['MONGODB_WAITQUEUETIMEOUTMS'] = 100
        app.config["DEBUG"] = True
        app.config["flask_profiler"] = {
            "enabled": app.config["DEBUG"],
            "storage": {
                "engine": "sqlite",
                "FILE": "/tmp/flask-profiler.sql"
            },
            "basicAuth":{
                "enabled": True,
                "username": "myuser",
                "password": "mypassword"
            }
        }
    
        db = MongoEngine(app)
        
        def register_blueprints(app):
            # Prevents circular imports
            from DmpWorkflow.core.views import jobs
            from DmpWorkflow.core.admin import admin
            app.register_blueprint(jobs)
            app.register_blueprint(admin)
        
            if app.config['flask_profiler']['enabled']: app.logger.info("started flask profiler")
        register_blueprints(app)
        flask_profiler.init_app(app)
        
        def main():
            app.logger.info("started DmpWorkflow Server Version: %s on %s",version,getfqdn())
            app.run()
    else:
        def main():
            pass
    
    if __name__ == '__main__':
        if kind == 'server':
            main()
    

    and yes, when running the wsgi application, it runs fine, except that the profiler seems to be unable to handle multiple connections to the sql database:

    [Thu Nov 17 09:49:24.257431 2016] [wsgi:error] [pid 21519] started flask profiler
    [Thu Nov 17 09:49:24.257440 2016] [wsgi:error] [pid 21519] --------------------------------------------------------------------------------
    [Thu Nov 17 09:49:48.635678 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512] mod_wsgi (pid=21519): Exception occurred processing WSGI script '/var/www/flask_dev/workflow.wsgi'.
    [Thu Nov 17 09:49:48.635867 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512] Traceback (most recent call last):
    [Thu Nov 17 09:49:48.635979 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1836, in __call__
    [Thu Nov 17 09:49:48.636587 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     return self.wsgi_app(environ, start_response)
    [Thu Nov 17 09:49:48.636651 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1820, in wsgi_app
    [Thu Nov 17 09:49:48.636709 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     response = self.make_response(self.handle_exception(e))
    [Thu Nov 17 09:49:48.636737 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1403, in handle_exception
    [Thu Nov 17 09:49:48.636828 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     reraise(exc_type, exc_value, tb)
    [Thu Nov 17 09:49:48.636844 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1817, in wsgi_app
    [Thu Nov 17 09:49:48.636864 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     response = self.full_dispatch_request()
    [Thu Nov 17 09:49:48.636878 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1477, in full_dispatch_request
    [Thu Nov 17 09:49:48.636898 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     rv = self.handle_user_exception(e)
    [Thu Nov 17 09:49:48.636913 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1381, in handle_user_exception
    [Thu Nov 17 09:49:48.636932 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     reraise(exc_type, exc_value, tb)
    [Thu Nov 17 09:49:48.636965 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1475, in full_dispatch_request
    [Thu Nov 17 09:49:48.636986 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     rv = self.dispatch_request()
    [Thu Nov 17 09:49:48.637000 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask/app.py", line 1461, in dispatch_request
    [Thu Nov 17 09:49:48.637018 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     return self.view_functions[rule.endpoint](**req.view_args)
    [Thu Nov 17 09:49:48.637033 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask_profiler/flask_profiler.py", line 113, in wrapper
    [Thu Nov 17 09:49:48.637121 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     return wrapped(*args, **kwargs)
    [Thu Nov 17 09:49:48.637140 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask_profiler/flask_profiler.py", line 92, in wrapper
    [Thu Nov 17 09:49:48.637162 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     collection.insert(measurement.__json__())
    [Thu Nov 17 09:49:48.637176 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]   File "/opt/virtualenvs/DAMPE/lib/python2.7/site-packages/flask_profiler/storage/sqlite.py", line 128, in insert
    [Thu Nov 17 09:49:48.637288 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512]     name))
    [Thu Nov 17 09:49:48.637321 2016] [wsgi:error] [pid 21519] [remote 129.194.54.242:512] OperationalError: attempt to write a readonly database
    

    is there a way to make sure that the profiler can access the db for my multiple instances of the wsgi app? Thanks!

    database 
    opened by zimmerst 4
  • flask-profiler work in production mode?

    flask-profiler work in production mode?

    Does the flask-profiler only work in debug mode? While this is great for debugging, I'd like to collect statistics while users are navigating my Flask app in a real production environment. Is this possible? If so, can you provide an example of the config info that needs to be set?

    question 
    opened by havok2063 4
  • Securing the metrics

    Securing the metrics

    Can you tell me how to secure the metrics?

    What I mean is I dont want to keep the metrics urls like /flask-profiler/ open to anybody. How can I add a security system?

    auth 
    opened by WhiteHatArpit 4
  • search engine indexing must be not allowed

    search engine indexing must be not allowed

    a robot.txt file may be created to prevent search engines from indexing flask profiler's dashboard because it most probably has confidential information.

    auth 
    opened by muatik 4
  • Fix truncation of exception traceback

    Fix truncation of exception traceback

    Today we've realized that our API exception tracebacks are being truncated when we have flask-profiler turned on. After short research, we've discovered that the exception's stack trace is rewritten because of the way exception is re-rised.

    except Exception as e:
        raise e
    

    Instead of this approach, just blank raise can be used. It keeps the old traceback.

    opened by grechut 3
  • Show variables in endpoints on dashboard

    Show variables in endpoints on dashboard

    Example:

    • /pages/apples
    • /pages/oranges

    Instead of

    • /pages/<pageName>
    • /pages/<pageName>

    Could be helpful to measure traffic in dynamic routes

    opened by kesarsauce 0
  • docs: Fix a few typos

    docs: Fix a few typos

    There are small typos in:

    • CONTRIBUTING.md
    • examples/app.py
    • flask_profiler/storage/mongo.py

    Fixes:

    • Should read profiler rather than profider.
    • Should read conforms rather than comforms.
    • Should read differences rather than differencies.

    Semi-automated pull request generated by https://github.com/timgates42/meticulous/blob/master/docs/NOTE.md

    opened by timgates42 0
  • pymongo 4.x not support ensure_index

    pymongo 4.x not support ensure_index

    PyMongo 4.x aready remove ensure_index(), should use create_index() or create_indexes().

    https://pymongo.readthedocs.io/en/stable/migrate-to-pymongo4.html#id43

    opened by dingwf 0
Releases(v1.8)
Owner
Mustafa Atik
software engineer
Mustafa Atik
Neo4j Movies Example application with Flask backend using the neo4j-python-driver

Neo4j Movies Application: Quick Start This example application demonstrates how easy it is to get started with Neo4j in Python. It is a very simple we

Neo4j Examples 309 Dec 24, 2022
Force SSL on your Flask app.

Flask-SSLify This is a simple Flask extension that configures your Flask application to redirect all incoming requests to HTTPS. The extension is no l

Kenneth Reitz 26 Dec 07, 2022
Criando um Bot com PYAUTOGUI e utilizando o Flask para Interface para Usuário

Criando um Bot com PYAUTOGUI e utilizando o Flask para Interface para Usuário O pyautogui foi escolhido pela possibilidade de fazer a identificação do

Rodrigo Vital 2 Oct 20, 2021
Glauth management ui created with python/flask

glauth-ui Glauth-UI is a small flask web app i created to manage the minimal glauth ldap server. I created this as i wanted to use glauth for authenti

Nils Thiele 67 Nov 29, 2022
Flask 文档中文翻译

Flask 中文文档 这里是 Flask 文档中文翻译项目,欢迎参与! 在开始翻译之前,请务必阅读下面的 Contributing Guide 了解贡献流程,然后阅读这个 Issue 了解翻译要求,在这个 Discussion 投票选出你认为合适的翻译词汇,在这个 Discussion 投票选出你喜

Grey Li 93 Nov 28, 2022
Mixer -- Is a fixtures replacement. Supported Django, Flask, SqlAlchemy and custom python objects.

The Mixer is a helper to generate instances of Django or SQLAlchemy models. It's useful for testing and fixture replacement. Fast and convenient test-

Kirill Klenov 870 Jan 08, 2023
Analytics snippets generator extension for the Flask framework.

Flask-Analytics Flask Analytics is an extension for Flask which generates analytics snippets for inclusion in templates. Installation $ pip install Fl

Mihir 80 Nov 30, 2022
Full-Stack application that visualizes amusement park safety.

Amusement Park Ride Safety Analysis Project Proposal We have chosen to look into amusement park data to explore ride safety relationships visually, in

Michael Absher 0 Jul 11, 2021
PatientDB is a flask app to store patient information.

PatientDB PatientDB on Heroku "PatientDB is a simple web app that stores patient information, able to edit the information, and able to query the data

rbb 2 Jan 31, 2022
Making a simple app using React, Flask and MySQL.

Samys-Cookbook Making a simple app using React and Flask. What This will be a simple site to host my recipes. It will have a react front-end, a flask

Samridh Anand Paatni 1 Jul 07, 2022
docker-compose uWSGI nginx flask

docker-compose uWSGI nginx flask Note that this was tested on CentOS 7 Usage sudo yum install docker

Abdolkarim Saeedi 3 Sep 11, 2022
É uma API feita em Python e Flask que pesquisa informações em uma tabela .xlsx e retorna o resultado.

API de rastreamento de pacotes É uma API feita em Python e Flask que pesquisa informações de rastreamento de pacotes em uma tabela .xlsx e retorna o r

Marcos Beraldo Barros 4 Jun 27, 2021
Library books management program, built with Flask, Python

Library books management program, With many features and good User Interface. built with Flask, Python. (Include Screenshots) and documentation on how to run it! Thank you :)

Thierry Mugisha 1 May 03, 2022
A service made with Flask and Python to help you find the weather of your favorite cities.

Weather-App A service made with Flask and Python to help you find the weather of your favorite cities. Features Backend using Flask and Jinja Weather

Cauã Rinaldi 1 Nov 17, 2022
A solid foundation for your flask app

Flask Foundation There is a cookiecutter version of this repo at https://github.com/JackStouffer/cookiecutter-Flask-Foundation. Documentation is locat

Jack Stouffer 1.3k Dec 11, 2022
Brandnew-flask is a CLI tool used to generate a powerful and mordern flask-app that supports the production environment.

Brandnew-flask is still in the initial stage and needs to be updated and improved continuously. Everyone is welcome to maintain and improve this CLI.

brandonye 4 Jul 17, 2022
Rich implementation for Flask

Flask Rich Implements the Rich programming library with Flask. All features are toggleable, including: Better logging Colorful tracebacks Usage Import

BD103 13 Jun 06, 2022
HTTP security headers for Flask

Talisman: HTTP security headers for Flask Talisman is a small Flask extension that handles setting HTTP headers that can help protect against a few co

Google Cloud Platform 853 Dec 19, 2022
Alexa Skills Kit for Python

Program the Amazon Echo with Python Flask-Ask is a Flask extension that makes building Alexa skills for the Amazon Echo easier and much more fun. Flas

John Wheeler 1.9k Dec 30, 2022
The Coodesh Python Backend Challenge (2021) written in Flask

Coodesh Back-end Challenge 🏅 2021 ID: 917 The Python Back-end Coodesh Challenge Description This API automatically retrieves users from the RandomUse

Marcus Vinicius Pereira 1 Oct 20, 2021