Skip to content

28. Esercizio pratico: versione 10

28.1. Introduzione

Negli esempi di client per il server di calcolo delle imposte, i thread inviavano N richieste in sequenza se dovevano elaborare N contribuenti. L'idea qui è quella di inviare un'unica richiesta che incapsuli i N contribuenti. Per ciascuno di essi, devono essere inviate le informazioni [coniugato, figli, stipendio]. Queste possono essere inviate come parametri:

  • nell'URL. Ciò comporta un URL lungo e privo di significato;
  • nel corpo della richiesta HTTP. Sappiamo che questo corpo è nascosto all'utente che utilizza un browser;

In entrambi i casi, è possibile utilizzare una richiesta [GET] o [POST]. Useremo una richiesta POST con i parametri incorporati nel corpo della richiesta HTTP.

L'architettura client/server non è cambiata:

Image

28.2. Il server web

Image

La cartella [http-servers/05] viene inizialmente creata copiando la cartella [http-servers/02]. Torniamo agli scambi JSON tra il client e il server. Abbiamo visto che passare da JSON a XML è molto semplice.

28.2.1. Configurazione

La configurazione [config, config_database, config_layers] rimane la stessa delle versioni precedenti. Non la ripasseremo di nuovo.

28.2.2. Lo script principale [main]

Lo script [main] è identico a quello nella cartella [http-servers/02] che abbiamo copiato. C'è solo una differenza:

1
2
3
4
5
#  Home URL
@app.route('/', methods=['POST'])
@auth.login_required
def index():
    …
  • riga 2: l'URL / è ora accessibile tramite una richiesta POST;

28.2.3. Il [index_controller]

Il [index_controller] si evolve come segue:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#  import dependencies

import json

from flask_api import status
from werkzeug.local import LocalProxy


