Imia
Imia (belarussian for "a name") is an authentication library for Starlette and FastAPI (python 3.8+).
Production status
The library is considered in "beta" state thus may contain bugs or security issues, but I actively use it in production.
Installation
Install imia using PIP or poetry:
pip install imia
# or
poetry add imia
Features
- Login/logout flows
- Pluggable authenticators:
- WWW-Basic
- session
- token
- bearer token
- any token (customizable)
- API key
- Database agnostic user storage
- Authentication middleware
- with fallback strategies:
- redirect to an URL
- raise an exception
- do nothing
- with optional URL protection
- with option URL exclusion from protection
- with fallback strategies:
- User Impersonation (stateless and stateful)
- SQLAlchemy 1.4 (async mode) integration
TODO
- remember me
A very quick start
If you are too lazy to read this doc, take a look into examples/ directory. There you will find several files demoing various parts of this library.
How it works?
Here are all moving parts:
- UserLike object, aka "user model" - is an arbitrary class that implements
imia.UserLikeprotocol. - a user provider - an adapter that loads user model (UserLike object) from the storage (a database).
- an authenticator - a class that loads user using the user provider from the request (eg. session)
- an authentication middleware that accepts an HTTP request and calls authenticators for a user model. The middleware always populates
request.authwithUserToken. - user token is a class that holds authentication state
When a HTTP request reaches your application, an imia.AuthenticationMiddleware will start handling it. The middleware iterates over configured authenticators and stops on the first one that returns non-None value. At this point the request is considered authenticated. If no authenticators return user model then the middleware will create anonymous user token. The user token available in request.auth property. Use user_token.is_authenticated token property to make sure that user is authenticated.
User authentication quick start
- Create a user model and implement methods defined by
imia.UserLikeprotocol. - Create an instance of
imia.UserProviderthat corresponds to your user storage. Feel free to create your own. - Setup one or more authenticators and pass them to the middleware
- Add
imia.AuthenticationMiddlewareto your Starlette application
At this point you are done.
Here is a brief example that uses in-memory provider for demo purpose. For production environment you should use database backed providers like SQLAlchemyORMUserProvider or SQLAlchemyCoreUserProvider. Also, for simplicity reason we will not implement login/logout flow and will authenticate requests using API keys.
from dataclasses import dataclass, field
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.routing import Route
from imia import APIKeyAuthenticator, AuthenticationMiddleware, InMemoryProvider
@dataclass
class User:
"""This is our user model. It may be an ORM model, or any python class, the library does not care of it,
it only expects that the class has methods defined by the UserLike protocol."""
id: str
password: str = 'password'
scopes: list[str] = field(default_factory=list)
def get_display_name(self) -> str:
return self.id.split('@')[0].title()
def get_id(self) -> str:
return self.id
def get_hashed_password(self) -> str:
return self.password
def get_scopes(self) -> list:
return self.scopes
async def whoami_view(request: Request) -> JSONResponse:
return JSONResponse({
'id': request.auth.user_id,
'name': request.auth.display_name,
})
user_provider = InMemoryProvider({
'[email protected]': User(id='[email protected]'),
'[email protected]': User(id='[email protected]'),
})
authenticators = [
APIKeyAuthenticator(user_provider=user_provider),
]
routes = [
Route('/', whoami_view),
]
middleware = [
Middleware(AuthenticationMiddleware, authenticators=authenticators)
]
app = Starlette(routes=routes, middleware=middleware)
Now save the file to myapp.py and run it with uvicorn application server:
uvicorn myapp:app
Open http://127.0.0.1:8000/ and see that your request is not authenticated and user is anonymous. Let's pass API key via query parameters to make the configured APIKeyAuthenticator to load user. This time open http://127.0.0.1:8000/[email protected] in your browser. Now the request is fully authenticated as User1 user.
For more details refer to the doc sections below.
Docs
- UserLike protocol (a user model)
- Load user from databases using User Providers
- Request authentication
- Built-in authenticators
- User token
- Passwords
- Login/Logout flow
- User impersontation
Usage
See examples/ directory.
962 Feb 19, 2021
1 Dec 10, 2021
95 Nov 28, 2022
2.4k Jan 3, 2023
1.1k Jan 5, 2023
4 Jan 29, 2022
2 Jul 3, 2020
1 Jan 24, 2022
42 Dec 06, 2022
2.2k Jan 01, 2023
1 Jan 02, 2022
384 Nov 23, 2022
347 Dec 18, 2022
154 Jan 03, 2023
12 May 22, 2022
4 Nov 29, 2022
1.1k Jan 03, 2023
76 Jan 02, 2023
5 Oct 26, 2022
6 Aug 18, 2022
31 Dec 11, 2022
4 Oct 28, 2021
5 Oct 19, 2021
229 Jan 05, 2023
3 May 16, 2022
417 Jan 07, 2023
23 Sep 11, 2022