
Security News
OpenGrep Restores Fingerprinting in JSON and SARIF Outputs
OpenGrep has restored fingerprint and metavariable support in JSON and SARIF outputs, making static analysis more effective for CI/CD security automation.
harlequelrah-fastapi
Advanced tools
Package personnalisé pour faciliter le développement avec python avec fastapi
Description
Passioné par la programmation et le développement avec python je me lance dans la création progressive d'une bibliothèque personnalisée ou framework pour m'ameliorer , devenir plus productif et partager mon expertise avec FASTAPI
Installation
Avec Github :
git clone https://github.com/Harlequelrah/Library-harlequelrah_fastapi
Avec pip :
pip install harlequelrah_fastapi
Utilisation
Ce package contient plusieurs modules utiles pour accélérer et modulariser le dévéloppement avec FASTAPI. Voici un aperçu de leurs fonctionnalités.
Commandes
Cette commande permet de générer un projet FASTAPI avec une archictecture définie
harlequelrah_fastapi startproject nomduprojet
architecture
:
nomduprojet/
├── __init__.py
├── .gitignore
├── alembic/
├── alembic.ini
├── requirements.txt
├── env/
├── __main__.py
├── nomduprojet/
│ ├── __init__.py
│ ├── main.py
│ ├── settings/
│ ├── .gitignore
│ ├── __init__.py
│ ├── database.py
│ ├── secret.py
│ └── models_metadata.py
Cette commande permet de créer une application dans le projet
harlequelrah_fastapi startapp nomappli
architecture
:
sqlapp/
├── __init__.py
├── cruds.py
├── models.py
├── router.py
├── schemas.py
├── utils.py
Cette commande permet de créer une application utilisateur
harlequelrah_fastapi generate userapp
architecture
:
userapp/
├── __init__.py
├── user_cruds.py
├── user_models.py
├── user_router_providers.py
├── user_routers.py
├── user_schemas.py
Cette commande permet de créer une application de log
architecture
:
loggerapp/
├── __init__.py
├── log_user.py
├── log_model.py
├── log_crud.py
├── log_router.py
├── log_schema.py
Modules
exception
Ce module contient des exceptions personnalisées utilisés dans cette bibliothèque
auth_exception
ce sous module dispose de quelques variables d'exceptions prédéfinies liés à l'authentification
INVALID_CREDENTIALS_CUSTOM_HTTP_EXCEPTION
: exception personnalisée de paramètres d'authentification invalides .
INACTIVE_USER_CUSTOM_HTTP_EXCEPTION
: exception personnalisée de compte utilisateur inactive .
INSUFICIENT_PERMISSIONS_CUSTOM_HTTP_EXCEPTION
: exception personnalisée lorsqu'un utilisateur n'a pas les permissions suffisantes pour acceder à une ressource .
exceptions_utils
ce sous module contient des fonction utilitaires pour les exceptions
raise_custom_http_exception
: lève une erreur CustomHttpException
paramètres :
status_code
: int
detail
: str
CustomHttpException
: génère une exception personnalisé qui definit une exception de type HTTPExeption.utility
Ce module contient des utilitaires .
utils
Ce sous module contient des quelques fonctions utiles .
update_entity
: mets à jour les champs d'une entité objet .
paramètres :
existing_entity : l'entité existante à mettre à jour.
update_entity : l'entité pour mettre : l'entité pour la mise à jour .
sortie : existing_entity
validate_value_type
: permet valider une valeur pour s'assurer qu'il est conforme à son type
paramètres :
sortie : value
utilisation :
myvalue= validate_value_type("True") # retourne True
create_database_if_not_exists : créer la base de donnée si elle n'existe pas .
paramètres :
database_url : str [l'url de la base de donnée dans le nom de la base de donnée] .
database_name : str [le nom de la base de donnée]
authentication
Ce module contient des classes et des fonctions utilisées pour l'authentification.
token
Ce sous module définit des classes pydantics pour la gestions des tokens :
AccessToken :
access_token : str
token_type : str
RefreshToken :
refresh_token : str
token_type : str
Token :
access_token : str
refresh_token : str
token_type : str
authenticate
ce sous module définit les classes et fonctions utilisées pour l'authentification
Classe Authentication
: classe principale pour gérer l'authentification
Attributs
TOKEN_URL
: définit l'url du schéma d'authentication
OAUTH2_SCHEME
: définit le schéma d'authentication
User
: le modèle d'utilisateur SQLAlchemy
UserCreateModel
: le modèle pydantic pour la création d'utilisateur
UserUpdateModel
: le modèle pydantic pour la mise à jour d'utilisateur
UserPydanticModel
: le modèle pydantic pour lire un utilisateur
UserLoginRequestModel
: le modèle pydantic la connexion d'utilisateur
__secret_key
: str [une clé secrète générer par défaut]
ALGORITHMS
: List[str] [un tableau d'algorithm [par défaut [HS256
]]
__algorithm
: str [un élément de ALGORITHMS]
REFRESH_TOKEN_EXPIRE_DAYS
: int
ACCESS_TOKEN_EXPIRE_MINUTES
: int
__session_factory
: sessionmaker[Session]
methodes
__init__
:
paramètres :
database_username : str
database_password : str
connector : str
database_name : str
server : str
set_oauth2_scheme
: modifie le schéma d'authentification
paramètres :
get_session
: retourne une session
Session
is_authorized
: verifie si un utilisateur a un privilège
paramètres :
user_id : int
privilege_id : int
sortie : bool
authenticate_user
: authentifie un utilisateur
paramètres :
password : str
username_or_email : str
session : Optional[Session]
sortie : User
create_access_token
: créer un token d'acces
paramètres :
data : dict
expires_delta : timedelta
sortie : AccessToken
create_refresh_token
: créer un token de rafraichissement
paramètres :
data : dict
expires_delta : timedelta
sortie : RefreshToken
get_access_token
: retourne le token d'accès de l'utilisateur actuellement authentifié .
get_current_user
: retourne l'utilisateur actuellement authentifié .
validate_token
: valide le token et retourne un payload
paramètres :
sortie : dict[str,any]
refresh_token
: rafraichi un token d'acces par un token de rafraichissement
paramètres :
sortie : AccessToken
check_authorization
: vérifie des authorizations suivant des roles ou privilèges en retournant un objet callable qui sera utilisé comme dépendence
paramètres :
privilege_name: Optional[List[str]]
roles_name : Optional[List[str]]
sortie : callable
get_user_by_sub
: retourne un utilisateur à partir de son username ou email
paramètres :
username_or_email : str
db : Session
sortie : User
authorization
Ce module contient des classes et des fonctions utilisées pour l'autorisation.
meta_model
Ce sous module contient des models Meta pour définir les models liés à l'authorization et pour lire partiellement des données .
MetaAuthorization
: classe pour définir les models SQLAlchemy Role et Privilege
id : Column(Integer)
name : Column(String)
normalizedName : Column(String) [automatique à l'ajout de name]
description : Column(String)
MetaAuthorizationBaseModel
: classe pour définir les Models Meta pour Role et Privilege .
id : int
normalizedName : str
is_active : bool
MetaAuthorizationPydanticModel(MetaAuthorizationModel)
; classe pour définir les Models Pydantic complet pour Role et Privilege.
name : str
role_model
Ce sous module contient les models SQLAlchemy et classes pydantic pour l'entité Role .
RoleModel(MetaAuthorization)
RoleBaseModel
:
RoleCreateModel(RoleBaseModel)
:
description : str
privileges : Optional[List[PrivilegeCreateModel]]
RoleUpdateModel
name : Optional[str]
description : Optional[str]
is_active : Optional[bool]
RolePydanticModel(MetaAuthorizationPydanticModel)
:
privilege_model
Ce sous module contient les models SQLAlchemy et classes pydantic pour l'entité Privilege .
PrivilegeModel(MetaAuthorization)
PrivilegeBaseModel
PrivilegeCreateModel
:
PrivilegeUpdateModel
:
name : Optional[str]
description : Optional[str]
is_active : Optional[bool]
PrivilegePydanticModel(MetaAuthorizationPydanticModel)
:
roles : Optional[List[MetaAuthorizationBaseModel]]
privilege_users : Optional[List[MetaPrivilegeUsers]]
role_privilege_model
Ce sous module contient les models SQLAlchemy et classes pydantic pour l'entité RolePrivilege .
RolePrivilegeModel
id : Column(Integer)
role_id : Column(Integer)
privilege_id : Column(Integer)
RolePrivilegeCreateModel
role_id : int
privilege : int
RolePrivilegeUpdateModel
role_id : Optional[int]
privilege : Optional[int]
RolePrivilegePydanticModel(RolePrivilegeCreateModel)
middleware
Ce module regroupe toute la gestion des middelwares
models
Ce sous module définit les modèles de Log : LoggerMiddlewareModel
et LoggerMiddlewarePydanticModel
pour la validation Pydantic
LoggerMiddlewareModel
:
Attributs prédéfinis:
id : Column(Integer)
status_code :Column(Integer)
method : Column(String)
url : Column(String)
error_message : Column(Text)
date_created : Column(DateTime)
process_time : Column(Numeric)
remote_adress: Column(String)
LoggerMiddlewarePydanticModel
:
Attributs prédéfinis:
id : int
status_code : int
method : str
url : str
error_message : str
date_created : datetime
process_time : float
remote_adress: str
log_middleware
Ce sous module définit les middelwares de loggins
Class LoggerMiddleware
paramètres :
LoggerMiddlewareModel : définit le modèle de Log
session_factory : sessionmaker[Session]
manager : ConnectionManager
error_middleware
Ce sous module définit les middelwares d'erreurs
Class ErrorMiddleware
paramètres :
LoggerMiddlewareModel : définit le modèle de Log
session_factory : sessionmaker[Session]
manager : ConnectionManager
ce sous module définit les methodes pour sauvegarder les logs .
save_log
: enregistre les logs
paramètres:
request : Request
LoggerMiddelewareModel
db : Session
call_next: Optional
error : Optional[str]
response : Optional[Response]
manager: Optional[ConnectionManager]
paramètres: Response
get_response_and_process_time
: renvoie le temps de la requete et la reponse .
paramètres:
request: Request
call_next:callable
response : Response
call_next: Optional
paramètres: [ response , process_time ]
read_response_body
: renvoie une chaine de caractère contenant la partie du detail du body si elle existe du corps de la requête
paramètres:
paramètres: str
recreate_async_iterator
: recree un nouvel itérateur pour la requete
paramètres
:
user
Ce module comporte toute la gestion des utilisateurs
models
Ce sous module comporte tous les models pour l'entité utilisateur .
class User
Attributs
:
id : Column(Integer)
email : Column(String)
username : Column(String)
password : Column(String)
lastname : Column(String)
date_created : Column(DateTime)
date_updated : Column(DateTime)
is_active : Column(Boolean)
attempt_login : Column(Integer)
role_id : Column(Integer)
MAX_ATTEMPT_LOGIN = 3
PasswordHasher
Methodes
:
try_login
:
tente de connecter un utilisateur et mets à jour attempt_login en fonction .
paramètres :
sortie : bool
set_password
: permet de modifier le mot de passe .
paramètres :
sortie : None
check_password
: permet de vérifier le mot de passe.
paramètres :
sortie : bool
has_role
: permet de vérifier si l'utilisateur a un role
paramètres :
sortie : bool
has_privilege
: permet de vérifier si l'utilisateur a un privilege
paramètres :
sortie : bool
UserPrivilegeModel
id : Column(Integer)
user_id : Column(Integer)
privilege_id : Column(Integer)
is_active : Column(Integer)
Models pydantics pour la validations
:
UserBaseModel
email : str
username : str
lastname : str
firstname : str
UserCreateModel(UserBaseModel)
password : str
role_id : Optional[int]
UserUpdateModel
email: Optional[str]
username: Optional[str]
lastname: Optional[str]
firstname: Optional[str]
is_active: Optional[bool]
password: Optional[str]
role_id : Optional[int]
UserPydanticModel(UserBaseModel)
id : int
date_created : datetime
date_updated : Optional[datetime]
is_active : bool
attempt_login : int
role : Optional[MetaAuthorizationBaseModel]
user_privileges : Optional[List[MetaUserPrivilegeModel]]
UserPrivilegeCreateModel
:
user_id : int
privilege_id : int
is_active : bool
UserPrivilegeUpdateModel
:
user_id : Optional[int]
privilege_id : Optional[int]
is_active : Optional[bool]
UserPrivilegePydanticModel
:
id : int
user_id : int
privilege_id : int
is_active : bool
MetaUserPrivilegeModel
:
privilege_id : int
is_active : bool
UserRequestModel
:
username : Optional[str]
email : Optional[str]
username_or_email : @property str|None
UserLoginRequestModel(UserRequestModel)
:
UserChangePasswordRequestModel(UserRequestModel)
:
current_password : str
new_password : str
websocket
Ce module comporte certaines classes et methodes pour interagir avec des websockets
connectionManager
Contient la classe ConnectionManager pour gérer une connextion avec un websocket .
methodes:
connect : permet de connecter un websocket au manager
paramètres:
disconnect : permet de déconnecter un websocket
paramètres:
send_message : permet d'envoyer un message
paramètres:
crud
Ce module comporte des classes methodes et autres utilitaires pour automatiser la création des cruds.
crud_forgery
Ce sous module comporte la classe CrudForgery pour générer des cruds de base .
CrudForgery
:
__init__
:
paramètres :
entity_name
: str
authentication
: Authentication
SQLAlchemyModel
: Le model SQLAlchemy
CreatePydanticModel
: Le model Pydantic pour la création . Optional
UpdatePydanticModel
: Le model Pydantic pour la mise à jour . Optional
Linked_Classes
: List[LinkClass]
create
:
paramètres :
create_ob
: CreatePydanticModelsortie : SQLAlchemyModel
count
:
read_all
:
paramètres :
skip
: Optional[int]
limit
: Optional[int]
sortie : List[SQLAlchemyModel]
read_all_by_filter
:
paramètres :
filter
: str
value
: str
skip
: Optional[int]
limit
: Optional[int]
sortie : List[SQLAlchemyModel]
read_one
:
paramètres :
id
: int
db
: Optional[Session] : pour utiliser la même session lors de update et delete .
sortie : SQLAlchemyModel
update
:
paramètres :
id
: int
update_obj
: UpdatePydanticModel
sortie : SQLAlchemyModel
delete
:
paramètres :
id
: intsortie : Reponse avec status code 204
user_crud_forgery
Ce sous module définit une classe UserCrudForgery hérité de CrudForgery pour offire un crud personnalisé pour l'utilisateur .
Méthodes :
__init__
paramètres :
change_password
: méthode pour changer le mot de passe d'un utilisateur
paramètres :
username_or_email : str
current_password : str
new_passowrd : str
sortie : Reponse avec status code 204
is_unique
: méthode pour vérifier si l'email ou le username est unique .
paramètres :
sortie : bool
read_one
: méthode lire un utilisateur à partir de son id , son email ou de son username .
paramètres :
sortie : bool
Sous module link_class
Ce sous module définit une classe LinkClass pour définir un attribut et un model à lié pour la creation d'une entité
LinkClass
__init__
:
paramètres :
key : str
Model : type
manage_linked_classes
: retourne un dictionnaire en créant les objets liés et en les ajoutant au modèle principal.
paramètres :
Linked_Classes : List[LinkClass]
dict_obj : dict
sortie : dict
router
Ce module comporte des classes methodes et autres utilitaires pour automatiser la création des router.
route_config
Ce sous module comporte la classe RouteConfig
pour configurer un CustomRouterProvider et une classe utilitaire DEFAULT_ROUTE_CONFIG
.
DEFAULT_ROUTE_CONFIG
__init__
:
paramètres
summary : str
description : str
RouteConfig
__init__
:
paramètres:
route_name
: str
route_path
: Optional[str]
summary
: Optional[str]
description
: Optional[str]
is_activated
: bool , default : False
is_protected
: bool , default : False
is_unlocked
: Optional[bool] , default : False
roles : Optional[List[str]]
privileges : Optional[List[str]]
get_authorization
: retourne une liste de callable utilisable comme dépendance pour l'authorization
paramètres :
sortie : List[callable]
route_namespace
Ce sous module comporte des Constantes et classes réutilisables dans le contexte du routage .
class TypeRoute
: (str,Enum) , définit les types de routes
DEFAULT_ROUTES_CONFIGS
: dict[DefaultRoutesName,DEFAULT,ROUTE_CONFIG] , contient une configuration de base pour définir les routes par défaut .
ROUTES_PUBLIC_CONFIG
: List[RouteConfig] ,contient une liste de RouteConfig pour les routes par défaut publics ou non protégés .
ROUTES_PROTECTED_CONFIG
: List[RouteConfig] , contient une liste de RouteConfig pour les routes par défaut protégés .
USER_AUTH_CONFIG
: dict[DefaultRoutesName,RouteConfig] , contient un dictionnaire de nom de route et de RouteConfig pour les routes par défaut liés à l'authentification d'un utilisateur .
USER_AUTH_CONFIG_ROUTES
: List[RouteConfig] , contient toutes les RouteConfig définit par
router_default_routes_name
Ce sous module définit notament des classes contenant les définitions des noms des routes
DefaultRoutesName
: (str,Enum) , contient les définitions des noms des routes définies par le routage .
DEFAULT_DETAIL_ROUTES_NAME
: list , définit les routes de detail
route_provider
Ce sous module comporte la classe CustomRouterProvider pour configurer un CustomRouterProvider .
CustomRouterProvider
Attributs de classe
__init__
:
paramètres:
prefix
: str
tags
: List[str]
PydanticModel
: type , Model de reponse Pydantic
crud
: CrudForgery
roles
: Optional[List[str]]
privileges
: Optional[List[str]]
utilisation
:
router_provider = CustomRouterProvider(
prefix="/items",
tags=["item"],
PydanticModel=model.PydanticModel,
crud=myapp_crud,
)
get_public_router
: renvoie un router avec la configuration de ROUTES_PUBLIC_CONFIG
paramètres:
exclude_routes_name : Optional[List[DefaultRoutesName]]
get_protected_router
: renvoie un router avec la configuration de ROUTES_PROTECTED_AUTH_CONFIG
paramètres:
exclude_routes_name : Optional[List[DefaultRoutesName]]
get_mixed_router
: renvoie un router avec une configuration personnalisée entre routes publics et protégés .
paramètres:
init_data
: List[RouteConfig]public_routes_name : Optional[List[DefaultRoutesName]]
protected_routes_name : Optional[List[DefaultRoutesName]]
exclude_routes_name : Optional[List[DefaultRoutesName]]
initialize_router
: renvoie un router avec une configuration personnalisée .
paramètres:
init_data
: List[RouteConfig]exclude_routes_name : Optional[List[DefaultRoutesName]]
utilisation
:
init_data: List[RouteConfig] = [
RouteConfig(route_name="create", is_activated=True),
RouteConfig(route_name="read-one", is_activated=True),
RouteConfig(route_name="update", is_activated=True, is_protected=True),
RouteConfig(route_name="delete", is_activated=True, is_protected=True),
]
app_myapp = router_provider.initialize_router(init_data=init_data)
router_crud
Ce sous module comporte certaines fonctions utilisées dans le cadre du routage .
exclude_route
: permet d'exclure des routes d'une liste de routes
paramètres:
routes : List[RouteConfig]
exclude_routes_name : Optional[List[DefaultRoutesName]]
sortie : List[RouteConfig]
get_single_route
: permet d'avoir une configuration par défaut d'une route particulière .
paramètres:
route_name : DefaultRoutesName
type_route : Optional[TypeRoute]= TypeRoute.PROTECTED
exclude_routes_name : Optional[List[DefaultRoutesName]]
sortie : RouteConfig
initialize_dependencies
: permet d'initialiser les dépendances à passer à une route .
paramètres:
config : RouteConfig
authentication : Authentication
roles : Optional[List[str]]
privileges : Optional[List[str]]
sortie : List[Depends]
user_router_provider
ce sous module continent UserRouterProvider qui hérite de CustomRouterProvider , personnalisé pour l'utilisateur .
__init__
:
paramètres :
crud: UserCrudForgery
prefix : str
tags : List[str]
roles : List[str] = []
privileges : List[str] = []
Contact ou Support
Pour des questions ou du support, contactez-moi à maximeatsoudegbovi@gmail.com ou au (+228) 91 36 10 29.
FAQs
Package personnalisé pour faciliter le développement avec python avec fastapi
We found that harlequelrah-fastapi demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
OpenGrep has restored fingerprint and metavariable support in JSON and SARIF outputs, making static analysis more effective for CI/CD security automation.
Security News
Security experts warn that recent classification changes obscure the true scope of the NVD backlog as CVE volume hits all-time highs.
Security Fundamentals
Attackers use obfuscation to hide malware in open source packages. Learn how to spot these techniques across npm, PyPI, Maven, and more.