def execute(request: LocalProxy, config: dict) -> tuple:
    #  dependencies
    from ImpôtsError import ImpôtsError
    from TaxPayer import TaxPayer

    #  retrieve the body of the post - wait for a list of dictionaries
    msg_erreur = None
    list_dict_taxpayers = None
    #  the jSON body of POST
    request_text = request.data
    try:
        #  which we transform into a list of dictionaries
        list_dict_taxpayers = json.loads(request_text)
    except BaseException as erreur:
        #  we note the error
        msg_erreur = f"le corps du POST n'est pas une chaîne jSON valide : {erreur}"
    #  do we have a non-empty list?
    if not msg_erreur and (not isinstance(list_dict_taxpayers, list) or len(list_dict_taxpayers) == 0):
        #  we note the error
        msg_erreur = "le corps du POST n'est pas une liste ou alors cette liste est vide"
    #  do we have a list of dictionaries?
    if not msg_erreur:
        erreur = False
        i = 0
        while not erreur and i < len(list_dict_taxpayers):
            erreur = not isinstance(list_dict_taxpayers[i], dict)
            i += 1
        #  mistake?
        if erreur:
            msg_erreur = "le corps du POST doit être une liste de dictionnaires"
    #  mistake?
    if msg_erreur:
        #  an error response is sent to the client
        résultats = {"réponse": {"erreurs": [msg_erreur]}}
        return résultats, status.HTTP_400_BAD_REQUEST

    #  check TaxPayers one by one
    #  initially no errors
    list_erreurs = []
    for dict_taxpayer in list_dict_taxpayers:
        #  we create a TaxPayer from dict_taxpayer
        msg_erreur = None
        try:
            #  the following operation will eliminate cases where the parameters are not
            #  properties of the TaxPayer class as well as the cases where their values
            #  are incorrect
            TaxPayer().fromdict(dict_taxpayer)
        except BaseException as erreur:
            msg_erreur = f"{erreur}"
        #  certain keys must be present in the dictionary
        if not msg_erreur:
            #  the keys [married, children, salary] must be present in the dictionary
            keys = dict_taxpayer.keys()
            if 'marié' not in keys or 'enfants' not in keys or 'salaire' not in keys:
                msg_erreur = "le dictionnaire doit inclure les clés [marié, enfants, salaire]"
        #  mistakes?
        if msg_erreur:
            #  we note the error in the TaxPayer itself
            dict_taxpayer['erreur'] = msg_erreur
            #  add the TaxPayer to the error list
            list_erreurs.append(dict_taxpayer)

    #  we've processed all the taxpayers - are there any mistakes?
    if list_erreurs:
        #  an error response is sent to the client
        résultats = {"réponse": {"erreurs": list_erreurs}}
        return résultats, status.HTTP_400_BAD_REQUEST

    #  no mistakes, we can work
    #  data recovery from tax authorities
    admindata = config["admindata"]
    métier = config["layers"]["métier"]
    try:
        #  process the TaxPayer one by one
        list_taxpayers = []
        for dict_taxpayer in list_dict_taxpayers:
            #  tAX CALCULATION
            taxpayer = TaxPayer().fromdict(
                {'marié': dict_taxpayer['marié'], 'enfants': dict_taxpayer['enfants'],
                 'salaire': dict_taxpayer['salaire']})
            métier.calculate_tax(taxpayer, admindata)
            #  the result is stored as a dictionary
            list_taxpayers.append(taxpayer.asdict())
        #  we send the response to the client
        return {"réponse": {"results": list_taxpayers}}, status.HTTP_200_OK
    except ImpôtsError as erreur:
        #  an error response is sent to the client
        return {"réponse": {"erreurs": f"[{erreur}]"}}, status.HTTP_500_INTERNAL_SERVER_ERROR
  • Riga 9: Il controller riceve:
      • la richiesta del client;
      • la configurazione del server [config];
  • righe 14–18: Recuperiamo il corpo della richiesta POST. I parametri incapsulati nel corpo della richiesta HTTP possono essere codificati in vari modi. Ne abbiamo già incontrato uno: [x-www-form-urlencoded]. Qui useremo un'altra codifica: JSON;
  • riga 18: [request.data] recupera il corpo della richiesta HTTP. Qui recuperiamo del testo e sappiamo che questo testo è JSON che rappresenta un elenco di dizionari [married, children, salary];
  • righe 19–24: recuperiamo questo elenco di dizionari;
  • righe 22–24: se il recupero del JSON non è andato a buon fine, registriamo l'errore;
  • righe 26–28: se scopriamo che l'oggetto recuperato non è un elenco o è un elenco vuoto, registriamo l'errore;
  • righe 29–38: se un elenco è stato recuperato con successo, verifichiamo che si tratti effettivamente di un elenco di dizionari;
  • righe 40–43: se si è verificato un errore, ci fermiamo qui e inviamo una risposta di errore al client;
  • righe 45–69: ora controlliamo ciascuno dei dizionari:
    • devono contenere le chiavi [married, children, salary];
    • devono consentirci di creare un oggetto [TaxPayer] valido;
  • righe 65–69: se viene rilevato un errore in un dizionario, questo viene aggiunto allo stesso dizionario sotto la chiave ‘error’;
  • righe 72–75: i dizionari contenenti errori sono stati raccolti nella lista [list_errors]. Se questa lista non è vuota, viene inviata in una risposta di errore al client;
  • riga 77: a questo punto, sappiamo di poter creare un elenco di oggetti di tipo [TaxPayer] dal corpo della richiesta inviata dal cliente;
  • righe 84–91: elaboriamo l'elenco dei dizionari ricevuti;
  • riga 86: da un dizionario, creiamo un oggetto [TaxPayer];
  • riga 89: calcoliamo l'imposta per questo [TaxPayer];
  • riga 91: sappiamo che [taxpayer] è stato modificato dal calcolo dell'imposta. Lo convertiamo in un dizionario e lo aggiungiamo a un elenco di risultati;
  • riga 93: questo elenco di risultati viene inviato al client;

28.2.4. Test del server

Testeremo il server utilizzando un client Postman:

  • Avviamo il server web, il DBMS e il server di posta [hMailServer];
  • Avviamo il client Postman e la sua console (Ctrl-Alt-C);

Image

  • in [1]: inviamo una richiesta [POST];
  • in [2]: l'URL del server;
  • in [3]: il corpo della richiesta HTTP;
  • in [5]: specifichiamo che questo corpo deve essere inviato come stringa JSON;
  • in [4]: passiamo alla modalità [raw] per poter copiare e incollare una stringa JSON;
  • in [6]: incolliamo la stringa JSON presa da uno dei file [results.json] per le diverse versioni. Quindi, per ogni contribuente, conserviamo solo le proprietà [married, salary, children];

Image

  • in [7], esaminiamo le intestazioni HTTP che il client Postman invierà al server;
  • in [8], vediamo che invierà un'intestazione [Content-Type] che indica che la richiesta contiene un corpo codificato in JSON. Ciò è dovuto alla scelta effettuata in precedenza in [5];

