## Les diplômes 

Pendant mon parcours professionnel, j'ai déjà eu à faire à plusieurs personnes qui ont carrément menti sur leur CV. 

Sur papier, ils avaient fait telle école etc... Mais c'est là où j'attire votre attention. Ayant été moi même recruteur, je me suis trouvé dans une position où j'ai eu à évaluer un document sur lequel, un individu retrace son parcours.

Naïvement, j'ai toujours fait confiance pensant que tout le monde était de bonne foi. Et bien c'est archi faux !

Faîtes, bien attention aux mots employés sur papier. **Faire telle école, ne signifie pas être diplomé de telle école**. Car les gens vont vraiment loin dans cette "triche". Ils jouent volontairement sur les mots pour ne pas avouer ou dire qu'ils ne sont pas allé au bout. Ce qui me gêne un peu plus, c'est qu'elles vous diront qu'elles ont été de bonne foi en ne mentionnant pas le fait d'être diplômé.

## En quoi est-ce important ?

Je pars du principe que quelqu'un qui commence une collaboration sur la base d'un non dit ou d'un mensonge (les deux cherchant uniquement à cacher la vérité, donc, à mes yeux, c'est la même chose), ne mérite pas ma confiance. On ne commence pas une relation professionnelle ou personnelle sur une base de mensonge. 

Bonjour, je suis champion du monde de Karaté, je suis patron d'une licorne, j'ai créé tel produit. 

Ok, le jour où la vérité s'apprend, ça nous amène où ?

Et personnellement, je suis honnête avec les gens, j'aimerais que les gens le soient en retour. Ca me perturberait fortement de savoir que l'on m'a caché la vérité sur tel ou tel sujet, aussi anodin soit-il. Si vous avez besoin de mentir sur un sujet, autant ne pas aborder ce sujet. 

## Que s'est-il passé pour le menteur ?

A chaque fois qu'il m'est arrivé de croiser un usurpateur dans ma vie professionnelle, il a été rapidement renvoyé !

Chez Webedia, à l'époque, on avait reçu dans notre équipe un nouveau qui disait avoir fait **Epitech**, une très bonne école d'ingénieur. Il ne s'était pas attardé sur le fait qu'il n'était pas allé au diplôme. Or, il a postulé pour un poste, en demandant un salaire d'entré équivalent à une personne diplômée. 

Je n'ai aucun problème avec cette demande, mais j'aimerais que la personne soit honnête. Vous êtes libre de penser que vous avez une valeur précise sur le marché, mais pour cela, il faut aussi vous mettre à l'épreuve. Tout comme ceux qui ont fait ces écoles, ont eu dans leur parcours scolaire, des évaluations concernant leurs connaissances. 

En revanche, si vous cachez la vérité, non seulement, vous cachez probablement que vous n'avez pas la capacité technique, de même, vous vous exposez aussi à des sanctions très graves.

## Le problème du mensonge

Dans d'autres expériences professionnelles, j'ai croisé des élèves qui disaient avoir fait l'**école 42**. Je pense énormément de bien de cette école, connaissant le mode de fonctionnement, je valide cette méthodologie. Apprendre à la dur et seul, c'est la méthodo que j'ai moi même employé pour commencer le dev quand j'étais petit.

En revanche, à chaque fois que j'ai eu à faire à un élève qui omettait ne pas avoir fini son parcours scolaire, **j'ai eu de très mauvaises surprises**. 

Lorsque je collaborais avec eux, je ne pouvais pas m'empêcher de remarquer les énormes lacunes en algorithmie... 

Après, il ne faut jamais juger trop vite, tout le monde a le droit de ne pas savoir et de s'améliorer. Moi y compris, je n'ai pas la science infuse. Mais, ces individus dont je vous parle partent de vraiment très loin. Trop loin, surtout si l'on doit passer du temps à les former.

## Au delà du CV, ils mentent aussi sur leurs compétences

Vous avez déjà eu un collègue qui dit qu'il sait tout faire, et qui a toujours une solution instinctive à tout, sans jamais y réfléchir avant ? 

Le profil même d'un bon dev, c'est quelqu'un qui réévalue toujours la situation. Car bien qu'ayant solutionné tel ou tel problème par le passé. Je me poserai toujours la question aujourd'hui, si je devais refaire la même chose, de savoir s'il n'y a pas plus optimisé comme approche.

Avec le temps, j'ai fini par comprendre qu'il y a plusieurs façons de savoir si un candidat est en train de vous rouler dans la farine. 

