flask-artisan 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- flask_artisan/__init__.py +36 -0
- flask_artisan/application.py +120 -0
- flask_artisan/auth/__init__.py +18 -0
- flask_artisan/auth/authenticatable.py +50 -0
- flask_artisan/auth/manager.py +173 -0
- flask_artisan/auth/middleware.py +35 -0
- flask_artisan/auth/provider.py +16 -0
- flask_artisan/auth/tokens.py +66 -0
- flask_artisan/cli.py +32 -0
- flask_artisan/config.py +68 -0
- flask_artisan/console.py +233 -0
- flask_artisan/container.py +153 -0
- flask_artisan/database/__init__.py +29 -0
- flask_artisan/database/alembic_env/env.py +21 -0
- flask_artisan/database/alembic_env/script.py.mako +28 -0
- flask_artisan/database/connection.py +39 -0
- flask_artisan/database/json.py +13 -0
- flask_artisan/database/manager.py +109 -0
- flask_artisan/database/migrations.py +109 -0
- flask_artisan/database/model.py +354 -0
- flask_artisan/database/provider.py +23 -0
- flask_artisan/database/query.py +166 -0
- flask_artisan/database/relations.py +95 -0
- flask_artisan/env.py +35 -0
- flask_artisan/facades.py +38 -0
- flask_artisan/helpers.py +18 -0
- flask_artisan/middleware.py +39 -0
- flask_artisan/providers.py +19 -0
- flask_artisan/route_provider.py +27 -0
- flask_artisan/routing.py +277 -0
- flask_artisan/skeleton/.env.example +16 -0
- flask_artisan/skeleton/.gitignore +5 -0
- flask_artisan/skeleton/app/__init__.py +0 -0
- flask_artisan/skeleton/app/console/__init__.py +0 -0
- flask_artisan/skeleton/app/console/commands/__init__.py +0 -0
- flask_artisan/skeleton/app/http/__init__.py +0 -0
- flask_artisan/skeleton/app/http/controllers/__init__.py +0 -0
- flask_artisan/skeleton/app/http/controllers/auth_controller.py +21 -0
- flask_artisan/skeleton/app/http/controllers/home_controller.py +6 -0
- flask_artisan/skeleton/app/http/kernel.py +18 -0
- flask_artisan/skeleton/app/http/middleware/__init__.py +0 -0
- flask_artisan/skeleton/app/models/__init__.py +0 -0
- flask_artisan/skeleton/app/models/user.py +14 -0
- flask_artisan/skeleton/app/providers/__init__.py +0 -0
- flask_artisan/skeleton/app/providers/app_service_provider.py +11 -0
- flask_artisan/skeleton/app/providers/route_service_provider.py +7 -0
- flask_artisan/skeleton/bootstrap/__init__.py +0 -0
- flask_artisan/skeleton/bootstrap/app.py +5 -0
- flask_artisan/skeleton/config/app.py +20 -0
- flask_artisan/skeleton/config/auth.py +13 -0
- flask_artisan/skeleton/config/database.py +40 -0
- flask_artisan/skeleton/config/flask.py +6 -0
- flask_artisan/skeleton/database/.gitignore +2 -0
- flask_artisan/skeleton/database/migrations/.gitkeep +0 -0
- flask_artisan/skeleton/pytest.ini +3 -0
- flask_artisan/skeleton/requirements.txt +2 -0
- flask_artisan/skeleton/routes/api.py +19 -0
- flask_artisan/skeleton/routes/web.py +5 -0
- flask_artisan/skeleton/tests/test_app.py +5 -0
- flask_artisan/skeleton/wsgi.py +1 -0
- flask_artisan/stubs/command.stub +7 -0
- flask_artisan/stubs/controller.resource.stub +23 -0
- flask_artisan/stubs/controller.stub +3 -0
- flask_artisan/stubs/middleware.stub +9 -0
- flask_artisan/stubs/model.stub +8 -0
- flask_artisan/stubs/provider.stub +11 -0
- flask_artisan-0.1.0.dist-info/METADATA +385 -0
- flask_artisan-0.1.0.dist-info/RECORD +72 -0
- flask_artisan-0.1.0.dist-info/WHEEL +5 -0
- flask_artisan-0.1.0.dist-info/entry_points.txt +2 -0
- flask_artisan-0.1.0.dist-info/licenses/LICENSE +21 -0
- flask_artisan-0.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
from flask_artisan.env import env # noqa: I001 — env en premier : config/*.py l'importe
|
|
2
|
+
from flask_artisan.application import Application
|
|
3
|
+
from flask_artisan.config import Repository
|
|
4
|
+
from flask_artisan.container import BindingResolutionError, Container
|
|
5
|
+
from flask_artisan.facades import DB, App, Auth, Config, Facade, Route
|
|
6
|
+
from flask_artisan.helpers import app, base_path, config
|
|
7
|
+
from flask_artisan.middleware import HttpKernel, Middleware
|
|
8
|
+
from flask_artisan.providers import ServiceProvider
|
|
9
|
+
from flask_artisan.route_provider import RouteServiceProvider
|
|
10
|
+
from flask_artisan.routing import RouteError, Router
|
|
11
|
+
|
|
12
|
+
__version__ = "0.1.0"
|
|
13
|
+
|
|
14
|
+
__all__ = [
|
|
15
|
+
"DB",
|
|
16
|
+
"App",
|
|
17
|
+
"Application",
|
|
18
|
+
"Auth",
|
|
19
|
+
"BindingResolutionError",
|
|
20
|
+
"Config",
|
|
21
|
+
"Container",
|
|
22
|
+
"Facade",
|
|
23
|
+
"HttpKernel",
|
|
24
|
+
"Middleware",
|
|
25
|
+
"Repository",
|
|
26
|
+
"Route",
|
|
27
|
+
"RouteError",
|
|
28
|
+
"RouteServiceProvider",
|
|
29
|
+
"Router",
|
|
30
|
+
"ServiceProvider",
|
|
31
|
+
"__version__",
|
|
32
|
+
"app",
|
|
33
|
+
"base_path",
|
|
34
|
+
"config",
|
|
35
|
+
"env",
|
|
36
|
+
]
|
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from pathlib import Path
|
|
4
|
+
|
|
5
|
+
from flask import Flask, current_app, has_app_context
|
|
6
|
+
|
|
7
|
+
from flask_artisan.config import Repository
|
|
8
|
+
from flask_artisan.console import COMMANDS, ArtisanGroup
|
|
9
|
+
from flask_artisan.container import Container
|
|
10
|
+
from flask_artisan.env import load_env_file
|
|
11
|
+
from flask_artisan.providers import ServiceProvider
|
|
12
|
+
from flask_artisan.routing import Router
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class Application(Flask, Container):
|
|
16
|
+
"""Une application Flask qui est aussi le conteneur de services."""
|
|
17
|
+
|
|
18
|
+
_current: Application | None = None
|
|
19
|
+
|
|
20
|
+
def __init__(self, base_path: str | Path):
|
|
21
|
+
base = Path(base_path).resolve()
|
|
22
|
+
Container.__init__(self)
|
|
23
|
+
Flask.__init__(
|
|
24
|
+
self,
|
|
25
|
+
import_name=base.name,
|
|
26
|
+
root_path=str(base),
|
|
27
|
+
instance_path=str(base / "instance"),
|
|
28
|
+
)
|
|
29
|
+
self._base_path = base
|
|
30
|
+
self._providers: dict[type, ServiceProvider] = {}
|
|
31
|
+
self._booted = False
|
|
32
|
+
|
|
33
|
+
load_env_file(base / ".env")
|
|
34
|
+
repository = Repository.from_directory(base / "config")
|
|
35
|
+
self._bridge_flask_config(repository)
|
|
36
|
+
|
|
37
|
+
self.instance("app", self)
|
|
38
|
+
self.instance(Application, self)
|
|
39
|
+
self.instance("config", repository)
|
|
40
|
+
self.instance(Repository, repository)
|
|
41
|
+
router = Router(self)
|
|
42
|
+
self.instance("router", router)
|
|
43
|
+
self.instance(Router, router)
|
|
44
|
+
Application.set_instance(self)
|
|
45
|
+
|
|
46
|
+
self.cli = ArtisanGroup(self.name, app=self)
|
|
47
|
+
for command in COMMANDS:
|
|
48
|
+
self.cli.add_command(command)
|
|
49
|
+
|
|
50
|
+
# Dans son propre contexte : façades et helpers visent cette app, même si une autre
|
|
51
|
+
# app a un contexte actif (fixtures de tests).
|
|
52
|
+
with self.app_context():
|
|
53
|
+
for provider in repository.get("app.providers", []):
|
|
54
|
+
self.register(provider)
|
|
55
|
+
self.boot()
|
|
56
|
+
|
|
57
|
+
def _bridge_flask_config(self, repository: Repository) -> None:
|
|
58
|
+
key = repository.get("app.key")
|
|
59
|
+
if not key:
|
|
60
|
+
raise RuntimeError(
|
|
61
|
+
"APP_KEY manquant dans .env : ajoutez une clé secrète "
|
|
62
|
+
'(ex. python -c "import secrets; print(secrets.token_hex(32))").'
|
|
63
|
+
)
|
|
64
|
+
self.config["SECRET_KEY"] = key
|
|
65
|
+
self.config["DEBUG"] = _flag(repository.get("app.debug", False))
|
|
66
|
+
self.config.update(repository.get("flask", {}))
|
|
67
|
+
|
|
68
|
+
def register(self, provider_class: type[ServiceProvider]) -> ServiceProvider:
|
|
69
|
+
if provider_class in self._providers:
|
|
70
|
+
return self._providers[provider_class]
|
|
71
|
+
provider = provider_class(self)
|
|
72
|
+
provider.register()
|
|
73
|
+
self._providers[provider_class] = provider
|
|
74
|
+
if self._booted:
|
|
75
|
+
with self.app_context(), self.make(Router).collecting():
|
|
76
|
+
provider.boot()
|
|
77
|
+
return provider
|
|
78
|
+
|
|
79
|
+
def boot(self) -> None:
|
|
80
|
+
if self._booted:
|
|
81
|
+
return
|
|
82
|
+
self._booted = True
|
|
83
|
+
# Les routes déclarées pendant les boot() sont poussées dans Flask à la fin.
|
|
84
|
+
with self.make(Router).collecting():
|
|
85
|
+
for provider in list(self._providers.values()):
|
|
86
|
+
provider.boot()
|
|
87
|
+
|
|
88
|
+
def base_path(self, path: str = "") -> Path:
|
|
89
|
+
return self._base_path / path
|
|
90
|
+
|
|
91
|
+
def config_path(self, path: str = "") -> Path:
|
|
92
|
+
return self._base_path / "config" / path
|
|
93
|
+
|
|
94
|
+
def app_path(self, path: str = "") -> Path:
|
|
95
|
+
return self._base_path / "app" / path
|
|
96
|
+
|
|
97
|
+
def environment(self) -> str:
|
|
98
|
+
return self.make("config").get("app.env", "production")
|
|
99
|
+
|
|
100
|
+
@classmethod
|
|
101
|
+
def get_instance(cls) -> Application:
|
|
102
|
+
# Pendant une requête, l'app courante gagne (plusieurs apps dans un même processus).
|
|
103
|
+
if has_app_context():
|
|
104
|
+
current = current_app._get_current_object()
|
|
105
|
+
if isinstance(current, Application):
|
|
106
|
+
return current
|
|
107
|
+
if Application._current is None:
|
|
108
|
+
raise RuntimeError("Aucune application flask-artisan n'a été créée.")
|
|
109
|
+
return Application._current
|
|
110
|
+
|
|
111
|
+
@classmethod
|
|
112
|
+
def set_instance(cls, app: Application | None) -> None:
|
|
113
|
+
Application._current = app
|
|
114
|
+
|
|
115
|
+
|
|
116
|
+
def _flag(value) -> bool:
|
|
117
|
+
"""Même lecture que Flask pour FLASK_DEBUG : "0", "false", "no" et "" valent False."""
|
|
118
|
+
if isinstance(value, str):
|
|
119
|
+
return value.strip().lower() not in ("0", "false", "no", "")
|
|
120
|
+
return bool(value)
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
from flask_artisan.auth.authenticatable import Authenticatable, AuthenticationError, HasApiTokens
|
|
2
|
+
from flask_artisan.auth.manager import AuthManager, SessionGuard, TokenGuard
|
|
3
|
+
from flask_artisan.auth.middleware import Authenticate
|
|
4
|
+
from flask_artisan.auth.provider import AuthServiceProvider
|
|
5
|
+
from flask_artisan.auth.tokens import PersonalAccessToken, find_token
|
|
6
|
+
|
|
7
|
+
__all__ = [
|
|
8
|
+
"AuthManager",
|
|
9
|
+
"AuthServiceProvider",
|
|
10
|
+
"Authenticatable",
|
|
11
|
+
"Authenticate",
|
|
12
|
+
"AuthenticationError",
|
|
13
|
+
"HasApiTokens",
|
|
14
|
+
"PersonalAccessToken",
|
|
15
|
+
"SessionGuard",
|
|
16
|
+
"TokenGuard",
|
|
17
|
+
"find_token",
|
|
18
|
+
]
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
import re
|
|
2
|
+
|
|
3
|
+
from sqlalchemy import delete
|
|
4
|
+
from sqlalchemy.orm import validates
|
|
5
|
+
from werkzeug.security import check_password_hash, generate_password_hash
|
|
6
|
+
|
|
7
|
+
from flask_artisan.auth.tokens import PersonalAccessToken, issue_token
|
|
8
|
+
from flask_artisan.database.model import _db
|
|
9
|
+
|
|
10
|
+
# Hash Werkzeug complet (méthode$sel$hex) : une valeur déjà hachée n'est pas re-hachée.
|
|
11
|
+
WERKZEUG_HASH = re.compile(r"(scrypt|pbkdf2):[^$]+\$[^$]+\$[0-9a-f]+")
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class AuthenticationError(Exception):
|
|
15
|
+
pass
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class Authenticatable:
|
|
19
|
+
"""Mixin d'utilisateur : `password` est haché à chaque affectation (pas à la relecture)."""
|
|
20
|
+
|
|
21
|
+
@validates("password")
|
|
22
|
+
def _hash_password(self, key, value):
|
|
23
|
+
if value is None or WERKZEUG_HASH.fullmatch(value):
|
|
24
|
+
return value
|
|
25
|
+
return generate_password_hash(value)
|
|
26
|
+
|
|
27
|
+
def check_password(self, plain: str) -> bool:
|
|
28
|
+
return self.password is not None and check_password_hash(self.password, plain)
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
class HasApiTokens:
|
|
32
|
+
"""Mixin d'utilisateur : tokens d'API stockés en base (`personal_access_tokens`)."""
|
|
33
|
+
|
|
34
|
+
def create_token(self, name: str) -> str:
|
|
35
|
+
"""Renvoie le token en clair `"<id>|<secret>"` : c'est la seule fois où il est visible."""
|
|
36
|
+
return issue_token(self.id, name)
|
|
37
|
+
|
|
38
|
+
def _hard_delete(self) -> None:
|
|
39
|
+
# Sinon, sous SQLite, un nouvel utilisateur qui reprend cet id hériterait des tokens.
|
|
40
|
+
_db().session.execute(
|
|
41
|
+
delete(PersonalAccessToken).where(PersonalAccessToken.user_id == self.id)
|
|
42
|
+
)
|
|
43
|
+
super()._hard_delete()
|
|
44
|
+
|
|
45
|
+
def tokens(self):
|
|
46
|
+
return PersonalAccessToken.where("user_id", self.id)
|
|
47
|
+
|
|
48
|
+
def current_access_token(self):
|
|
49
|
+
"""Le token qui a authentifié la requête courante (guard token), sinon None."""
|
|
50
|
+
return getattr(self, "_access_token", None)
|
|
@@ -0,0 +1,173 @@
|
|
|
1
|
+
import hashlib
|
|
2
|
+
import hmac
|
|
3
|
+
from functools import cache
|
|
4
|
+
|
|
5
|
+
from flask import has_request_context, request, session
|
|
6
|
+
from werkzeug.security import check_password_hash, generate_password_hash
|
|
7
|
+
|
|
8
|
+
from flask_artisan.auth.authenticatable import AuthenticationError
|
|
9
|
+
from flask_artisan.auth.tokens import find_token
|
|
10
|
+
|
|
11
|
+
SESSION_KEY = "_auth_user_id"
|
|
12
|
+
# Empreinte du hash du mot de passe : changer le mot de passe (ou réutiliser l'id) coupe la session.
|
|
13
|
+
SESSION_HASH_KEY = "_auth_password_hash"
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
@cache
|
|
17
|
+
def _dummy_hash() -> str:
|
|
18
|
+
return generate_password_hash("dummy-password")
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def _state() -> dict:
|
|
22
|
+
"""État d'auth de la requête (pas de `g`, partagé si un app context englobe plusieurs requêtes)."""
|
|
23
|
+
return request.environ.setdefault("flask_artisan.auth", {})
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def _fingerprint(user) -> str:
|
|
27
|
+
return hashlib.sha256((user.password or "").encode()).hexdigest()
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
class Guard:
|
|
31
|
+
"""Résout l'utilisateur de la requête courante ; le résultat est gardé dans `g`."""
|
|
32
|
+
|
|
33
|
+
def __init__(self, name: str, model: type):
|
|
34
|
+
self.name = name
|
|
35
|
+
self.model = model
|
|
36
|
+
|
|
37
|
+
def user(self):
|
|
38
|
+
if not has_request_context():
|
|
39
|
+
return None
|
|
40
|
+
state = _state()
|
|
41
|
+
key = f"user:{self.name}"
|
|
42
|
+
if key not in state:
|
|
43
|
+
state[key] = self._resolve()
|
|
44
|
+
return state[key]
|
|
45
|
+
|
|
46
|
+
def _remember(self, user) -> None:
|
|
47
|
+
_state()[f"user:{self.name}"] = user
|
|
48
|
+
|
|
49
|
+
def id(self):
|
|
50
|
+
user = self.user()
|
|
51
|
+
return None if user is None else user.id
|
|
52
|
+
|
|
53
|
+
def check(self) -> bool:
|
|
54
|
+
return self.user() is not None
|
|
55
|
+
|
|
56
|
+
def guest(self) -> bool:
|
|
57
|
+
return not self.check()
|
|
58
|
+
|
|
59
|
+
def validate(self, **credentials):
|
|
60
|
+
"""L'utilisateur si les identifiants sont bons, sinon None ; ne connecte personne."""
|
|
61
|
+
password = credentials.pop("password", None)
|
|
62
|
+
# Frontière de confiance (JSON du client) : que des chaînes. None deviendrait IS NULL.
|
|
63
|
+
if not credentials or not all(
|
|
64
|
+
isinstance(v, str) for v in (password, *credentials.values())
|
|
65
|
+
):
|
|
66
|
+
return None
|
|
67
|
+
query = self.model.query()
|
|
68
|
+
for key, value in credentials.items():
|
|
69
|
+
query = query.where(key, value)
|
|
70
|
+
user = query.first()
|
|
71
|
+
if user is None:
|
|
72
|
+
check_password_hash(_dummy_hash(), password) # même durée qu'un email connu
|
|
73
|
+
return None
|
|
74
|
+
return user if user.check_password(password) else None
|
|
75
|
+
|
|
76
|
+
def _resolve(self):
|
|
77
|
+
raise NotImplementedError
|
|
78
|
+
|
|
79
|
+
|
|
80
|
+
class SessionGuard(Guard):
|
|
81
|
+
def _resolve(self):
|
|
82
|
+
user_id = session.get(SESSION_KEY)
|
|
83
|
+
user = None if user_id is None else self.model.find(user_id)
|
|
84
|
+
expected = session.get(SESSION_HASH_KEY, "")
|
|
85
|
+
if user is None or not hmac.compare_digest(_fingerprint(user), expected):
|
|
86
|
+
return None
|
|
87
|
+
return user
|
|
88
|
+
|
|
89
|
+
def attempt(self, **credentials) -> bool:
|
|
90
|
+
user = self.validate(**credentials)
|
|
91
|
+
if user is not None:
|
|
92
|
+
self.login(user)
|
|
93
|
+
return user is not None
|
|
94
|
+
|
|
95
|
+
def login(self, user) -> None:
|
|
96
|
+
session.clear() # contre la fixation de session : un cookie Flask n'a pas d'id à régénérer
|
|
97
|
+
session[SESSION_KEY] = user.id
|
|
98
|
+
session[SESSION_HASH_KEY] = _fingerprint(user)
|
|
99
|
+
self._remember(user)
|
|
100
|
+
|
|
101
|
+
def logout(self) -> None:
|
|
102
|
+
session.clear()
|
|
103
|
+
self._remember(None)
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
class TokenGuard(Guard):
|
|
107
|
+
def _resolve(self):
|
|
108
|
+
scheme, _, plain = request.headers.get("Authorization", "").partition(" ")
|
|
109
|
+
if scheme.lower() != "bearer" or not plain.strip():
|
|
110
|
+
return None
|
|
111
|
+
token = find_token(plain.strip())
|
|
112
|
+
user = None if token is None else self.model.find(token.user_id)
|
|
113
|
+
if user is not None:
|
|
114
|
+
user._access_token = token
|
|
115
|
+
return user
|
|
116
|
+
|
|
117
|
+
def attempt(self, **credentials):
|
|
118
|
+
raise AuthenticationError(
|
|
119
|
+
f"Le guard '{self.name}' (token) est sans état : utilisez Auth.validate(...) "
|
|
120
|
+
"puis user.create_token(nom)."
|
|
121
|
+
)
|
|
122
|
+
|
|
123
|
+
def login(self, user):
|
|
124
|
+
self.attempt()
|
|
125
|
+
|
|
126
|
+
def logout(self):
|
|
127
|
+
raise AuthenticationError(
|
|
128
|
+
f"Le guard '{self.name}' (token) est sans état : révoquez le token avec "
|
|
129
|
+
"Auth.user().current_access_token().delete()."
|
|
130
|
+
)
|
|
131
|
+
|
|
132
|
+
|
|
133
|
+
DRIVERS = {"session": SessionGuard, "token": TokenGuard}
|
|
134
|
+
RELAYED = {"user", "id", "check", "guest", "validate", "attempt", "login", "logout"}
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
class AuthManager:
|
|
138
|
+
"""Service `"auth"` (façade Auth) : construit les guards de config/auth.py."""
|
|
139
|
+
|
|
140
|
+
def __init__(self, app):
|
|
141
|
+
self._app = app
|
|
142
|
+
|
|
143
|
+
def guard(self, name: str | None = None) -> Guard:
|
|
144
|
+
config = self._app.make("config")
|
|
145
|
+
if name is None and has_request_context():
|
|
146
|
+
name = _state().get("guard")
|
|
147
|
+
name = name or config.get("auth.defaults.guard")
|
|
148
|
+
guards = config.get("auth.guards", {})
|
|
149
|
+
if name not in guards:
|
|
150
|
+
raise AuthenticationError(
|
|
151
|
+
f"Guard '{name}' inconnu ; guards configurés : {', '.join(guards)}."
|
|
152
|
+
)
|
|
153
|
+
driver = guards[name].get("driver")
|
|
154
|
+
if driver not in DRIVERS:
|
|
155
|
+
raise AuthenticationError(
|
|
156
|
+
f"Driver '{driver}' inconnu pour le guard '{name}' : {', '.join(DRIVERS)}."
|
|
157
|
+
)
|
|
158
|
+
model = config.get("auth.model")
|
|
159
|
+
if model is None:
|
|
160
|
+
raise AuthenticationError(
|
|
161
|
+
"Déclarez le modèle utilisateur : 'model' dans config/auth.py."
|
|
162
|
+
)
|
|
163
|
+
return DRIVERS[driver](name, model)
|
|
164
|
+
|
|
165
|
+
def should_use(self, name: str) -> None:
|
|
166
|
+
"""Guard par défaut pour la requête courante (comme shouldUse de Laravel)."""
|
|
167
|
+
self.guard(name)
|
|
168
|
+
_state()["guard"] = name
|
|
169
|
+
|
|
170
|
+
def __getattr__(self, name: str):
|
|
171
|
+
if name in RELAYED:
|
|
172
|
+
return getattr(self.guard(), name)
|
|
173
|
+
raise AttributeError(name)
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
from flask import current_app, redirect, url_for
|
|
2
|
+
from werkzeug.routing import BuildError
|
|
3
|
+
|
|
4
|
+
from flask_artisan.auth.manager import AuthManager, TokenGuard
|
|
5
|
+
from flask_artisan.middleware import Middleware
|
|
6
|
+
|
|
7
|
+
UNAUTHENTICATED = ({"message": "Unauthenticated."}, 401)
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
def expects_json(request) -> bool:
|
|
11
|
+
# Type préféré seulement : un `*/*` (curl, navigateurs) ne réclame pas du JSON.
|
|
12
|
+
return request.is_json or "json" in (request.accept_mimetypes.best or "")
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class Authenticate(Middleware):
|
|
16
|
+
"""`auth`, `auth:api`, `auth:web,api` : laisse passer si un des guards trouve un utilisateur."""
|
|
17
|
+
|
|
18
|
+
def handle(self, request, next, *guards):
|
|
19
|
+
auth = current_app.make(AuthManager)
|
|
20
|
+
tried = []
|
|
21
|
+
for name in guards or (None,):
|
|
22
|
+
guard = auth.guard(name)
|
|
23
|
+
tried.append(guard)
|
|
24
|
+
if guard.user() is not None:
|
|
25
|
+
if name is not None:
|
|
26
|
+
auth.should_use(name)
|
|
27
|
+
return next(request)
|
|
28
|
+
# Que des guards token (auth:api) : un client d'API, jamais de page de login.
|
|
29
|
+
api_only = all(isinstance(g, TokenGuard) for g in tried)
|
|
30
|
+
if api_only or expects_json(request) or "login" not in current_app.view_functions:
|
|
31
|
+
return UNAUTHENTICATED
|
|
32
|
+
try:
|
|
33
|
+
return redirect(url_for("login"))
|
|
34
|
+
except BuildError: # route login qui attend des paramètres
|
|
35
|
+
return UNAUTHENTICATED
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
from flask_artisan.auth.authenticatable import AuthenticationError
|
|
2
|
+
from flask_artisan.auth.manager import AuthManager
|
|
3
|
+
from flask_artisan.providers import ServiceProvider
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
class AuthServiceProvider(ServiceProvider):
|
|
7
|
+
"""Enregistre l'authentification (`"auth"`, façade Auth)."""
|
|
8
|
+
|
|
9
|
+
def register(self):
|
|
10
|
+
if not self.app.make("config").has("auth"):
|
|
11
|
+
raise AuthenticationError(
|
|
12
|
+
"Configuration manquante : créez config/auth.py (guards et modèle utilisateur)."
|
|
13
|
+
)
|
|
14
|
+
manager = AuthManager(self.app)
|
|
15
|
+
self.app.instance("auth", manager)
|
|
16
|
+
self.app.instance(AuthManager, manager)
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
import hashlib
|
|
2
|
+
import hmac
|
|
3
|
+
import secrets
|
|
4
|
+
from datetime import datetime, timedelta, timezone
|
|
5
|
+
|
|
6
|
+
from sqlalchemy import String, update
|
|
7
|
+
|
|
8
|
+
from flask_artisan.database import Mapped, Model, column
|
|
9
|
+
from flask_artisan.database.model import _commit, _db
|
|
10
|
+
|
|
11
|
+
LAST_USED_THROTTLE = timedelta(minutes=1)
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class PersonalAccessToken(Model):
|
|
15
|
+
"""Token d'API façon Sanctum : seule l'empreinte SHA-256 du secret est stockée."""
|
|
16
|
+
|
|
17
|
+
# Pas de clé étrangère : la table des utilisateurs n'est pas figée par le framework.
|
|
18
|
+
user_id: Mapped[int] = column(index=True)
|
|
19
|
+
name: Mapped[str]
|
|
20
|
+
token: Mapped[str] = column(String(64), unique=True)
|
|
21
|
+
last_used_at: Mapped[datetime | None]
|
|
22
|
+
|
|
23
|
+
fillable = ("user_id", "name", "token")
|
|
24
|
+
hidden = ("token",)
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
def _digest(secret: str) -> str:
|
|
28
|
+
return hashlib.sha256(secret.encode()).hexdigest()
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def issue_token(user_id: int, name: str) -> str:
|
|
32
|
+
secret = secrets.token_urlsafe(40)
|
|
33
|
+
row = PersonalAccessToken.create(user_id=user_id, name=name, token=_digest(secret))
|
|
34
|
+
return f"{row.id}|{secret}"
|
|
35
|
+
|
|
36
|
+
|
|
37
|
+
def find_token(plain: str) -> PersonalAccessToken | None:
|
|
38
|
+
"""Le token correspondant à `"<id>|<secret>"`, sinon None.
|
|
39
|
+
|
|
40
|
+
Met à jour `last_used_at` au plus une fois par minute, et jamais si la session a des
|
|
41
|
+
changements en attente (on ne valide pas le travail du handler à sa place).
|
|
42
|
+
"""
|
|
43
|
+
token_id, _, secret = (plain or "").partition("|")
|
|
44
|
+
# isascii : "²".isdigit() est vrai ; 18 chiffres tiennent dans un BIGINT.
|
|
45
|
+
if not (token_id.isascii() and token_id.isdigit()) or len(token_id) > 18 or not secret:
|
|
46
|
+
return None
|
|
47
|
+
db = _db()
|
|
48
|
+
# Avant toute requête : une transaction ouverte ou des changements en attente
|
|
49
|
+
# appartiennent au handler, on ne les valide pas à sa place.
|
|
50
|
+
busy = db.session.in_transaction() or db.session.new or db.session.dirty or db.session.deleted
|
|
51
|
+
with db.session.no_autoflush:
|
|
52
|
+
row = PersonalAccessToken.find(int(token_id))
|
|
53
|
+
if row is None or not hmac.compare_digest(row.token, _digest(secret)):
|
|
54
|
+
return None
|
|
55
|
+
now = datetime.now(timezone.utc)
|
|
56
|
+
last = row.last_used_at
|
|
57
|
+
if last is not None and last.tzinfo is None:
|
|
58
|
+
last = last.replace(tzinfo=timezone.utc) # SQLite relit les dates sans fuseau
|
|
59
|
+
if busy or (last is not None and now - last < LAST_USED_THROTTLE):
|
|
60
|
+
return row
|
|
61
|
+
# UPDATE direct : save() toucherait updated_at.
|
|
62
|
+
db.session.execute(
|
|
63
|
+
update(PersonalAccessToken).where(PersonalAccessToken.id == row.id).values(last_used_at=now)
|
|
64
|
+
)
|
|
65
|
+
_commit(db)
|
|
66
|
+
return row
|
flask_artisan/cli.py
ADDED
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
import secrets
|
|
2
|
+
import shutil
|
|
3
|
+
from pathlib import Path
|
|
4
|
+
|
|
5
|
+
import click
|
|
6
|
+
|
|
7
|
+
# shortcut: suppose un package décompressé (toujours vrai pour un wheel) ; importlib.resources.as_file si zipimport un jour.
|
|
8
|
+
SKELETON = Path(__file__).parent / "skeleton"
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
@click.group()
|
|
12
|
+
def main():
|
|
13
|
+
"""Flask-Artisan : création de projets."""
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
@main.command()
|
|
17
|
+
@click.argument("name")
|
|
18
|
+
def new(name: str):
|
|
19
|
+
"""Crée un nouveau projet Flask-Artisan dans le dossier NAME."""
|
|
20
|
+
target = Path(name)
|
|
21
|
+
if target.exists() and any(target.iterdir()):
|
|
22
|
+
raise click.ClickException(f"Le dossier '{target}' existe et n'est pas vide.")
|
|
23
|
+
|
|
24
|
+
shutil.copytree(
|
|
25
|
+
SKELETON, target, dirs_exist_ok=True, ignore=shutil.ignore_patterns("__pycache__")
|
|
26
|
+
)
|
|
27
|
+
env = (target / ".env.example").read_text()
|
|
28
|
+
env = env.replace("APP_NAME=\n", f"APP_NAME={target.resolve().name}\n", 1)
|
|
29
|
+
env = env.replace("APP_KEY=\n", f"APP_KEY={secrets.token_hex(32)}\n", 1)
|
|
30
|
+
(target / ".env").write_text(env)
|
|
31
|
+
|
|
32
|
+
click.echo(f"Projet créé dans {target}.\n\n cd {name}\n flask run\n")
|
flask_artisan/config.py
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
import importlib.util
|
|
2
|
+
from pathlib import Path
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
_MISSING = object()
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
class ConfigError(Exception):
|
|
9
|
+
pass
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class Repository:
|
|
13
|
+
"""Configuration de l'application, accessible en notation pointée (`app.name`)."""
|
|
14
|
+
|
|
15
|
+
def __init__(self, items: dict | None = None):
|
|
16
|
+
self._items = items if items is not None else {}
|
|
17
|
+
|
|
18
|
+
def get(self, key: str, default: Any = None) -> Any:
|
|
19
|
+
node: Any = self._items
|
|
20
|
+
for part in key.split("."):
|
|
21
|
+
if not isinstance(node, dict) or part not in node:
|
|
22
|
+
return default
|
|
23
|
+
node = node[part]
|
|
24
|
+
return node
|
|
25
|
+
|
|
26
|
+
def has(self, key: str) -> bool:
|
|
27
|
+
return self.get(key, _MISSING) is not _MISSING
|
|
28
|
+
|
|
29
|
+
def set(self, key: str, value: Any) -> None:
|
|
30
|
+
*parents, last = key.split(".")
|
|
31
|
+
node = self._items
|
|
32
|
+
for part in parents:
|
|
33
|
+
if not isinstance(node.get(part), dict):
|
|
34
|
+
node[part] = {}
|
|
35
|
+
node = node[part]
|
|
36
|
+
node[last] = value
|
|
37
|
+
|
|
38
|
+
def all(self) -> dict:
|
|
39
|
+
return self._items
|
|
40
|
+
|
|
41
|
+
@classmethod
|
|
42
|
+
def from_directory(cls, path: Path) -> "Repository":
|
|
43
|
+
"""Charge chaque `config/<nom>.py` (dict `config`) sous la clé `<nom>`."""
|
|
44
|
+
path = Path(path)
|
|
45
|
+
items = {}
|
|
46
|
+
if path.is_dir():
|
|
47
|
+
for file in sorted(path.glob("*.py")):
|
|
48
|
+
if not file.name.startswith("_"):
|
|
49
|
+
items[file.stem] = _load_file(file)
|
|
50
|
+
return cls(items)
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
def _load_file(file: Path) -> dict:
|
|
54
|
+
# Chargé par chemin, jamais par nom de module : pas de conflit avec un autre package `config`.
|
|
55
|
+
spec = importlib.util.spec_from_file_location(f"flask_artisan_config_{file.stem}", file)
|
|
56
|
+
module = importlib.util.module_from_spec(spec)
|
|
57
|
+
try:
|
|
58
|
+
spec.loader.exec_module(module)
|
|
59
|
+
except Exception as exc:
|
|
60
|
+
raise ConfigError(
|
|
61
|
+
f"Impossible de charger le fichier de config {file.name} : {exc}"
|
|
62
|
+
) from exc
|
|
63
|
+
value = getattr(module, "config", None)
|
|
64
|
+
if not isinstance(value, dict):
|
|
65
|
+
raise ConfigError(
|
|
66
|
+
f"Le fichier de config {file.name} doit définir un dict `config = {{...}}`."
|
|
67
|
+
)
|
|
68
|
+
return value
|