Skip to content

28. Exercício da aplicação: versão 10

28.1. Introdução

Nos exemplos de clientes para o servidor de cálculo de impostos, os threads enviam N pedidos sequencialmente se tiverem de processar N contribuintes. A ideia aqui é enviar um único pedido que englobe os N contribuintes. Para cada um deles, as informações [casado, filhos, salário] devem ser enviadas. Estas podem ser enviadas como parâmetros:

  • na URL. Isto resulta numa URL longa e sem sentido;
  • no corpo da solicitação HTTP. Sabemos que este corpo fica oculto do utilizador que utiliza um navegador;

Em ambos os casos, pode utilizar uma solicitação [GET] ou [POST]. Utilizaremos uma solicitação POST com os parâmetros incorporados no corpo da solicitação HTTP.

A arquitetura cliente/servidor não mudou:

Image

28.2. O servidor web

Image

A pasta [http-servers/05] é inicialmente criada através da cópia da pasta [http-servers/02]. Voltamos às trocas JSON entre o cliente e o servidor. Vimos que a mudança de JSON para XML é muito simples.

28.2.1. Configuração

A configuração [config, config_database, config_layers] permanece a mesma das versões anteriores. Não vamos voltar a abordá-la.

28.2.2. O script principal [main]

O script [main] é idêntico ao da pasta [http-servers/02] que copiámos. Apenas uma coisa difere:

1
2
3
4
5
#  Home URL
@app.route('/', methods=['POST'])
@auth.login_required
def index():
    …
  • linha 2: o URL / é agora acedido através de um pedido POST;

28.2.3. O [index_controller]

O [index_controller] evolui da seguinte forma:

 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
  • Linha 9: O controlador recebe:
      • o pedido do cliente;
      • a configuração do servidor [config];
  • linhas 14–18: Recuperamos o corpo da solicitação POST. Os parâmetros encapsulados no corpo da solicitação HTTP podem ser codificados de várias maneiras. Já vimos uma delas: [x-www-form-urlencoded]. Aqui, usaremos outra codificação: JSON;
  • linha 18: [request.data] recupera o corpo da solicitação HTTP. Aqui, recuperamos texto, e sabemos que este texto é JSON representando uma lista de dicionários [casado, filhos, salário];
  • linhas 19–24: recuperamos esta lista de dicionários;
  • linhas 22–24: se a recuperação do JSON falhar, registamos o erro;
  • linhas 26–28: se verificarmos que o objeto recuperado não é uma lista ou é uma lista vazia, registamos o erro;
  • linhas 29–38: se uma lista foi recuperada com sucesso, verificamos se é de facto uma lista de dicionários;
  • linhas 40–43: se ocorreu um erro, paramos aqui e enviamos uma resposta de erro ao cliente;
  • linhas 45–69: verificamos agora cada um dos dicionários:
    • eles devem conter as chaves [casado, filhos, salário];
    • devem permitir-nos construir um objeto [TaxPayer] válido;
  • linhas 65–69: se for detetado um erro num dicionário, este é adicionado ao mesmo dicionário sob a chave «error»;
  • linhas 72–75: os dicionários que contêm erros foram reunidos na lista [list_errors]. Se esta lista não estiver vazia, é enviada numa resposta de erro ao cliente;
  • linha 77: nesta altura, sabemos que podemos criar uma lista de objetos do tipo [TaxPayer] a partir do corpo do pedido enviado pelo cliente;
  • linhas 84–91: Processamos a lista de dicionários recebidos;
  • linha 86: a partir de um dicionário, criamos um objeto [TaxPayer];
  • linha 89: calculamos o imposto para este [TaxPayer];
  • linha 91: sabemos que [taxpayer] foi modificado pelo cálculo do imposto. Convertemo-lo num dicionário e adicionamo-lo a uma lista de resultados;
  • linha 93: esta lista de resultados é enviada ao cliente;

28.2.4. Teste do servidor

Iremos testar o servidor utilizando um cliente Postman:

  • Iniciamos o servidor web, o SGBD e o servidor de e-mail [hMailServer];
  • Iniciamos o cliente Postman e a sua consola (Ctrl-Alt-C);

Image

  • em [1]: enviamos uma solicitação [POST];
  • em [2]: a URL do servidor;
  • em [3]: o corpo da solicitação HTTP;
  • em [5]: especificamos que este corpo deve ser enviado como uma string JSON;
  • em [4]: mudamos para o modo [raw] para poder copiar e colar uma string JSON;
  • em [6]: coloque a string JSON retirada de um dos ficheiros [results.json] para as diferentes versões. Em seguida, para cada contribuinte, mantenha apenas as propriedades [casado, salário, filhos];

Image

  • em [7], analisamos os cabeçalhos HTTP que o cliente Postman enviará ao servidor;
  • em [8], vemos que ele enviará um cabeçalho [Content-Type] indicando que a solicitação contém um corpo codificado em JSON. Isto deve-se à escolha feita anteriormente em [5];

Image

  • em [9-12]: incluímos as credenciais esperadas pelo servidor na solicitação;

Enviamos esta solicitação. A resposta do servidor é a seguinte:

Image

  • em [3], recebemos JSON;
  • em [4], o imposto dos contribuintes;

Vamos examinar o diálogo cliente/servidor que ocorreu na consola do Postman (Ctrl-Alt-C):

O cliente Postman enviou o seguinte texto:

 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
  }
]
  • linha 1: o pedido POST para o servidor;
  • linha 2: o cabeçalho de autenticação HTTP;
  • linha 3: o cliente informa ao servidor que está a enviar uma cadeia JSON e que esta cadeia tem 824 bytes (linha 11);
  • linhas 13–69: o corpo JSON da solicitação;