Image

  • in [9-12]: includiamo nella richiesta le credenziali richieste dal server;

Inviamo questa richiesta. La risposta del server è la seguente:

Image

  • in [3], abbiamo ricevuto JSON;
  • in [4], l'imposta dei contribuenti;

Esaminiamo il dialogo client/server che ha avuto luogo nella console di Postman (Ctrl-Alt-C):

Il client Postman ha inviato il seguente testo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: 03c4aa28-5a5d-4bb5-ac51-7ad51968c71d
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 824

[
  {
    "marié": "oui",
    "enfants": 2,
    "salaire": 55555
  },
  {
    "marié": "oui",
    "enfants": 2,
    "salaire": 50000
  },
  {
    "marié": "oui",
    "enfants": 3,
    "salaire": 50000
  },
  {
    "marié": "non",
    "enfants": 2,
    "salaire": 100000
  },
  {
    "marié": "non",
    "enfants": 3,
    "salaire": 100000
  },
  {
    "marié": "oui",
    "enfants": 3,
    "salaire": 100000
  },
  {
    "marié": "oui",
    "enfants": 5,
    "salaire": 100000
  },
  {
    "marié": "non",
    "enfants": 0,
    "salaire": 100000
  },
  {
    "marié": "oui",
    "enfants": 2,
    "salaire": 30000
  },
  {
    "marié": "non",
    "enfants": 0,
    "salaire": 200000
  },
  {
    "marié": "oui",
    "enfants": 3,
    "salaire": 200000
  }
]
  • riga 1: la richiesta POST al server;
  • riga 2: l'intestazione di autenticazione HTTP;
  • riga 3: il client comunica al server che sta inviando una stringa JSON e che questa stringa è lunga 824 byte (riga 11);
  • righe 13–69: il corpo JSON della richiesta;

Il server ha risposto con il seguente testo:


HTTP/1.0 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 1461
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:16:34 GMT
 
{"réponse": {"results": [{"marié": "oui", "enfants": 2, "salaire": 55555, "impôt": 2814, "surcôte": 0, "taux": 0.14, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 2, "salaire": 50000, "impôt": 1384, "surcôte": 0, "taux": 0.14, "décôte": 384, "réduction": 347}, {"marié": "oui", "enfants": 3, "salaire": 50000, "impôt": 0, "surcôte": 0, "taux": 0.14, "décôte": 720, "réduction": 0}, {"marié": "non", "enfants": 2, "salaire": 100000, "impôt": 19884, "surcôte": 4480, "taux": 0.41, "décôte": 0, "réduction": 0}, {"marié": "non", "enfants": 3, "salaire": 100000, "impôt": 16782, "surcôte": 7176, "taux": 0.41, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 3, "salaire": 100000, "impôt": 9200, "surcôte": 2180, "taux": 0.3, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 5, "salaire": 100000, "impôt": 4230, "surcôte": 0, "taux": 0.14, "décôte": 0, "réduction": 0}, {"marié": "non", "enfants": 0, "salaire": 100000, "impôt": 22986, "surcôte": 0, "taux": 0.41, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 2, "salaire": 30000, "impôt": 0, "surcôte": 0, "taux": 0.0, "décôte": 0, "réduction": 0}, {"marié": "non", "enfants": 0, "salaire": 200000, "impôt": 64210, "surcôte": 7498, "taux": 0.45, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 3, "salaire": 200000, "impôt": 42842, "surcôte": 17283, "taux": 0.41, "décôte": 0, "réduction": 0}]}}
  • riga 1: la richiesta è andata a buon fine;
  • riga 2: il corpo della risposta del server è una stringa JSON. È lunga 1461 byte (riga 3);
  • riga 7: la risposta JSON del server;

Ora proviamo alcuni casi di errore.

Caso 1: inviamo qualsiasi cosa


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: 47652706-9744-46a0-a682-de010e5406c0
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 3
 
abc
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 125
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:43:27 GMT
 
{"réponse": {"erreurs": ["le corps du POST n'est pas une chaîne jSON valide : Expecting value: line 1 column 1 (char 0)"]}}
  • riga 13: è stata inviata la stringa [abc], che non è una stringa JSON valida (riga 3);
  • riga 15: il server risponde con un codice di errore 400;
  • riga 21: la risposta JSON del server;

