Pour régler le problème qui arrive souvent sur les projets **node**: 

```shell
Error: EMFILE, too many open files, watch ...
```

Nous allons augmenter le nombre de fichier que le système peut watch simultanément !

Pour celà, faîtes un :

```shell
sudo nano /etc/sysctl.conf
```

Dans le fichier **/etc/sysctl.conf**, ajoutez les lignes :

```shell
fs.file-max = 65535 
fs.inotify.max_user_watches=524288
fs.inotify.max_user_instances=512
```

Sauvegardez et rechargez votre fichier sysctl : 

```shell
sudo sysctl --system
```

large_error-emfile.png

medium_error-emfile.png

small_error-emfile.png

thumbnail_error-emfile.png

error-emfile.png

Lorsque vous travaillez sous linux, le watch mode, qui sert à compiler à la volée lorsque vous modifiez le code, notamment si vous faîtes du Typescript, un projet react-create-app ou autre, risque de rencontrer un problème au lancement. Comment solutionner cela ?

Gérer le problème too many open files sous Ubuntu 22

### Installer Temporal sous Windows

Temporal est livré avec son propre CLI (son exécutable), la commande **temporal** depuis un terminal. Mais il ne suffit pas de [télécharger le CLI](https://www.restack.io/docs/temporal-knowledge-temporal-io-download).

Pour pouvoir l'installer et l'utiliser vous aurez besoin [d'installer Nodejs](https://nodejs.org/en/download) et [d'installer Rust](https://www.rust-lang.org/tools/install).

Une fois que installé, et le projet **Temporal** cloné, j'ai pour habitude de lancer Temporal au démarrage de la machine. 

### Lancer Temporal au boot

Cliquez sur Windows et tapez "run", vous aurez une commande d'exécution qui va s'ouvrir, tapez: "shell:startup".

Un dossier va s'ouvrir. 📁

Il faut savoir que tout ce que vous allez mettre ici se lance automatiquement au démarrage.

Je crée 2 fichiers **.bat** : un pour le serveur un pour le worker. 🗎

**server.bat**
```shell
cd "<chemin vers le projet temporal>"
yarn start:dev --ui-ip <ip de la machine>
```

**worker.bat**
```shell
cd "<chemin vers le projet temporal>"
yarn start
```

### La subtilité

Pour éviter d'avoir des problèmes avec un accès distant, j'ai redirigé l'ip de la web interface vers l'ip locale (pour éviter de forcer localhost). Dans le cas contraire votre machine est inaccessible depuis le réseau local.

Cependant, assurez vous de:

- Basculer en réseau privé (au lieu de public)
- Ajouter une exception dans votre firewall en TCP sur les port : **7233**, **8233**

### Résultat 

![temporal-remote.png](https://bo.dev-freelance.fr/uploads/temporal_remote_ad0ac72389.png)

Dans mon cas, j'ai redirgé uniquement l'ip de la web interface, donc si vous avez besoin d'accéder au serveur **Temporal** directement depuis un Worker sur une autre machine, là c'est une autre pair de manches. C'est un scénario que je n'ai pas testé, mais je prendrai le temps de le faire prochainement.

large_windows-10-temporal.jpg

medium_windows-10-temporal.jpg

small_windows-10-temporal.jpg

thumbnail_windows-10-temporal.jpg

windows-10-temporal.jpg

Sous Windows 10 et 11, il n'est pas évident de déployer un Temporal accessible de partout sur un réseau local. Pour éviter les problèmes de timeout, il va falloir faire quelques modifications.

Comment mettre en place un serveur Temporal sous Windows

Avez vous eu à intégrer des process multi étapes en programmation ? 

Cela peut être :
- Une chaîne de vente (vente/paiement, mise à jour des stocks, logistique, livraison, consolidation en compta)
- Une chaîne d'appro (commande, logistique, stockage, mise à jour des stocks, inventaire)

Tout process qui peut durer dans le temps est difficile à traduire informatiquement, car on a souvent du mal à savoir quand est-ce que les événement vont se produire.

A tel point que, les méthodes mises en place par les sociétés informatiques, consistent souvent à coder plusieurs étapes du process séparément, puis en planifier l’exécution récurrente. 

Ainsi il n'est pas rare d'avoir une chaîne de vente qui ressemble à cela :

![Process de vente traditionnel ><](https://bo.dev-freelance.fr/uploads/temporal_sample_process_drawio_e26a2662ee.png)

⚠️ Si une étape est en erreur, c'est l'intégralité du process qui est remis en question.

Pour une pièce défectueuse à remplacer dans la commande avant expédition, il faudra rajouter une étape de réassort etc... **Le simple fait de casser le schéma connu de process peut corrompre son fonctionnement. De même que les rattrapages sont souvent gérés à la main, c'est à dire, hors process.**

Gérer la complexité d'un process long est un cauchemar pour tout développeur qui l'a déjà fait. Souvent, à cause du fait que chacune de ces étapes passe par un outil ou une passerelle dédié. Chaque équipe de l'entreprise ayant son mode de fonctionnement, il n'est pas rare d'avoir : 
- Un logiciel de Caise AAAA
- Un logiciel de gestion de stock BBBB
- Un prestataire de livraison avec une plateforme CCCC
- Un logiciel comptable DDDD

Vous voyez où je veux en venir ? Les passerelles sont souvent différentes, et jusqu'à présent, il y a peu d'outils capable d'unifier tout le process, de gérer facilement le prolongement d'une étape dans le temps, un retry de process sans avoir à tout reprendre de 0. J'ai l'air de décrire quelque chose de magique et d'impossible jusque là. Pourtant cet outil existe réellement et il s'appelle [Temporal](https://temporal.io/) ⚡ !

![temporal-logo-dark.svg ><](https://bo.dev-freelance.fr/uploads/temporal_logo_dark_8217d6ff16.svg)

### Pourquoi cette solution est incroyable ?

Temporal est une technologie qui a été créée par le Tech Lead d'**Amazon SQS**. Et rien qu'avec ça on sait que le bougre en a sous le coude avec les process asynchrones. 

**SQS** pour **Simple Queue Service**, est un service d'**Amazon** qui permet à plusieurs briques de code de s'interfacer (via un messaging system) efficacement et à moindre coût. Il s'agit d'un outil taillé pour les architectures micro-service. 

**Temporal** est tout de même différent de **SQS**, il peut fonctionner de plusieurs façons, même au sein d'un service unique et sera plutôt un orchestrateur de process. Il s'agit d'un moteur de workflow, c'est à dire qu'il va séquencer les étapes les unes après les autres afin de reproduire tout le process de A à Z. Que vous soyez en micro-service ou en monolithique importe peu.

De même, il est très utilisé par des boîtes comme **Uber**, le géant de la mise en relation du transport pour une raison bien particulière : son extrême résilience vis à vis du long-run. 

### Le long run c'est quoi ?

Lorsque chacune de vos étapes de process peut tourner pendant période difficilement prévisible, il y a plusieurs façon de procéder :

 - Soit on fait du **Cron** (une tâche planifiée qui s'exécute automatiquement) et on réessaye régulièrement pour voir s'il y de nouveaux traitements à faire
 - Soit on a un process qui est tourne en tâche de fond et qui prend les jobs aussitôt qu'ils tombent (cela consomme de la ressource en permanence)

**Temporal** vous propose la seconde option, mais plutôt que ce soit vos systèmes qui passent en position d'attente, c'est le process de **Temporal** qui va le faire pour votre système, laisse ainsi de la ressource disponible pour continuer à opérer.

Dans l'idée, vous aurez besoin de coder des micro étapes de votre process. Tant que vous pouvez découper, il faut découper :
- Sélection d'un produit = 1 étape
- Paiement = 1 étape
- Mise à jour de stock = 1 étape
- Préparation de commande = 1 étape
- Remise au livreur = 1 étape

Dans Temporal, ces étapes s'appellent des **activities**.

Si l'on peut découper encore plus finement, il faut le faire, et vous allez comprendre pourquoi. Le principe même de Temporal, c'est de venir **Wrapper** chacune de ces étapes, de manière à être capable de relancer uniquement celle qui s'est arrêté ou a rencontré une erreur.

### En quoi est-ce une révolution ?

Au lieu d'avoir des process qui doivent être rejoué de A à Z en cas d'erreur, ici nous sommes dans une situation ou chacune des étapes peut être jouée l'une après l'autre, et lorsqu'une étape s'arrête, elle peut être reprise à tout moment. 

A tel point que si vous avez un bug dans le code, cette fonctionnalité vous permet de redéployer entièrement votre projet. Le processus se relancera comme si rien n'avait bougé, et réexécutera uniquement l'activité en erreur. 

Pas de gestion de l'invalidation à faire, pas de rollback à prévoir.

Je m'adresse à tout ceux qui ont déjà codé des process longs ☝️, vous savez de quoi je parle, pas vrai ? 😝

Après rien ne vous empêche de faire le flow sur mesure, qui gère le rollbck ou autre. 

Cepandant, il y a quelques principes de base à respecter comme toujours utiliser des fonctions déterministes pour vos **activities**, car ces inputs vont créer un pattern qui permettra de savoir si oui ou non cette étape a déjà été jouée. Il faut qu'une fonction qui soit appelée avec le même input retourne le même résultat. 

### Les avantages de Temporal

Les avantages de Temporal sont légions :
- sous Licence MIT
- Gère la problématique de long run comme s'il s'agissait d'un jeu d'enfant
- Built-in retry en cas d'erreur d'une étape
- On ne relance pas un process entier depuis le début
- Un dashboard détaillé pour suivre le process
- Déclenchement par le code (client sdk à disposition), CLI ou autre
- Scalable grâce aux workers
- Concepts très simples mais très puissant si on a un besoin complexe à gérer

### Les inconvénients de Temporal

- En terme de ressources : Temporal a besoin de déployer **un serveur pour orchestrer les jobs** et **des workers pour jouer les workflows**
- Est plus efficace avec une base de donnée (même si cela reste optionnel) car si non, rien ne sera loggé à chaque fois que l'on relance l'instance server

### Conclusion

Je pense qu'il y a largement plus d'avantages que d'inconvénients. Vous pouvez même opter pour un modèle SaaS hébergé par la société qui édite **Temporal**, si vous décidez de déléguer l'administration d'un serveur.

Qu'attendez-vous pour vous y mettre ? Prochainement je vous parlerai de mes expériences avec **Temporal**.

large_temporal.jpg

medium_temporal.jpg

small_temporal.jpg

thumbnail_temporal.jpg

temporal.jpg

Lorsque vous intégrez un process business dans un projet applicatif, il est très compliqué de transposer la réalité sur un système informatique. Que ce soit au niveau des données, mais surtout au niveau process. C'est pourquoi je vous présente un outil qui est spécialement conçu pour intégrer des process de l'entreprise.

Connaissez-vous Temporal ?

## La GED

La **GED** (pour Gestion Electronique des Documents) est un domaine spécifique en informatique. Il s'agit de l'archivage et parfois de la compréhension de documents imprimés ou écrits. Pour ces derniers, on parle d'**OCR** (optical character recognition), comprenez la reconnaissance des caractères. Chaque domaine spécifique en informatique demande une compétence spécifique, c'est à dire que les professionnels experts de la **GED** sont souvent bien meilleurs que les autres sur le sujet, car ils ont eu le temps d'expérimenter beaucoup d'approches et ont une expérience dédiée au sujet.

Moi, qui suis un néophyte en la matière, je vous propose de faire un retour d'expérience sur le sujet car j'ai eu l'occasion de me pencher sur le traitement des relevés bancaires fournis en **PDF** scanné. 

## Le PDF

Le format **PDF** (portable document format) a été créé par **Adobe**, l'éditeur logiciel qui a créé entre-autres, **Photoshop**, le meilleur logiciel de retouche photo, à mon avis. Le **PDF** est un format permettant de récupérer un ensemble de pages dans un seul fichier. Jusqu'alors, scanner un document signifiait avoir l'extraction de chaque page en un fichier image différent.

Le **PDF** permet non seulement de regrouper plusieurs documents en un seul, et peut être généré au format texte ou au format image. Inutile de vous préciser que lorsque vous scannez un document en **PDF**, très souvent vous obtiendrez un format image, (même si certains scanner font l'effort de faire de l'**OCR**). Et c'est sur ce format spécifique, constitué d'images que nous allons nous pencher, car, il est beaucoup plus difficile à traiter.

## Tesseract

Lorsque l'on veut faire de l'**OCR**, on utilise des librairies très connus tel que **Tesseract**. Cette librairie a été dévelopée par **HP** avec le soutien de **Google** et est distribuée sous licence **Apache**. Avec **Tesseract**, en quelques lignes dans un terminal on peut lui faire sortir un fichier texte depuis une source image.

Et cela peut se faire en une ligne très simple :

```
tesseract image.png output.txt
```

Alors, vous l'aurez compris, si la condition est d'avoir en entrée un fichier image, il suffit de splitter le **PDF** en plusieurs fichier image et de les passer chacune à **Tesseract** et le tour est joué ?

Et bien, ce n'est pas si simple !

Lorsque le fichier image est complexe (c'est notamment le cas d'un tableau de relevé bancaire avec des alignements dans toutes les colonnes et des données pouvant être d'un côté et de l'autre du document) **Tesseract** est incapable de gérer les alignements. 
Il n'est par rare qu'il mette tous les caractères à côté alors que dans le fichier source ils sont à 10 cm l'un de l'autre. De même, il n'est pas rare que **Tesseract** zappe littéralement des portions du fichier, que vous ne retrouverez pas en sortie !

## Pourquoi faire du machine learning ?

Je vais vous expliquer maintenant pourquoi, j'ai opté pour une approche **IA** plutôt qu'un simple script étape par étape qui va passer les éléments à **Tesseract**.

J'ai procédé à un test simple, j'ai splité chaque ligne du tableau de relevé bancaire et je l'ai passé à Tesseract pour voir comment il réagissait. Le résultat est incroyable, désormais, tous les éléments sont restitués, il n'y a plus de partie manquante en sortie. Le seul petit bémol, c'est qu'il n'arrive toujours pas à gérer les alignements correctement.

En revanche l'IA peut gérer ce problème d'alignement :

Etant donné que chaque banque fourni systématiquement un format spécifique avec des alignements toujours identiques, on pourrait imaginer un système qui s'appuie sur de l'**object detection** en IA, qui serait dédié à chaque type de banque afin d'avoir une reconnaissance automatique des colonnes du relevés à savoir : date, libellé, débit, crédit. 

L'object détection consiste à faire détecter des éléments à l'IA. Pour ce faire, on va marquer ces éléments sur plusieurs images et entrainer un modèle sur ces marquages jusqu'à ce qu'il sache de lui même les repérer lorsqu'on lui passe un flux (image, vidéo ou autre). 

Pourquoi je veux absolument faire un modèle d'object detection dédié par banque ? 

En machine learning, le nerf de la guerre c'est la data. 

Il faut avoir énormément de données sources pour que le modèle puisse s'entrainer et assimiler. Le problème d'un modèle unique, multi banque, c'est que je vais devoir avoir une quantité énorme de documents à fournir et à marquer. Alors qu'un modèle dédié, me permettrait de fournir une vingtaine de fichier par banque, car on couvrirait une quantité raisonnable de cas et je pense que cela serait suffisant pour que l'IA comprenne quel élément correspond à quelle colonne.

## Le plan d'attaque

Voici comment je vais procéder :

![ia_releve_bancaire.drawio.png](https://bo.dev-freelance.fr/uploads/ia_releve_bancaire_drawio_8e79e1bc32.png)

Je vais commencer par faire de la classification, puis, par banque, je vais faire de l'object detection pour extraire les lignes qui m'intéressent de manière splittée, ensuite je vais refaire de l'object detection sur chaque ligne afin de repérer les colonnes et enfin je vais assembler les données.

### Qu'est-ce que la classification ?

Plus haut, je vous parlait de l'**object detection**. De la même manière, la **Classification** est une méthodologie en IA qui permet de déterminer visuellement quel type d'élément on manipule. C'est de cette façon que les développeur créent des classificateurs Chats/Chiens, etc... 

![classification.drawio.png](https://bo.dev-freelance.fr/uploads/classification_drawio_71c004ed5f.png)

Nous allons entraîner un modèle qui permet de déterminer quel est le nom de la banque du relevé que l'on fourni. De manière général, c'est un procédé très simple qui consiste à mettre dans un dossier plusieurs éléments d'une même famille afin de les regrouper. Une fois le modèle d'IA entraîné, il saura de lui même, à quelle famille appartient cet élément.

Pour la classification je me sers de **Tensorflow**. Je vais créer un réseau neuronal assez classique, en 9 couches. 

## L'object detection

Ensuite, une fois que nous savons quelle est la banque concernée par le relevé, nous passons le relevé dans une autre moulinette qui va chercher à faire de l'**object detection**. Pour faire cela, nous allons utiliser un outil en **Python** qui s'appelle **LabelImg**. En gros, ça consiste à délimiter des zones et décrire ce qui s'y trouve. 

Au passage, lorsque vous installez **LabelImg**, vous constaterez peut-être quelques bugs, mais pas de panique, c'est du **Python**, il suffit d'ouvrir les fichiers et de faire des fixs à la main (simple conversion float > int).

L'outil ressemble à ça :
![labelimg-image-annotation-software.jpg](https://bo.dev-freelance.fr/uploads/labelimg_image_annotation_software_43dcd351b8.jpg)

Je vais répéter ce procédé une dizaine de fois pour marquer chacun des relevés sur les éléments suivants: **Logo**, **Information**, **Ligne**.

Une fois ces 3 éléments annotés, le **logo** pourra nous confirmer de quelle banque il s'agit, les **informations** pourront être passé à l'OCR si besoin, et les **lignes** seront aussi converties par OCR pour générer un fichier de sortie.

Pour faire la détection, j'ai utilisé la librairie **Yolo** que j'ai entrainé sur un modèle custom à partir de mes relevés marqués par **LabelImg**. Après une série de tests je réalise que le modèle fonctionne bien mieux lorsque je paramètre un nombre très grand d'**épochs** (cycle d'entrainement du modèle). 

Généralement, les **épochs** sont paramétrés à 100 sur des entraînements assez simple: détection d'humain, détection de voiture. 

Dans notre cas, nous essayons de détecter un élément écrit parmi tant d'autres et il va falloir comprendre en quoi ils sont différents. J'ai effectué des tests pendant une journée entière sur un petit nombre d'épochs et, il m'était impossible d'avoir une bonne qualité de détection en sortie. D'autant plus que les images sont redimmensionnés pendant le passage au réseaux neuronal, ce qui fera la vitesse et l'efficacité de la détection dépend énormément de la compression de l'image. Si elle est trop grande, cela demandera beaucoup trop d'effort au matériel.

Tiens, tiens ! Le matériel... parlons en ! 

Pour entraîner un modèle comme celui-ci avec comme base **Yolov8n** (n pour nano: c'est un petit modèle pré-trained qui est déjà capable de détecter des objets de la vie quotidienne comme un téléphone, un ordinateur ou autre), mon ordinateur qui possède un GPU de type RTX 3060 Ti prends 20 minutes pour passer les 2000 epochs. Et la charge ram monte à 4go sur les 8go de disponible, il ne faut donc, pas lésiner sur les moyens:

![yolo_train.png](https://bo.dev-freelance.fr/uploads/yolo_train_e5eecfc498.png)

Il reste tout de même un avantage là dedans : le modèle est immédiatement sauvegardé. Je n'aurais donc pas à repasser par cette étape si je veux le réutiliser pour lancer immédiatement la détection.

J'ai lancé la détection sur un relevé **Bred** et voici le résultat :

![detection_private.jpg](https://bo.dev-freelance.fr/uploads/detection_private_78a8a1896b.jpg)

Observez les petits décalages à gauches sur les lignes, ce n'est pas 100% parfait, mais ceci est dû au fait que je n'ai entraîné le modèle que sur une quantité réduite de documents (2 ou 3 pages, car c'est usant de faire du LabelImg). Je pense qu'avec plus de données, et plus d'épochs, je peux arriver à un résultat quasi parfait.

## Compréhension des lignes

Après détection, on peut directement demander à extraire les **matches** au format texte. Mais pas si vite, on ne peut pas passer le résultat directement à l'OCR. J'ai fait le test avec un second relevé, de chez N26 : 

![ligne_bancaire.png](https://bo.dev-freelance.fr/uploads/ligne_bancaire_4e08ca30bb.png)

Et là, nous rencontrons un problème :

![img-to-txt-tesseract.png](https://bo.dev-freelance.fr/uploads/img_to_txt_tesseract_30e836398b.png)

Vous le voyez vous aussi ? Tesseract n'arrive pas à détecter les colonnes. Dans notre cas, il s'agit d'un débit, mais comme il n'arrive pas à gérer les offsets, il faut repasser par une étape de détection, cette fois ci, beaucoup plus simple. Qui consiste à dire, pour telle banque, voici la position des colonnes. 

![label-img-ligne.png](https://bo.dev-freelance.fr/uploads/label_img_ligne_bf69b2ea86.png)

Nous pourrons ainsi, de la même façon que l'object detection de lignes, obtenir le champs dédié et faire un simple OCR sur ce champs. 

On récupère chacune des lignes dans un tableau de dict et le tour est joué, on peut en faire un **txt**, un **csv**, ou autre.

## Bilan

C'était un petit projet passionnant, j'ai adoré la phase exploratoire ou je me demandais toujours : Comment je vais procéder ? Quel outil je vais pouvoir utiliser ?

Après avoir identifié ce dont j'aurai besoin, le départ a été plutôt fastidieux car la mise en place des réseaux de neurones, la partie tweaking du réseau pour que ça fonctionne comme attendu, a été assez longue. J'ai dû y passer 2 à 3 jours. Mais au final, j'ai réussi avec aussi peu de données en entrée (entrainement) à faire un petit extracteur de mouvements pour les relevés bancaires. Je pense que si j'y passe 1 mois, j'obtiendrai quelque chose de très puissant (exploitable sous forme de SaaS j'entends).

**Python** est un langage simple et accessible, et les outils de machine learning sont légions sur ce langage. Internet regorge d'exemples et de tutos que vous pourrez suivre pour vous aussi vous y mettre. Une fois que l'on a compris quelques principes, ce n'est pas très compliqué. Si c'est un sujet qui vous intéresse depuis longtemps, mais que vous n'avez toujours pas franchi le pas, vous devriez vous y mettre.

large_premier-projet-ia.jpg

medium_premier-projet-ia.jpg

small_premier-projet-ia.jpg

thumbnail_premier-projet-ia.jpg

premier-projet-ia.jpg

Je vous parlais dernièrement de mon convertisseur de relevés bancaires pour le traitement comptable et les rapprochements. Celui-ci fonctionnait à l'aide d'exports bancaires CSV ou Excel. Qu'en est-il d'un relevé scanné fourni au format PDF ? 

Mon premier "gros" projet IA

Pour créer des mocks en **Python**, je m'appuie sur la librairie **responses** j'imagine par opposition au paquet **requests**.

```shell
pip install responses
# on n'oublie pas d'installer pytest si ce n'est pas fait
pip install pytest
```

Nous allons créer une petite lib de test qui fait des appels API, puis mettre en place les mocks pour tester cette lib. Voici l'arborescence:

```shell
.
├── libs
│   ├── resource.py
└── tests
    └── test_resource.py
```

Nous allons créer un contenu très simple pour notre lib **resource.py**:

```python
# resource.py
import requests

def get_resource(id):
  headers = {
    'Accept': 'application/json'
  }
  response = requests.get('http://localhost:3000/resource/' + id, headers=headers)
  
  if response.status_code != 200:
    raise Exception('Unable to get resource ' + id)
  
  return response.json()


def create_resource(data):
  headers = {
    'Accept': 'application/json',
    'Authorization': 'Bearer blabla' 
  }
  response = requests.post('http://localhost:3000/resource', data=data, headers=headers)

  if response.status_code != 201:
    raise Exception('Unable to get resource ' + id)
  
  return response.json()
```

Maintenant pour mettre en place nos tests, respectons les conventions de **Pytest**, nous allons créer un dossier **tests** et un fichier **test_resource.py** au sein de ce dossier:

```python
# test_resource.py
import os
import sys
import responses

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

from libs.resource import get_resource, create_resource

```

Maintenant, avant d'aller plus loin, nous allons utiliser un décorateur qui va expliquer à **responses** que nous souhaitons mettre en place dans cette fonction, l'interception des appels HTTP. Un décorateur c'est une ligne qui se positionne juste avant la déclaration de votre fonction qui viendra altérer le fonctionnement de votre fonction, sans avoir à écrire des lignes entière de code.

```python
@responses.activate
def test_get_resource():
```

Je vais ensuite déclarer la réponse du mock. C'est à dire, les données que je souhaite manipuler pendant mon test unitaire.

```python
  response_mock = {
    'username': 'Foo',
    'email': 'foo@bar.com',
    'role': 'user'
  }
```

Puis, on va déclarer dans **responses** quel appel intercepter afin de donner notre mock en réponse personnalisée en retour:

```python
responses.add(
    responses.get(
      url='http://localhost:3000/resource/3',
      json=response_mock,
      status=200,
      content_type='application/json'
    )
  )
```

Il ne reste plus qu'à déclencher l'appel et effectuer nos tests:

```python
  resource = get_resource(str(3))
  assert resource['username'] == response_mock['username']
```

Voici le fonctionnement en gros, et nous appliquons la même logique pour la partie POST. Sans vous faire languir plus longtemps, je vous met directement le fichier entier afin de vous donner une idée du résultat final.

```python
# test_resource.py
import os
import sys
import responses

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

from libs.resource import get_resource, create_resource


@responses.activate
def test_get_resource():
  response_mock = {
    'username': 'Foo',
    'email': 'foo@bar.com',
    'role': 'user'
  }

  responses.add(
    responses.get(
      url='http://localhost:3000/resource/3',
      json=response_mock,
      status=200,
      content_type='application/json'
    )
  )

  resource = get_resource(str(3))
  assert resource['username'] == response_mock['username']

@responses.activate
def test_create_resource():
  response_mock = {
    'id': '45',
    'username': 'Blah',
    'email': 'blabla@bar.com',
    'role': 'admin'
  }

  responses.add(
    responses.post(
      url='http://localhost:3000/resource',
      json=response_mock,
      status=201,
      content_type='application/json'
    )
  )

  response = create_resource({
    'username': 'Blah',
    'email': 'blabla@bar.com',
    'role': 'admin'
  })

  assert response['id'] == '45'
```

Pour lancer les tests, on utilise :

```
python3 -m pytest -s
```

C'est tout bon ! J'espère que cet article vous a été utile et qu'il vous aidera à mettre en place **vos mocks** dans vos projets **Python**. 


large_mock_python.jpg

medium_mock_python.jpg

small_mock_python.jpg

thumbnail_mock_python.jpg

mock_python.jpg

Lorsque vous codez vos tests unitaires, il arrive que vous ayez besoin que certains appels API ne se déclenchent pas. Surtout si cet API déclenche des appels impactants, suppression, paiement, etc. Cela peut être intéressant de mettre en place un mock. Voici comment procéder...

Comment créer des mocks HTTP en Python

Et oui, incroyable mais vrai, la simple installation de **yarn** sous windows n'est pas sans manipulation. 

Rien de compliqué en soit mais il se peut que même après avoir installé yarn en global sur votre machine: 

```shell
npm i -g yarn
```

Vous soyez dans l'incapacité de lancer une commande yarn et receviez en retour ce message d'erreur:

```shell
yarn.ps1 cannot be loaded because running scripts is disabled on this system. For more informations, see about_Execution_Policies at https...

+ CategoryInfo: SecurityError (:) [], PSSecurityException
+ FullyQualifiedErrorId : UnauthorizedAccess 
```

Alors qu'est-ce que c'est que ce charabia ? Tout simplement que **yarn** est incapable de se lancer sur votre machine, faute de droits.

Pour y remédier, rien de compliqué, ouvrez **windows** et tapez **powershell** puis faîtes un clic droit > exécuter en tant qu'administrateur.

![powershell_admin.jpg](https://bo.dev-freelance.fr/uploads/powershell_admin_59e7c13b60.jpg)

Une fois **powershell** ouvert, entrez ceci :

```shell
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
```

On vous demandera de confirmer avec **O**, faîtes-le. 

Voilà, désormais vous êtes en mesure d'utiliser vos commandes **yarn** sur Windows 11 sans problèmes.


large_yarn.jpg

medium_yarn.jpg

small_yarn.jpg

thumbnail_yarn.jpg

yarn.jpg

C'est de plus en plus dur de coder quelque chose sous Windows. De manière générale, je trouve que c'est plus fastidieux qu'ailleurs de faire quoique ce soit dans le dev sous Windows. Chercher des paquets à la main etc, avant l'introduction de nuget du moins. Aujourd'hui nous allons voir comment utiliser yarn (le paquet node) sous Windows.

Comment utiliser Yarn sous Windows 11

Commençons par installer le paquet qui permet d'exécuter les tests en python, j'ai nommé **pytest**

```shell
pip install pytest
```

Une fois que **pytest** est installé, vous pouvez vous lancer sans plus attendre dans l'écriture de vos tests. Je suis un fervent défenseur du TDD car coder sans anticiper l'utilisation m'a déjà causé beaucoup de soucis par le passé. Alors j'aime bien avoir une spécification des entrées et sorties écrites quelque part. Cela permet d'acter comment vous allez utiliser une fonction/méthode, etc.

Lorsque vous avez une idée sur la fonction que vous souhaitez écrire il faut se poser les questions suivantes:

- Comment vais-je me servir de cette fonction ? (par exemple: server side, client side, etc... pour poser un cadre)
- De quoi ai-je besoin, au minimum pour appeler cette fonction ? (quels paramètres sont obligatoires ? et de quel type ?)
- Y a t-il des paramètres optionnels ? (cela permettra de définir combien de scénario vous aurez à minima)
- Y a t-il plusieurs façon d'utiliser cette fonction ? (est-ce que les opérations seront différentes selon certaines conditions ? par exemple connecté ou déconnecté)

Une fois que vous avez plus ou moins une idée des réponses vous pouvez commencer l'écriture de vos tests.

Les fichiers tests doivent par convention commencer par **test_**.
Personnellement, j'aime bien séparer en différents fichiers l'écriture de tests si nous sommes dans des cas différents, par exemple: **test_lib_a_disconnected** et **test_lib_a_connected**.

Par convention, les fonctions de tests commencent aussi par **test_**
Dans chaque fichier, je ferai une fonction séparée pour tester différents paramètre de ma fonction:
**def test_access_url_a_with_token()** et **def test_access_url_a_without_token()**...

Voyez ces fonctions de tests comme les **it** en **Node.js**. Le nom de votre fonction doit définir ce que vous êtes sur le point de tester. A vous de mettre le curseur sur un groupe d'actions où de limiter le test à une micro opération, nécessitant ainsi, plusieurs tests pour pouvoir couvrir toutes les fonctionnalités, ainsi que les scénarios couverts.

J'ai créé l'arborescence suivante : 

```shell
├── libs
│   └── reader.py
└── tests
    └── test_reader.py
    └── sample.txt
 ```
 
 Pour que ce soit plus lisible, je vais commencer ici par là lib, donc nous ne faisons pas réellement du TDD, mais presque...
 Ecrivons une petite lib reader qui ne fait rien de mystique, à savoir, lire un fichier: 📄
 
 ```python
 # libs/reader.py

def read_file(filepath):
  f = open(filepath, "r")
  return f.read()

 ```
 
 Comme il s'agit d'une lib pour lire un fichier, je vais créer un petit fichier de test dans mon répertoire de tests, **sample.txt** :
 
 ```
Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, 
when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
It has survived not only five centuries, but also the leap into electronic typesetting, 
remaining essentially unchanged. 
It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, 
and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
 ```
 
Dans nos tests, nous allons importer notre lib reader, avec [la méthode que je vous ai présenté dans cet article](https://dev-freelance.fr/dev/importer-des-packages-python-depuis-des-sous-repertoires) :

```python
# tests/test_reader.py

import os
import sys
import os

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

from libs.reader import read_file

def test_reader():
  filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), './sample.txt')
  content = read_file(filepath)
  assert len(content) == 580
```

Pour lancer nos tests, il suffit de taper dans un terminal :

```shell
python3 -m pytest
```

Si jamais vous utilisez des **print** dans vos tests, il faut lancer pytest avec l'option **-s** pour que ceux-ci s'affichent, car ils sont catchés par défaut.

```shell
python3 -m pytest -s
```

Voilà c'était un article très simple et très basique mais qui permet de faire beaucoup de chose quand on s'y met. 😀

La prochaine fois nous allons voir comment créer des **mocks** avec python pour gérer les appels **HTTP Rest API** ou **JSON-RPC**, toujours dans une démarche de couverture de tests.



large_devl.jpg

medium_devl.jpg

small_devl.jpg

thumbnail_devl.jpg

devl.jpg

Pour coder efficacement, rien de plus pratique que les tests unitaires. Aussi, je recommande chaudement de les implémenter en TDD, c'est à dire faire les tests avant voire en même temps que chaque fonction, histoire d'avoir une direction, et de coder selon un plan (input/ouput).

Ecrire simplement ses tests unitaires avec Python

Lorsque vous travaillez dans un projet avec une arboresence comme celle-ci:

```shell
.
├── libs
│   ├── get_content.py
│   └── get_key.py
└── tests
    └── test_get_key.py
```

Pour importer les libs de  depuis le répertoire test, cela peut s'avérer un peu tricky. Mais voici comment procéder depuis notre fichier `test_get_key.py`:

```python
import os
import sys

# nous allons demander à Python de prendre aussi en considération les répertoires à partir du répertoire parent. 

parent_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
sys.path.append(parent_dir)

# maintenant il est possible d'importer facilement toutes les libs du répertoire parent.

from libs.get_key import read_key
```

Rien ne vous empêche de spécifier des chemins plus complexe et de les importer.

large_screen-python-resized.jpg

medium_screen-python-resized.jpg

small_screen-python-resized.jpg

thumbnail_screen-python-resized.jpg

screen-python-resized.jpg

En Python, lorsque vous devez structurer un projet, il arrive que vous ayez besoin de charger une lib dans un répertoire parent, et pour cela, il est vrai que ce n'est pas évident de les importer. Voici un petit snippet code qui pourrait vous être utile.

Importer des packages Python depuis des sous répertoires

Il n’y a pas longtemps, [je postais un article plutôt critique](https://dev-freelance.fr/news/le-problemes-des-prompts-ia) concernant les **LLM** (Large Language Model, comprenez les bots intelligents comme **ChatGPT**). Le fait est qu’en tant qu’utilisateur je trouve cet outil de moins en moins pratique car ses réponses sont de plus en plus brèves et manquent de détails. [Et je ne suis pas le seul à l’avoir constaté](https://www.tomsguide.fr/chatgpt-la-derniere-mise-a-jour-a-soigne-gpt-4-turbo-de-la-paresse/).

De même, je tenais un discours assez critique concernant **Github Copilot** étant donné que ce dernier s’appuie sur **Chatgpt**. Je disais que j’avais de gros doutes quant à son efficacité car **Chatgpt** lui même n’est pas très précis, or le code nécessite de la précision. 

Et bien, là aussi, je ne suis pas le seul à penser de la sorte. [Mes confrères de développez.com ont justement posté un article plutôt critique sur le sujet](https://intelligence-artificielle.developpez.com/actu/353321/L-utilisation-de-l-assistant-d-IA-GitHub-Copilot-pour-la-programmation-entraine-une-baisse-de-la-qualite-globale-du-code-et-une-quantite-importante-de-code-redondant-selon-une-etude/).

Je pense qu'une IA serait plus utile à faire de l’optimisation de code, de la relecture, du formatage etc… qu’à penser réellement les features. Le fait que son contenu se base sur le passé, il arrive souvent que ces outils fournissent des snippets obsolètes. De même, j’ai un regard assez critique sur ce qu’ils fournissent comme résultat. 

Open source ou pas, les projets étant très différents, ainsi que l’organisation dans les projets. Ce qui signifie qu’en termes de qualité on peut avoir tout et n’importe quoi. Par exemple, un des moteurs qui fait tourner la majorité des pages du web s’appelle **Wordpress**, et pour y avoir mis les mains, je n’ai pas une haute opinion de ce moteur: le code est mal organisé, mal structuré, brouillon… Donc si on me dit génial “je génère ton code grâce à des projets complètement claqués”, et bien j’ai plus peur du résultat qu’autre chose. 

Donc voilà je ne suis pas autant enjoué de cette situation, je préfère de loin la qualité d’un expert qu’un générateur automatique qui ne comprend pas le quart de ce qu’il fait. Et comprenez-moi bien, c’est le cas aujourd’hui. Je ne dis pas que dans dix ans, ce sera toujours une réalité, et surtout j’espère bien que non. Ce serait évidemment intéressant de collaborer avec des IA au niveau, mais pour le moment ce n'est tout simplement pas envisageable.

Encore une fois, ces limitations sont dû à la conception actuelle des modèles neuronaux. **Ces derniers font de l'apprentissage, mais ne font pas de l'expérimentation**. Ce qui signifie que leur compréhension s'arrête à ce qui a été réalisé. Créant ainsi des lacunes lorsqu'il s'agit d'être innovant en matière d'approche et d'optimisation, ce qu'arrive à faire aisément un humain.

large_code-resized.jpg

medium_code-resized.jpg

small_code-resized.jpg

thumbnail_code-resized.jpg

code-resized.jpg

A tout ceux qui souhaite aller plus vite en utilisant des générateurs de code, je pense que vous prenez un risque à utiliser ces outils. Pour le moment, ces derniers manquent de maturité et je ne suis pas le seul à l'avoir constaté.

Découvrez tous nos articles de la catégorie Dev - page 3 sur 7