O servidor respondeu com o seguinte texto:


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}]}}
  • linha 1: o pedido foi bem-sucedido;
  • linha 2: o corpo da resposta do servidor é uma cadeia JSON. Tem 1461 bytes de comprimento (linha 3);
  • linha 7: a resposta JSON do servidor;

Agora vamos testar alguns casos de erro.

Caso 1: enviamos qualquer coisa


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)"]}}
  • linha 13: foi enviada a cadeia [abc], que não é uma cadeia JSON válida (linha 3);
  • linha 15: o servidor responde com um código de erro 400;
  • linha 21: a resposta JSON do servidor;

Caso 2: Vamos enviar uma string JSON válida que não seja uma lista


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: Vamos enviar uma cadeia JSON que é uma lista cujos elementos não são todos dicionários


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: Vamos enviar uma lista de dicionários com um dicionário que não tem as chaves corretas


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: Vamos enviar uma lista de dicionários com um dicionário que contém chaves em falta:


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: Vamos enviar uma lista de dicionários, sendo que um deles contém as chaves corretas, mas alguns têm valores incorretos:


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. O cliente web

Image

O ficheiro [http-clients/05] (versão 10) é inicialmente obtido através da cópia do ficheiro [http-clients/02] (versão 7). Em seguida, é modificado.

28.3.1. A camada [dao]

A camada [dao] é implementada pela seguinte 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
  • linhas 1–26: o código permanece o mesmo da versão 7 e de outras versões;
  • linhas 27–70: é introduzido um novo método [calculate_tax_in_bulk_mode], cujo objetivo é calcular o imposto para uma lista de contribuintes;
  • linha 28: [taxpayers] é esta lista de contribuintes;
  • linhas 31–39: convertemos uma lista de objetos [TaxPayer] numa lista de dicionários utilizando a função [map];
  • linhas 34–38: a função lambda utilizada transforma um objeto do tipo [TaxPayer] num dicionário do tipo [dict] com apenas as chaves [married, children, salary]. Para tal, utilizamos o parâmetro denominado [included_keys] do método [BaseEntity.asdict]. Note que, para determinar os nomes exatos das propriedades a incluir nos parâmetros [excluded_keys, included_keys], deve utilizar o dicionário predefinido [taxpayer.__dict__];
  • linhas 41–48: ligar-se ao servidor e recuperar a sua resposta HTTP;
  • linhas 44, 48:
    • Utilizamos o método estático [requests.post] para enviar um pedido POST ao servidor;
    • O parâmetro denominado [json] é utilizado para indicar que o corpo da solicitação POST é uma cadeia de caracteres JSON. Isto terá duas consequências:
      • o objeto atribuído ao parâmetro denominado [json], neste caso uma lista de dicionários, será convertido numa cadeia JSON;
      • o cabeçalho 
Content-Type: application/json

será incluído nos cabeçalhos HTTP do POST;

  • linha 59: a resposta JSON do servidor é deserializada para o dicionário [result];
  • linhas 61–63: qualquer erro enviado pelo servidor é tratado;
  • linha 65: os resultados do cálculo do imposto estão numa lista de dicionários;
  • linhas 67–69: estes resultados são utilizados para atualizar a lista inicial de contribuintes [taxpayers] originalmente recebida pelo método na linha 28;
  • linha 70: aqui, a lista inicial de contribuintes foi atualizada com os resultados do cálculo do imposto;

28.3.2. O script principal [main]

O script principal [main] evolui da seguinte forma: apenas a função [thread_function] executada pelos threads criados pelo cliente é modificada. O resto do código permanece inalterado.

 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")
  • linhas 9–10: enquanto anteriormente tínhamos um ciclo que passava cada contribuinte, um por um, para o método [dao.calculate_tax], aqui fazemos uma única chamada ao método [dao.calculate_tax_in_bulk_mode], passando-lhe todos os contribuintes;

28.3.3. Execução do cliente

Vamos comparar os tempos de execução das versões:

  • 7, em que cada contribuinte é objeto de um pedido HTTP;
  • 10 (esta), em que os contribuintes são agrupados numa única solicitação HTTP;

Primeiro, a versão 6. Para comparar as duas versões, definimos a propriedade [sleep_time] do servidor como zero, para que não haja espera forçada para os threads. Os registos do cliente são os seguintes:


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]

O tempo de execução do cliente para calcular o imposto de 11 contribuintes é, portanto, [913065-811347= 101718], ou seja, aproximadamente 102 milissegundos.

Vamos fazer o mesmo com a versão 10 (tempo de espera do servidor definido como zero). Os registos do cliente são então os seguintes:


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

O tempo de execução do cliente para calcular o imposto de 11 contribuintes é, portanto, [935958-871428= 64530 ns] (linha 8 – linha 1), ou seja, aproximadamente 65 milissegundos. Esta nova versão 10 proporciona, assim, um ganho de desempenho de aproximadamente 57% em relação à versão 7.

28.3.4. Testes da camada [dao] do cliente

Image

O teste [TestHttpClientDao] para o cliente na versão 10 é muito semelhante ao da versão 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()
  • linha 14: em vez de chamar o método [dao.calculate_tax], chamamos o método [dao.calculate_tax_in_bulk_mode], passando-lhe uma lista (indicada pelos parênteses retos) de contribuintes;

Todos os testes são aprovados.

https://stahe.github.io
Este tutorial, escrito por Serge Tahé, é disponibilizado ao público sob os termos da Creative Commons Atribuição – Não comercial – Partilha igual 3.0 Unported.