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.
Files changed (72) hide show
  1. flask_artisan/__init__.py +36 -0
  2. flask_artisan/application.py +120 -0
  3. flask_artisan/auth/__init__.py +18 -0
  4. flask_artisan/auth/authenticatable.py +50 -0
  5. flask_artisan/auth/manager.py +173 -0
  6. flask_artisan/auth/middleware.py +35 -0
  7. flask_artisan/auth/provider.py +16 -0
  8. flask_artisan/auth/tokens.py +66 -0
  9. flask_artisan/cli.py +32 -0
  10. flask_artisan/config.py +68 -0
  11. flask_artisan/console.py +233 -0
  12. flask_artisan/container.py +153 -0
  13. flask_artisan/database/__init__.py +29 -0
  14. flask_artisan/database/alembic_env/env.py +21 -0
  15. flask_artisan/database/alembic_env/script.py.mako +28 -0
  16. flask_artisan/database/connection.py +39 -0
  17. flask_artisan/database/json.py +13 -0
  18. flask_artisan/database/manager.py +109 -0
  19. flask_artisan/database/migrations.py +109 -0
  20. flask_artisan/database/model.py +354 -0
  21. flask_artisan/database/provider.py +23 -0
  22. flask_artisan/database/query.py +166 -0
  23. flask_artisan/database/relations.py +95 -0
  24. flask_artisan/env.py +35 -0
  25. flask_artisan/facades.py +38 -0
  26. flask_artisan/helpers.py +18 -0
  27. flask_artisan/middleware.py +39 -0
  28. flask_artisan/providers.py +19 -0
  29. flask_artisan/route_provider.py +27 -0
  30. flask_artisan/routing.py +277 -0
  31. flask_artisan/skeleton/.env.example +16 -0
  32. flask_artisan/skeleton/.gitignore +5 -0
  33. flask_artisan/skeleton/app/__init__.py +0 -0
  34. flask_artisan/skeleton/app/console/__init__.py +0 -0
  35. flask_artisan/skeleton/app/console/commands/__init__.py +0 -0
  36. flask_artisan/skeleton/app/http/__init__.py +0 -0
  37. flask_artisan/skeleton/app/http/controllers/__init__.py +0 -0
  38. flask_artisan/skeleton/app/http/controllers/auth_controller.py +21 -0
  39. flask_artisan/skeleton/app/http/controllers/home_controller.py +6 -0
  40. flask_artisan/skeleton/app/http/kernel.py +18 -0
  41. flask_artisan/skeleton/app/http/middleware/__init__.py +0 -0
  42. flask_artisan/skeleton/app/models/__init__.py +0 -0
  43. flask_artisan/skeleton/app/models/user.py +14 -0
  44. flask_artisan/skeleton/app/providers/__init__.py +0 -0
  45. flask_artisan/skeleton/app/providers/app_service_provider.py +11 -0
  46. flask_artisan/skeleton/app/providers/route_service_provider.py +7 -0
  47. flask_artisan/skeleton/bootstrap/__init__.py +0 -0
  48. flask_artisan/skeleton/bootstrap/app.py +5 -0
  49. flask_artisan/skeleton/config/app.py +20 -0
  50. flask_artisan/skeleton/config/auth.py +13 -0
  51. flask_artisan/skeleton/config/database.py +40 -0
  52. flask_artisan/skeleton/config/flask.py +6 -0
  53. flask_artisan/skeleton/database/.gitignore +2 -0
  54. flask_artisan/skeleton/database/migrations/.gitkeep +0 -0
  55. flask_artisan/skeleton/pytest.ini +3 -0
  56. flask_artisan/skeleton/requirements.txt +2 -0
  57. flask_artisan/skeleton/routes/api.py +19 -0
  58. flask_artisan/skeleton/routes/web.py +5 -0
  59. flask_artisan/skeleton/tests/test_app.py +5 -0
  60. flask_artisan/skeleton/wsgi.py +1 -0
  61. flask_artisan/stubs/command.stub +7 -0
  62. flask_artisan/stubs/controller.resource.stub +23 -0
  63. flask_artisan/stubs/controller.stub +3 -0
  64. flask_artisan/stubs/middleware.stub +9 -0
  65. flask_artisan/stubs/model.stub +8 -0
  66. flask_artisan/stubs/provider.stub +11 -0
  67. flask_artisan-0.1.0.dist-info/METADATA +385 -0
  68. flask_artisan-0.1.0.dist-info/RECORD +72 -0
  69. flask_artisan-0.1.0.dist-info/WHEEL +5 -0
  70. flask_artisan-0.1.0.dist-info/entry_points.txt +2 -0
  71. flask_artisan-0.1.0.dist-info/licenses/LICENSE +21 -0
  72. 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")
@@ -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