Caso 2: inviamo una stringa JSON valida che non sia un elenco


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: 03b64735-9239-47b3-b92d-be7c9ebc7559
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 17
 
{"att1":"value1"}
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 97
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:50:11 GMT
 
{"réponse": {"erreurs": ["le corps du POST n'est pas une liste ou alors cette liste est vide"]}}

Caso 3: inviamo una stringa JSON che è un elenco i cui elementi non sono tutti dizionari


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: a1528a5f-777c-413f-b3be-7d4e9955b12a
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 7
 
[0,1,2]
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 85
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:52:10 GMT
 
{"réponse": {"erreurs": ["le corps du POST doit être une liste de dictionnaires"]}}

Caso 4: inviamo un elenco di dizionari con un dizionario che non ha le chiavi corrette


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: ba964d81-c9d9-46ff-a521-b4c4e5639484
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 19
 
[{"att1":"value1"}]
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 112
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:54:33 GMT
 
{"réponse": {"erreurs": [{"att1": "value1", "erreur": "MyException[2, la clé [att1] n'est pas autorisée]"}]}}

Caso 5: inviamo un elenco di dizionari con un dizionario contenente chiavi mancanti:


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: 98aec51d-f37d-4c14-81cd-c7ffcbbcdc65
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 18
 
[{"marié":"oui"}]
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 125
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:56:40 GMT
 
{"réponse": {"erreurs": [{"marié": "oui", "erreur": "le dictionnaire doit inclure les clés [marié, enfants, salaire]"}]}}

Caso 6: inviamo un elenco di dizionari in cui uno contiene le chiavi corrette ma alcuni hanno valori errati:


