1. Runner

Ce script Python est un gestionnaire pour exécuter diverses applications et API qui peuvent être intégrées à ce système. Il fournit des fonctionnalités de journalisation, de chargement d’applications et d’API, de suivi d’état et un environnement d’exécution pour ces applications. Il utilise massivement le multithreading pour permettre potentiellement l’exécution simultanée et le suivi de plusieurs applications.

La classe Runner est divisée en plusieurs parties :

  1. Initialisation de la classe (__init__) : Initialise le Runner avec des attributs pour stocker les API et les applications, les indicateurs de débogage et de test, la configuration du logger, les événements de thread et le verrou pour le threading.

  2. Configuration du logger (__setup_logger) : Cette méthode configure le logger pour le Runner, y compris un gestionnaire de fichiers et un gestionnaire de flux (console) en utilisant le module logging.

  3. Chargement des applications (__load_applications) : Cette méthode est chargée de charger les instances de chaque application à partir des sous-classes de application.Application. Seules les sous-classes qui ne surchargent pas la méthode run mais qui surchargent la méthode job sont prises en compte. Leurs instances sont stockées et leur logger est configuré.

  4. Chargement des API (__load_apis) : Cette méthode est chargée de charger les instances de chaque API à partir des sous-classes de api.API, de les stocker et de configurer leur logger.

  5. Suivi d’état (__get_all_status et __status_thread) : Ces méthodes sont utilisées pour obtenir l’état de toutes les applications individuellement ou dans un thread séparé de suivi d’état. Le thread de suivi d’état enregistre l’état de toutes les applications après l’avoir obtenu et déterminé le type de message correspondant (erreur, avertissement, débogage).

  6. Détection de la surcharge de méthodes (is_method_overridden) : Cette méthode vérifie si une certaine méthode est surchargée dans les sous-classes d’une application donnée.

  7. Exécution du module principal (run) : Cette méthode charge les API, charge les applications, puis exécute toutes les applications une fois si le drapeau de débogage est activé ou les programme pour qu’elles s’exécutent à leurs fréquences.

  8. Arrêt (shutdown) : Cette méthode arrête le module principal.

L’implémentation utilise la bibliothèque externe schedule pour programmer des travaux (c’est-à-dire exécuter des instances d’application à intervalles réguliers).

Dans l’ensemble, ce script est un exemple assez complexe mais modulaire d’une application Python qui pourrait être utilisée pour exécuter et gérer plusieurs applications et API de manière robuste avec un soutien étendu à la journalisation et au suivi d’état.

This module contains the Runner class.

class runner.Runner(debug=False, test=False)

Bases : object

This class is the main class of the core module.

__get_status(app)

Get the status of an application.

Paramètres:

app – The application to get the status of.

Renvoie:

None

__load_apis()

This method loads the APIs by creating an instance of each API. The instances are stored in the _apis list attribute. It also sets the logs of each API.

Renvoie:

None

__load_applications()

This method loads the applications by creating an instance of each application. The instances are reset if there are existing applications. It also sets the log of each application.

Renvoie:

None

__setup_logger()

This method sets up the logger. It creates a file handler and a console handler. The file handler logs all messages with level WARNING.

Renvoie:

None

__status_thread(app)

This method is the thread that is run by the status method. It gets the status of all applications and prints it.

Paramètres:

app – The application object for which the status is to be retrieved.

Renvoie:

None

static is_method_overridden(app, method)

This method checks if the given method is overridden in any of the applications.

Paramètres:

  • app – The application to check.

  • method – The method to check.

Renvoie:

True if the app overrides the method, False otherwise.

logger = <Logger runner (DEBUG)>
run()

Runs the core module by calling the job method of each application. If the debug flag is set, the job method is called only once immediately. If the debug flag is not set, the job method is scheduled to run at the frequency of the application.

Renvoie:

None

shutdown()

This method shuts down the core module.

Renvoie:

None

2. API

Ce script Python définit un module qui simplifie l’interaction avec une API.