- Lorsqu'il est repousse toujours une implémentation pour cause d'indécision sur le choix technique à faire
- Lorsqu'il emploi des termes beaucoup trop techniques pour parler d'un problème pourtant très simple
- Lorsqu'il vous dit toujours qu'il a besoin de comprendre exactement le fonctionnement de tout, car cela "l'empêche" de mener à bien sa tâche, et y passe des semaines
- Lorsqu'il vous dit à chaque fois que l'on peut "mieux" faire sans jamais réaliser l'implémentation lui même
- Lorsqu'il vous parle d'une expérience passée où il a mis tel outil en place, mais toujours en restant très vague sur chacun des sujets
- Lorsqu'il ne veut pas vous montrer le bout de code qu'il est en train de produire parce qu'il "n'est pas terminé"
- Lorsqu'il semble lui même persuadé qu'il a fait quelque chose d'incroyable sur des sujets pourtant primaires

J'ai réellement connu des gens comme ça ☝️

Avec le temps, j'ai de plus en plus de mal à supporter ces individus. Peut-être qu'avec l'age, l'expérience, j'ai appris à accepter cette partie de moi, qui n'a pas le temps avec les bullshiters. Alors je n'irai pas jusqu'au conflit avec ces personnes. Ne perdons pas de temps, du moins, si ce n'est pas moi qui ai fait le recrutement, ce n'est pas mon problème, je les mets de côté et me concentre sur mes objectifs. 

Mais j'espère que ces quelques lignes vous permettront de mettre en place des filtres qui identifient les éléments qui pourrissent notre société actuelle, nos entreprises et notre performance. Car, dans les faits, ces personnes ne produisent rien ou trop peu. Je pense que sincèrement qu'un meilleur recrutement, rendrait notre pays et nos entreprises beaucoup plus compétitives.

large_fake-cv.jpg

medium_fake-cv.jpg

small_fake-cv.jpg

thumbnail_fake-cv.jpg

fake-cv.jpg

D'expérience, il m'est arrivé tellement de fois dans le milieu professionnel d'avoir à faire à des menteurs, sur leur CV, leur parcours, leur expérience. Mentir ou sur-vendre quelque chose qui dans les faits n'est pas la réalité, ne fait pas bon ménage avec le travail.

Les gens mentent sur leurs cv 😡

## 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

## Une application lourde

Pour de nombreux développeurs **Javascript** (ou **Typescript**), faire une application lourde rime avec **Electron**. Pour les autres, **Electron** est un toolkit qui permet de générer une app JS qui propose une interface **HTML**. Vous pouvez donc créer une interface pour vos applications sans obliger qui que ce soit à travailler sous un terminal. Surtout lorsque votre application est destinée à un utilisateur lambda (non dev).