POST / HTTP/1.1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Type: application/json
User-Agent: PostmanRuntime/7.26.2
Accept: */*
Cache-Control: no-cache
Postman-Token: 3083e601-dee4-4e15-9ea4-fc0328d0fcf0
Host: localhost:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 46
 
[{"marié":"x", "enfants":"x", "salaire":"x"}]
 
HTTP/1.0 400 BAD REQUEST
Content-Type: application/json; charset=utf-8
Content-Length: 167
Server: Werkzeug/1.0.1 Python/3.8.1
Date: Tue, 28 Jul 2020 07:59:32 GMT
 
{"réponse": {"erreurs": [{"marié": "x", "enfants": "x", "salaire": "x", "erreur": "MyException[31, l'attribut marié [x] doit avoir l'une des valeurs oui / non]"}]}}

28.3. Il client web

Image

Il file [http-clients/05] (versione 10) viene inizialmente ottenuto copiando il file [http-clients/02] (versione 7). Viene poi modificato.

28.3.1. Il livello [dao]

Il livello [dao] è implementato dalla seguente classe [ImpôtsDaoWithHttpClient]:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#  imports

import requests
from flask_api import status

from AbstractImpôtsDao import AbstractImpôtsDao
from AdminData import AdminData
from ImpôtsError import ImpôtsError
from InterfaceImpôtsMétier import InterfaceImpôtsMétier
from TaxPayer import TaxPayer


class ImpôtsDaoWithHttpClient(AbstractImpôtsDao, InterfaceImpôtsMétier):

    #  manufacturer
    def __init__(self, config: dict):
        …

    #  unused method
    def get_admindata(self) -> AdminData:
        pass

    #  tAX CALCULATION
    def calculate_tax(self, taxpayer: TaxPayer, admindata: AdminData = None):
        …

    #  bulk tax calculation
    def calculate_tax_in_bulk_mode(self, taxpayers: list) -> list:
        #  we let the exceptions rise

        #  transform taxpayers into a list of dictionaries
        #  we keep only the properties [married, children, salary]
        list_dict_taxpayers = list(
            map(lambda taxpayer:
                taxpayer.asdict(included_keys=[
                    '_TaxPayer__marié',
                    '_TaxPayer__enfants',
                    '_TaxPayer__salaire']),
                taxpayers))

        #  server connection
        config_server = self.__config_server
        if config_server['authBasic']:
            response = requests.post(config_server['urlServer'], json=list_dict_taxpayers,
                                     auth=(config_server["user"]["login"],
                                           config_server["user"]["password"]))
        else:
            response = requests.post(config_server['urlServer'], json=list_dict_taxpayers)
        #  debug mode?
        if self.__debug:
            #  logger
            if not self.__logger:
                self.__logger = self.__config['logger']
            #  log on
            self.__logger.write(f"{response.text}\n")
        #  response status code HTTP
        status_code = response.status_code
        #  we put the response jSON in a dictionary
        résultat = response.json()
        #  error if status code other than 200 OK
        if status_code != status.HTTP_200_OK:
            #  we know that the errors have been associated with the [errors] key in the response
            raise ImpôtsError(93, résultat['réponse']['erreurs'])
        #  we know that the result has been associated with the [results] key in the response
        list_dict_taxpayers2 = résultat['réponse']['results']
        #  the initial list of taxpayers is updated with the results received
        for i in range(len(taxpayers)):
            #  taxpayers[i] update
            taxpayers[i].fromdict(list_dict_taxpayers2[i])
        #  here the [taxpayers] parameter has been updated with the server results
  • righe 1–26: il codice rimane lo stesso della versione 7 e delle altre versioni;
  • righe 27–70: viene introdotto un nuovo metodo [calculate_tax_in_bulk_mode], il cui scopo è calcolare l'imposta per un elenco di contribuenti;
  • riga 28: [taxpayers] è questo elenco di contribuenti;
  • righe 31–39: convertiamo un elenco di oggetti [TaxPayer] in un elenco di dizionari utilizzando la funzione [map];
  • righe 34–38: la funzione lambda utilizzata trasforma un oggetto di tipo [TaxPayer] in un dizionario di tipo [dict] con solo le chiavi [married, children, salary]. Per farlo, utilizziamo il parametro denominato [included_keys] del metodo [BaseEntity.asdict]. Si noti che per determinare i nomi esatti delle proprietà da includere nei parametri [excluded_keys, included_keys], è necessario utilizzare il dizionario predefinito [taxpayer.__dict__];
  • righe 41–48: connessione al server e recupero della sua risposta HTTP;
  • righe 44, 48:
    • utilizziamo il metodo statico [requests.post] per inviare una richiesta POST al server;
    • Il parametro denominato [json] viene utilizzato per indicare che il corpo della richiesta POST è una stringa JSON. Ciò comporta due conseguenze:
      • l'oggetto assegnato al parametro denominato [json], in questo caso un elenco di dizionari, verrà convertito in una stringa JSON;
      • l'intestazione 
Content-Type: application/json

sarà inclusa nelle intestazioni HTTP del POST;

  • riga 59: la risposta JSON del server viene deserializzata nel dizionario [result];
  • righe 61–63: viene gestito qualsiasi errore inviato dal server;
  • riga 65: i risultati del calcolo delle imposte sono in un elenco di dizionari;
  • righe 67–69: questi risultati vengono utilizzati per aggiornare l'elenco iniziale dei contribuenti [taxpayers] originariamente ricevuto dal metodo alla riga 28;
  • riga 70: qui, l'elenco iniziale dei contribuenti è stato aggiornato con i risultati del calcolo delle imposte;

28.3.2. Lo script principale [main]

Lo script principale [main] si evolve come segue: viene modificata solo la funzione [thread_function] eseguita dai thread creati dal client. Il resto del codice rimane invariato.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#  executing the [dao] layer in a thread
#  taxpayers is a list of taxpayers
def thread_function(dao: ImpôtsDaoWithHttpClient, logger: Logger, taxpayers: list):
    #  log thread start
    thread_name = threading.current_thread().name
    nb_taxpayers = len(taxpayers)
    #  log
    logger.write(f"début du calcul de l'impôt des {nb_taxpayers} contribuables\n")
    #  taxpayers' taxes are calculated
    dao.calculate_tax_in_bulk_mode(taxpayers)
    #  log
    logger.write(f"fin du calcul de l'impôt des {nb_taxpayers} contribuables\n")
  • righe 9–10: mentre in precedenza avevamo un ciclo che passava ogni contribuente a turno al metodo [dao.calculate_tax], qui effettuiamo una singola chiamata al metodo [dao.calculate_tax_in_bulk_mode], passando ad esso tutti i contribuenti;

28.3.3. Esecuzione client

Confronteremo i tempi di esecuzione delle versioni:

  • 7, in cui ogni contribuente è oggetto di una richiesta HTTP;
  • 10 (questa), in cui i contribuenti sono raggruppati in un'unica richiesta HTTP;

In primo luogo, la versione 6. Per confrontare le due versioni, impostiamo la proprietà [sleep_time] del server a zero in modo che non vi sia alcuna attesa forzata per i thread. I log del client sono i seguenti:


2020-07-28 14:20:45.811347, Thread-1 : début du thread [Thread-1] avec 4 contribuable(s)
2020-07-28 14:20:45.811347, Thread-1 : début du calcul de l'impôt de {"id": 1, "marié": "oui", "enfants": 2, "salaire": 55555}
…
2020-07-28 14:20:45.913065, Thread-3 : fin du calcul de l'impôt de {"id": 11, "marié": "oui", "enfants": 3, "salaire": 200000, "impôt": 42842, "surcôte": 17283, "taux": 0.41, "décôte": 0, "réduction": 0}
2020-07-28 14:20:45.913065, Thread-3 : fin du thread [Thread-3]

Il tempo di esecuzione del client per calcolare l'imposta per 11 contribuenti è quindi [913065-811347= 101718], ovvero circa 102 millisecondi.

Facciamo lo stesso con la versione 10 (timeout del server impostato a zero). I log del client sono quindi i seguenti:


2020-07-28 14:25:31.871428, Thread-1 : début du calcul de l'impôt des 4 contribuables
2020-07-28 14:25:31.873594, Thread-2 : début du calcul de l'impôt des 3 contribuables
2020-07-28 14:25:31.877429, Thread-3 : début du calcul de l'impôt des 3 contribuables
2020-07-28 14:25:31.882855, Thread-4 : début du calcul de l'impôt des 1 contribuables
2020-07-28 14:25:31.930723, Thread-2 : {"réponse": {"results": [{"marié": "non", "enfants": 3, "salaire": 100000, "impôt": 16782, "surcôte": 7176, "taux": 0.41, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 3, "salaire": 100000, "impôt": 9200, "surcôte": 2180, "taux": 0.3, "décôte": 0, "réduction": 0}, {"marié": "oui", "enfants": 5, "salaire": 100000, "impôt": 4230, "surcôte": 0, "taux": 0.14, "décôte": 0, "réduction": 0}]}}
….
2020-07-28 14:25:31.935958, Thread-4 : fin du calcul de l'impôt des 1 contribuables
2020-07-28 14:25:31.935958, Thread-1 : fin du calcul de l'impôt des 4 contribuables

Il tempo di esecuzione del client per calcolare l'imposta per 11 contribuenti è quindi [935958-871428= 64530 ns] (riga 8 – riga 1), ovvero circa 65 millisecondi. Questa nuova versione 10 offre quindi un guadagno in termini di prestazioni di circa il 57% rispetto alla versione 7.

28.3.4. Test del livello [dao] del client

Image

Il test [TestHttpClientDao] per il client nella versione 10 è molto simile a quello della versione 7:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import unittest

from Logger import Logger


class TestHttpClientDao(unittest.TestCase):

    def test_1(self) -> None:
        from TaxPayer import TaxPayer

        #  { 'married': 'yes', 'children': 2, 'salary': 55555,
        #  tax': 2814, 'surcôte': 0, 'décôte': 0, 'réduction': 0, 'taux': 0.14}
        taxpayer = TaxPayer().fromdict({"marié": "oui", "enfants": 2, "salaire": 55555})
        dao.calculate_tax_in_bulk_mode([taxpayer])
        #  check
        self.assertAlmostEqual(taxpayer.impôt, 2815, delta=1)
        self.assertEqual(taxpayer.décôte, 0)
        self.assertEqual(taxpayer.réduction, 0)
        self.assertAlmostEqual(taxpayer.taux, 0.14, delta=0.01)
        self.assertEqual(taxpayer.surcôte, 0)

    …

if __name__ == '__main__':
    #  configure the application
    import config
    config = config.configure({})

    #  logger
    logger = Logger(config["logsFilename"])
    #  we save it in the config
    config["logger"] = logger
    #  we recover the [dao] layer
    dao = config["layers"]["dao"]

    #  test methods are executed
    print("tests en cours...")
    unittest.main()
  • riga 14: invece di chiamare il metodo [dao.calculate_tax], chiamiamo il metodo [dao.calculate_tax_in_bulk_mode], passando un elenco (indicato dalle parentesi quadre) di contribuenti;

Tutti i test sono stati superati.

https://stahe.github.io
Questo tutorial scritto da Serge Tahé è reso disponibile al pubblico secondo i termini della Creative Commons Attribuzione – Non commerciale – Condividi allo stesso modo 3.0 Unported.