Le script comprend les principales sections suivantes :

  1. Une fonction décoratrice type_check() pour vérifier le type des arguments transmis à une fonction. Si les types des arguments ne correspondent pas aux types attendus, une TypeError est levée.

  2. La classe API, qui sert d’interface à une API. Elle offre les fonctionnalités suivantes :

    • Stocker l’URL de base, le jeton, et les ressources liées à une instance de l’API.

    • Créer dynamiquement des méthodes pour les demandes GET, POST, PUT et DELETE en fonction des métadonnées de la ressource.

    • Valider les métadonnées de la ressource (c’est-à-dire, le nom de la ressource, le verbe HTTP, la méthode, et les paramètres) en utilisant un schéma JSON défini avec le module jsonschema. Une erreur sera consignée si les métadonnées ne correspondent pas au schéma.

  3. La classe RequestResponse est utilisée pour stocker la réponse à une requête API. Elle inclut le code de statut de la requête et les données qui ont été renvoyées par celle-ci.

Voici une explication rapide des composants :

  • type_check : Il s’agit d’une fonction décoratrice qui effectue une vérification de type sur chaque argument transmis à une fonction. La fonction décoratrice peut être appliquée à n’importe quelle fonction pour imposer des contraintes de type sur les arguments.

  • API : C’est une classe de base abstraite qui représente une API générique. Elle met en œuvre la logique d’envoi de requêtes HTTP à une API et de traitement des réponses. Au sein de cette classe, les méthodes sont créées de manière dynamique pour les points de terminaison GET, POST, PUT et DELETE en fonction des métadonnées des ressources.

  • set_method : C’est une méthode de la classe API. Elle détermine l’opération appropriée de l’API (verbe HTTP, comme GET, POST, PUT, DELETE) pour chaque ressource définie et décore la méthode avec le décorateur type_check, qui impose la vérification du type sur les arguments de la méthode.

  • RequestResponse : Cette classe est utilisée pour stocker et accéder à la réponse d’une requête API. Elle comprend le code de statut HTTP et toutes les données renvoyées par la requête.

This module contains the API interface.

class api.API(url=None, test_url=None, token=None, test=False, ressources=None)

Bases : ABC

This class is the main class of the core module.

Paramètres:

  • url (str) – The main url for the API.

  • test_url (str) – The test url for the API.

  • token (str) – The token used for authentication.

  • test (bool, optional) – Optional flag to indicate whether to use the test url or the main url. Defaults to False.

  • ressources – The dictionary of resources and their corresponding methods and parameters.Ressources must

follow the following schema:
{
« ressource_name »: {

« verb »: « GET » | « POST » | « PUT » | « DELETE », « method »: method_name, « params »: [str, int, float, list, dict, bool, None]

}

}

_abc_impl = <_abc_data object>
static get_parameters(resource)

Get the parameters for the specified resource.

Paramètres:

resource – A dictionary representing the resource for which the parameters need to be retrieved.

Renvoie:

A list of parameters for the specified resource.

instances = []
process_resource(resource, resource_value)

Process a resource.

Paramètres:

  • resource – The resource name.

  • resource_value – The value of the resource.

Renvoie:

None.

process_sub_resource(super_resource_name, super_resource)

This method processes the sub-resource by iterating over the items of the super_resource dictionary. For each item, it retrieves the « method » value and performs error handling in case it is missing.

The method then calls the type_wrap method to wrap the resource value and obtains the parameters using the get_parameters method.

Finally, it sets the super_resource_name attribute of the type_wrap object to the method value. It also applies type checking using the type_check decorator to the method attribute.

Paramètres:

  • super_resource_name – The name of the sub-resource being processed.

  • super_resource – A dictionary containing the super resource and its values.

Renvoie:

None

set_method()

Process the resources and sub-resources.

Renvoie:

None

type_wrap(ressource) → type

Wrapper method for HTTP methods based on the verb associated with the given resource.

Paramètres:

ressource (dict) – The resource for which the HTTP method is being wrapped.

Renvoie:

The wrapped HTTP method.