Je vous invite directement à vous rendre sur [la page d'Electron](https://www.electronjs.org/) pour en savoir plus sur cette technologie.

## Pourquoi faire une app client-side ?

Alors avant d'expliquer le pourquoi, je vais vous faire un petit topo de qu'est-ce qui est attendu. Pour faire très simple : on veut transformer un fichier **Excel** ou **CSV** fourni par une banque, en un format **Excel** spécifique avec des colonnes préformatées, attendu par le logiciel comptable. Rien de très compliqué en soit, vous me direz, mais figurez vous qu'à ce jour, il y a encore beaucoup de sociétés qui font ces traitements manuellement. Soit en faisant absolument tout à la main, soit via quelque chose de plus évolué comme des formules **Excel**.

Maintenant, pourquoi ai-je choisi de faire une application sans mettre en place tout un système d'API ?

J'aurais bien pu faire une application serveur qui expose des endpoint d'upload de fichier, puis faire les traitements serveur side et dans ce cas, on n'aurait pas eu à installer quoique ce soit sur les machines. On serait en mesure de fournir une url aux comptables pour qu'ils puissent convertir facilement leur fichier.

Cependant, il y a plusieurs problèmes là dedans:

- D'un côté, il peut y avoir des coupures d'internet imprévisible, mais celles-ci ne doivent en aucun cas empêcher la productivité
- D'un autre côté travailler sur un produit avec une API, une interface web, une gestion de services est plus long à coder, donc je mettrai plus de temps à livrer quelque chose.

En optant pour une application Electron, j'ai fait le choix de ne pas gérer de réseau. Sur la machine de l'utilisateur, j'ai directement accès à son filesystem, donc je peux lire et écrire. Je n'ai pas à gérer l'upload (souvent problématique avec les tailles limites, le stream etc...). 

Le seul point "négatif" là dedans, c'est que les évolutions de l'application se feront forcément manuellement, en mettant à jour l'application. 

## Ca ressemble à quoi ?

C'est pas l'application la plus belle du monde, mais ça a le mérite d'être fonctionnel 😂 :

![Convertisseur Bancaire](https://bo.dev-freelance.fr/uploads/bank_converter_fa1ea79a59.png) 

L'utilisateur choisi sont fichier d'entrée, le type ainsi que la banque, il peut spécifier certaines options, et cela génère automatiquement un fichier de sortie séparé (pour ne pas écraser le fichier en entrée).

Pour le coup, je n'étais pas à ma version d'essai. J'ai déjà créé ce genre d'outil, notamment en 2013 lorsque je travaillais pour un groupe d'entreprise qui rassemblait la comptabilité de toutes ses sociétés sur une seule plateforme comptable (**Isa Compta**).

La seule petite différence c'est que **Isa Compta** utilisait des fichier tabulés, et pour mon convertisseur actuel qui utilise **Coala**, il s'agit d'un séparateur point-virgule. 

Et dans l'approche, je n'ai pas fait exactement là même chose. Pour **Isa Compta** j'avais créé un moteur plus bas niveau (meta-language) sur une base de C#, qui permettait d'interprêter dynamiquement une config en entrée et avait un comportement sur mesure et paramétrable. Pour **Coala** j'ai décidé de faire un convertisseur simple avec une configuration en entrée par type de fichier d'input. C'est à dire que la mise à jour passera par du code et pas par de la config comme c'était le cas avant.  Au moins, j'ai pu boucler ce projet plus rapidement grâce à cette approche. 

En 2019, j'optais aussi pour une approche similaire à ce convertisseur bancaire chez **Webedia** pour faire du traitement automatique sur les paiements des influenceurs **Youtube**. A l'époque, j'étais **Lead Developer** sur un projet qui s'appellait **Melberries** (en charge du paiement des talents web). Il s'agissait de faire la répartition automatique et équitable par rapport au nombre de vue, des révenus générés par **Youtube**.  Les utilisateurs de cette solutions passaient alors à quelques minutes au lieu de plusieurs jours de traitement des paiements.

C'est le genre de projet qui me plait, car c'est un projet qui peut voir le jour rapidement, sur lequel on peut observer des résultats et qui est utile pour l'utilisateur de cette solution. 

Pour ma part, j'aime savoir que mes applications sont utiles 😊, nous ne codons pas uniquement pour notre plaisir personnel.
La prochaine fois, je parlerai d'une approche avec IA pour convertir un export comptable scanné en **PDF** au lieu d'un **CSV** ou **Excel**.

large_convertisseur_bancaire.jpg

medium_convertisseur_bancaire.jpg

small_convertisseur_bancaire.jpg

thumbnail_convertisseur_bancaire.jpg

convertisseur_bancaire.jpg

Dernièrement je bossais sur un convertisseur de relevés bancaires, qui permet de générer des fichiers au format attendu par le logiciel comptable. Afin d'optimiser au mieux cette conversion, j'ai opté pour une application full client-side afin de ne pas avoir à gérer le réseau, l'API et le stockage de fichier.

Je crée un convertisseur de relevés bancaires pour un expert comptable

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é.

Github Copilot, pas si intéressant après tout

On le sait, la période est difficile en ce moment pour chercher du travail, enfin… plutôt pour le conserver ! 

Les vagues de licenciement comme pour ne rien changer dans notre industrie, sont légions.

Pour vous donner une idée (visible partout sur le net) :

- Riot Games: 530 personnes
- [Ebay: 1000 personnes](https://next.ink/brief_article/les-licenciements-continuent-1-000-postes-chez-ebay-530-chez-riot-games-et-60-chez-tiktok/)
- TikTok: 60 personnes
- Youtube: 100 personnes
- Google: 1000 personnes
- Amazon: 30 personnes 
- [SAP: 8000 personnes (une hécatombe dû à l’IA…)](https://www.usine-digitale.fr/article/sap-va-supprimer-8000-emplois-supplementaires.N2206958)
- [Tripadvisor: 125 personnes](https://skift.com/2023/11/12/tripadvisor-laid-off-4-of-its-workforce-and-more-cuts-are-on-the-way/)

Et même chez de plus petites compagnies, on le sait, les licenciements s’accélèrent. 
Sans chercher de coupable dans le capitalisme, ou l’IA, ou je ne sais quel motif, je pense tout simplement, la recherche de stabilité et de rentabilité, qui reste l’objectif de chacune des entreprises.

Alors oui le procédé peut paraître indécent, violent, injuste et ça l’est. Mais honnêtement, on le sait que cela peut arriver, et il faut être fou pour ne pas l’envisager. **J’espère que de votre côté vous ne pensez pas votre emploi est immuable et que vous êtes intouchable, car l’histoire a prouvé mainte et mainte fois le contraire.**

Pour ma part, je me suis lancé dans le freelancing, fort de cette constatation: **le CDI ne protège pas du chômage**. 
Je sais que beaucoup de gens pensent le contraire, et je dois reconnaître qu’il y a des avantages au CDI:
- les congés payés
- les congés maternité
- la mutuelle
- l’accès aux prêts
- accès aux assedic

Mais dans cette liste, ne figure absolument pas la conservation de son emploi.

Donc je me suis dit, tout naturellement, étant donné que rien ne protège l’emploi, autant être plus à même de décider de comment je dispose de mon temps, de quel projet j’ai envie de coder, et à combien j’estime que cette prestation vaut le coup d’être réalisée.

Il se trouve que lorsque l’on sait programmer, effectivement on peut aller dans à peu près toutes les directions en termes de réalisation. Je sais qu’il y a le fameux complexe du Dieu vivant pour tous les développeurs qui ont pris le melon, mais je parle ici de quelque chose de bien concret et faisable. 

Lorsque vous savez coder, vous pouvez à priori, faire n’importe quel programme. Du système, du bas niveau, de l’IOT, du hack, de l’IA, peu importe le sujet, tout est à portée de main. Donc je dois avouer, qu’étant donné que je peux apprendre et maîtriser tous les sujets qui m’intéressent, j’ai vraiment bien choisi ma profession et non je n’ai pas peur d’être remplacé par l’IA.

Pour plusieurs raisons, l’IA, comme on la connaît actuellement, est non seulement un modèle imparfait basé sur l’expérience produite. **Selon moi, la seule IA qui vaut la peine d’être apprivoisée et qui serait potentiellement intéressante pour accompagner un vrai développeur, serait un modèle qui a la capacité à penser différemment, à proposer des optimisations et des innovations. Non pas un modèle qui va se baser sur l’existant et le passé.**

### Pourquoi faut-il penser différemment ?

A chaque fois que le monde a connu des transformations majeures, ces transformations ont eu lieu parce que le modèle de pensée a été brisé vers une optimisation jusqu’à présent impensable. 
Par exemple, on est passé des chevaux à la voiture, on est passé de la voiture à l’avion, du charbon à l’essence, etc…

Et tant que l’IA ne fera pas ce genre de pivot que l’on appelle une disruption, (traduisons ici pour **“casser un schéma de pensée”**), et bien l’IA sera pour moi, extrêmement imparfaite, et ne servira qu’à faire automatiquement des choses que l’on connaît et que l’on maîtrise.

Soyons honnête, à quand pourrons-nous déléguer la recherche à l’IA ? A quand pourrons-nous confier un sujet majeur de société à l’IA ? En toute honnêteté, pas demain, ni dans dix ans.

Donc c’est triste mais c’est vrai: les seuls boulots aujourd’hui remplaçables par l’IA, sont des boulots où l’on va répéter un schéma existant, très proche de ce que l’on pourrait qualifier de travail à la chaîne. (Sans vouloir offenser qui que ce soit)

Je sais que dans ces professions, certains employés sont très impliqués, qu’ils travaillent dur, qu’ils font des heures supplémentaires, et peut être même qu’ils sont meilleurs que leurs confrères lorsqu’on les compare. Mais une IA, c’est aussi un travail H24, avec un risque infime d’erreur, ainsi qu'une capacité à toujours traiter plus et plus rapidement (avec la puissance des machines qui évolue)... 

### Peut-on lutter ?

Bien sûr ! Devenons créatifs ! Devenons ceux qui sont à l’origine de grands changements, recherchons la perfection et menons à bien nos objectifs, pensons à comment nous pourrions optimiser, faire mieux, faire plus et théorisons tout cela afin que cela n’impacte pas que vous, votre boite, mais toute votre industrie.

large_office_resized.jpg

medium_office_resized.jpg

small_office_resized.jpg

thumbnail_office_resized.jpg

office_resized.jpg

Avec les suppressions de postes à tout va, le monde de la tech est frappée de plein fouet par le chômage. Est-ce qu'on est tous fichus ? Comment contrecarrer ce sombre destin que semble nous dépeindre la presse ? 

Découvrez tous nos articles - page 3 sur 8