reapxdev/pypi-scraper huggingface dataset:
Flask-JWT-Extended 4.7.4 — Extended JWT integration with Flask
Author: Lily Acadia Gilbert
License: MIT 
Keywords: flask, jwt, json web token
Requires Python: <4,>=3.10
Dependencies: Werkzeug>=0.14, Flask<4.0,>=2.0, PyJWT<3.0,>=2.11.0, cryptography>=3.3.1; extra == "asymmetric-crypto"

# Flask-JWT-Extended

### Features

Flask-JWT-Extended not only adds support for using JSON Web Tokens (JWT) to Flask for protecting routes,
but also many helpful (and **optional**) features built in to make working with JSON Web Tokens
easier. These include:

-   Adding custom claims to JSON Web Tokens
-   Automatic user loading (`current_user`).
-   Custom claims validation on received tokens
-   [Refresh tokens](https://auth0.com/blog/refresh-tokens-what-are-they-and-when-to-use-them/)
-   First class support for fresh tokens for making sensitive changes.
-   Token revoking/blocklisting
-   Storing tokens in cookies and CSRF protection

### Usage

[View the documentation online](https://flask-jwt-extended.readthedocs.io/en/stable/)

### Upgrading from 3.x.x to 4.0.0

[View the changes](https://flask-jwt-extended.readthedocs.io/en/stable/v4_upgrade_guide/)

### Changelog

You can view the changelog [here](https://github.com/vimalloc/flask-jwt-extended/releases).
This project follows [semantic versioning](https://semver.org/).

### Chatting

Come chat with the community or ask questions at https://discord.gg/EJBsbFd

### Contributing

Before making any changes, make sure to install the development requirements
and setup the git hooks which will automatically lint and format your changes.

```bash
pip install -r requirements.txt
pre-commit install
```

We require 100% code coverage in our unit tests. You can run the tests locally
with `tox` which ensures that all tests pass, tests provide complete code coverage,
documentation builds, and style guide are adhered to

```bash
tox
```

A subset of checks can also be ran by adding an argument to tox. The available
arguments are:

-   py37, py38, py39, py310, py311, py312, pypy3
    -   Run unit tests on the given python version
-   mypy
    -   Run mypy type checking
-   coverage
    -   Run a code coverage check
-   docs
    -   Ensure documentation builds and there are no broken links
-   style
    -   Ensure style gui
Flask-Login 0.6.3 — User authentication and session management for Flask.
Author: Matthew Frazier
License: MIT 
Requires Python: >=3.7
Dependencies: Flask >=1.0.4, Werkzeug >=1.0.1

# Flask-Login

![Tests](https://github.com/maxcountryman/flask-login/workflows/Tests/badge.svg)
[![coverage](https://coveralls.io/repos/maxcountryman/flask-login/badge.svg?branch=main&service=github)](https://coveralls.io/github/maxcountryman/flask-login?branch=main)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)

Flask-Login provides user session management for Flask. It handles the common
tasks of logging in, logging out, and remembering your users' sessions over
extended periods of time.

Flask-Login is not bound to any particular database system or permissions
model. The only requirement is that your user objects implement a few methods,
and that you provide a callback to the extension capable of loading users from
their ID.

## Installation

Install the extension with pip:

```sh
$ pip install flask-login
```

## Usage

Once installed, the Flask-Login is easy to use. Let's walk through setting up
a basic application. Also please note that this is a very basic guide: we will
be taking shortcuts here that you should never take in a real application.

To begin we'll set up a Flask app:

```python
import flask

app = flask.Flask(__name__)
app.secret_key = 'super secret string'  # Change this!
```

Flask-Login works via a login manager. To kick things off, we'll set up the
login manager by instantiating it and telling it about our Flask app:

```python
import flask_login

login_manager = flask_login.LoginManager()

login_manager.init_app(app)
```

To keep things simple we're going to use a dictionary to represent a database
of users. In a real application, this would be an actual persistence layer.
However it's important to point out this is a feature of Flask-Login: it
doesn't care how your data is stored so long as you tell it how to retrieve it!

```python
# Our mock database.
users = {'foo@bar.tld': {'password': 'secret'}}
```

We also need to tell Flask-Login how to load a user from a Flask request and
from its session.