Lève:

ValueError – If the verb associated with the resource is invalid.

class api.RequestResponse(status_code, data)

Bases : object

This class is used to store the response from an API request.

Paramètres:

  • status_code (int) – The status code of the response.

  • data (dict) – The data in the response.

property data

This is the data property.

property status_code

This is the status code property.

api.type_check(*type_args, **type_kwargs) → callable

Decorator that checks the types of the arguments passed to a function.

Paramètres:

  • type_args – Positional arguments represent the types of the function arguments.

  • type_kwargs – Keyword arguments representing the types of the function keyword arguments.

Renvoie:

Decorator function that performs the type checking.

3. Application

Définit une classe de base abstraite (ABC) pour représenter une Application exécutable et une énumération Status pour suivre l’état actuel d’une Application.

  • L’énumération Status contient les différents statuts qu’une application peut avoir, tels que RUNNING, WAITING, ERROR, et SUCCESS.

  • La classe Application est une classe de base abstraite (ne peut pas être instanciée directement). Elle fournit un modèle pour créer d’autres classes qui sont considérées comme des Applications, ce qui signifie qu’elles doivent implémenter les méthodes spécifiées dans cette classe abstraite. Cette classe met en place la journalisation et initialise diverses propriétés telles que les APIs, la fréquence d’exécution, et le statut.

  • La méthode api() récupère une instance API à partir de la liste privée _apis en fonction de son nom de classe.

  • La méthode run() est utilisée pour exécuter l’application. Elle définit le statut comme RUNNING et essaie ensuite d’appeler la méthode abstraite job(). Si une exception se produit pendant ce processus, elle enregistre l’erreur et définit le statut comme ERROR. Si le mode de débogage est activé, elle relève à nouveau l’exception.

  • La méthode shutdown() est un espace réservé qui peut être remplacé par des implémentations de sous-classe si l’Application a besoin de libérer des ressources ou d’effectuer des actions de nettoyage lorsqu’elle est arrêtée. Si elle n’est pas remplacée, elle ne fait rien.

  • Ce script utilise également les bibliothèques schedule et logging pour la planification des tâches et la création de journaux d’application, respectivement.

This module contains the Application Interface of the core module. All applications must implement this interface if they want to be run by the runner.

class application.Application

Bases : ABC

Application Interface of the core module. All applications must implement this interface if they want to be run by the runner.

An application can use one or more APIs to work. The APIs are stored in a list. The frequency of the application is stored in a schedule.Job.

The job method is the method that is called by the runner. It must be implemented by the application. This method must contain all the work of the application.

Variables:

  • _apis – The list of APIs used by the application.

  • frequency – The frequency of the application.

See:

api.API

See:

schedule.Job

_abc_impl = <_abc_data object>
_apis: List[API]
api(name)

This method returns the API with the given name.

Paramètres:

name – The name of the API.

Renvoie:

The API object corresponding to the given name.

Lève:

ValueError – If the API with the given name does not exist.

property debug: bool

This property returns the debug mode of the application.

Renvoie:

The debug mode of the application as a boolean value.

frequency: Job
property health_check

This property returns the health check of the application.

Renvoie:

The health check of the application

Type renvoyé:

bool

Raises:

None

abstract job() → Status

The runner calls this method. It must contain all the work of the application. It must update the status of the application (RUNNING, ERROR, SUCCESS).

Renvoie:

None

run()

The runner calls this method. It loads the APIs, sets the frequency and schedules the job.

This method must not be overridden. :return: None

set_status(value: Status)

This method sets the status of the application.

Paramètres:

value – The status value to be set.

Must be of type Status. :return: None

shutdown()

The runner calls this method when the application is stopped. It must stop all the work of the application.

Renvoie:

None

property status: Status

This property returns the status of the application.

Renvoie:

The status of the application.

Type renvoyé:

Status.

class application.Status(value)

Bases : Enum

This class is an enum for the status of an application.

ERROR = 3
NEVER = 0
RUNNING = 1
SUCCESS = 4
WAITING = 2