Comment créer un bot et automatiser votre travail quotidien

La plupart des tâches comportent des tâches répétitives que vous pouvez automatiser, ce qui vous libère une partie de votre temps précieux. Cela fait de l'automatisation une compétence clé à acquérir.

Un petit groupe d'ingénieurs en automatisation qualifiés et d'experts du domaine peut être en mesure d'automatiser bon nombre des tâches les plus fastidieuses d'équipes entières.

Dans cet article, nous explorerons les bases de l'automatisation des flux de travail à l'aide de Python - un langage de programmation puissant et facile à apprendre. Nous utiliserons Python pour écrire un petit script d'automatisation simple et utile qui nettoiera un dossier donné et placera chaque fichier dans son dossier correspondant.

Notre objectif ne sera pas d'écrire un code parfait ou de créer des architectures idéales au début.

Nous ne construirons rien non plus d '"illégal". Au lieu de cela, nous verrons comment créer un script qui nettoie automatiquement un dossier donné et tous ses fichiers.

Table des matières

  1. Domaines d'automatisation et par où commencer
    • Automatisation simple
    • Automatisation des API publiques
    • Ingénierie inverse API
  2. Considérations éthiques de l'automatisation
  3. Création d'un script de nettoyage de répertoire
  4. Un guide complet sur la création de robots et l'automatisation de votre travail quotidien

Domaines d'automatisation et par où commencer

Commençons par définir le type d'automatisation existant.

L'art de l'automatisation s'applique à la plupart des secteurs. Pour commencer, il facilite les tâches telles que l'extraction d'adresses e-mail d'un tas de documents afin que vous puissiez faire une explosion d'e-mails. Ou des approches plus complexes telles que l'optimisation des flux de travail et des processus au sein des grandes entreprises.

Bien sûr, passer de petits scripts personnels à une grande infrastructure d'automatisation qui remplace les personnes réelles implique un processus d'apprentissage et d'amélioration. Voyons donc par où commencer votre voyage.

Automatisations simples

Des automatisations simples permettent un point d'entrée rapide et simple. Cela peut couvrir de petits processus indépendants tels que les nettoyages de projets et la restructuration de fichiers à l'intérieur de répertoires, ou des parties d'un flux de travail comme le redimensionnement automatique de fichiers déjà enregistrés.

Automatisations des API publiques

Les automatisations d'API publiques sont la forme d'automatisation la plus courante, car nous pouvons accéder à la plupart des fonctionnalités à l'aide de requêtes HTTP aux API de nos jours. Par exemple, si vous souhaitez automatiser l'arrosage de votre jardin intelligent fait maison à la maison.

Pour ce faire, vous voulez vérifier la météo du jour en cours pour voir si vous avez besoin d'arroser ou s'il y a de la pluie.

Ingénierie inverse API

L'automatisation basée sur l'ingénierie inverse d'API est plus courante dans les bots réels et dans la section "Bot Imposter" du tableau dans la section "Considérations éthiques" ci-dessous.

En procédant au reverse-engineering d'une API, nous comprenons le flux des applications des utilisateurs. Un exemple pourrait être la connexion à un jeu par navigateur en ligne.

En comprenant le processus de connexion et d'authentification, nous pouvons dupliquer ce comportement avec notre propre script. Ensuite, nous pouvons créer notre propre interface pour travailler avec l'application même s'ils ne la fournissent pas eux-mêmes.

Quelle que soit l'approche que vous visez, considérez toujours si elle est légale ou non.

Vous ne voulez pas vous causer d'ennuis, n'est-ce pas? ?

Considérations éthiques

Un gars sur GitHub m'a contacté une fois et m'a dit ceci:

«Les goûts et l'engagement sont une monnaie numérique et vous les dévalorisez.»

Cela est resté avec moi et m'a fait remettre en question l'outil que j'ai construit exactement dans ce but.

Le fait que ces interactions et l'engagement peuvent être automatisés et «falsifiés» de plus en plus conduit à un système de médias sociaux déformé et cassé.

Les personnes qui produisent un contenu précieux et de bonne qualité sont invisibles pour les autres utilisateurs et les sociétés de publicité si elles n'utilisent pas de robots et d'autres systèmes d'engagement.

Un de mes amis est venu avec l'association suivante avec «Nine Circles of Hell» de Dante où à chaque pas de plus pour devenir un influenceur social, vous devenez de moins en moins conscient de la rupture de tout ce système.

Je veux partager cela avec vous ici car je pense que c'est une représentation extrêmement précise de ce dont j'ai été témoin en travaillant activement avec des influenceurs avec InstaPy.

Niveau 1: Limbo - Si vous ne bottez pas du tout

Niveau 2: Flirt - Lorsque vous aimez et suivez manuellement autant de personnes que vous pouvez pour les amener à vous suivre / aimer vos messages

Niveau 3: Conspiration - lorsque vous rejoignez un groupe Telegram pour aimer et commenter 10 photos afin que les 10 prochaines personnes aiment et commentent votre photo

Niveau 4: Infidélité - Lorsque vous utilisez un assistant virtuel à faible coût pour aimer et suivre en votre nom

Niveau 5: Lust - Lorsque vous utilisez un bot pour donner des likes et que vous ne recevez aucun likes en retour (mais vous ne payez pas pour cela - par exemple, une extension Chrome)

Niveau 6: Promiscuité - Lorsque vous utilisez un bot pour donner 50+ likes à 50+ likes, mais que vous ne payez pas pour cela - par exemple, une extension Chrome

Niveau 7: Avarice ou Extreme Greed - Lorsque vous utilisez un bot pour aimer / suivre / commenter entre 200 et 700 photos, en ignorant les chances d'être banni

Niveau 8: Prostitution - Lorsque vous payez un service tiers inconnu pour vous engager dans des likes / suivis réciproques automatisés pour vous, mais qu'ils utilisent votre compte pour aimer / suivre

Niveau 9: Fraude / Hérésie - Lorsque vous achetez des followers et des likes et que vous essayez de vous vendre à des marques en tant qu'influenceur

Le niveau de bottage sur les réseaux sociaux est si répandu que si vous ne bottez pas, vous serez coincé au niveau 1, Limbo , sans croissance de suiveurs et faible engagement par rapport à vos pairs.

En théorie économique, c'est ce qu'on appelle le dilemme du prisonnier et le jeu à somme nulle . Si je ne bot et vous bot, vous gagnez. Si vous ne bottez pas et que je bot, je gagne. Si personne ne botte, tout le monde gagne. Mais comme il n'y a pas d'incitation pour tout le monde à ne pas botter, tout le monde bote, donc personne ne gagne.

Soyez conscient de cela et n'oubliez jamais les implications de tout cet outil sur les réseaux sociaux.

Nous voulons éviter de traiter des implications éthiques et continuer à travailler sur un projet d'automatisation ici. C'est pourquoi nous allons créer un simple script de nettoyage de répertoire qui vous aide à organiser vos dossiers en désordre.

Création d'un script de nettoyage de répertoire

Nous voulons maintenant examiner un script assez simple. Il nettoie automatiquement un répertoire donné en déplaçant ces fichiers dans des dossiers en fonction de l'extension de fichier.

Donc, tout ce que nous voulons faire est ceci:

Configuration de l'analyseur d'arguments

Since we are working with operating system functionality like moving files, we need to import the os library. In addition to that, we want to give the user some control over what folder is cleaned up. We will use the argparse library for this.

import os import argparse

After importing the two libraries, let's first set up the argument parser. Make sure to give a description and a help text to each added argument to give valuable help to the user when they type --help.

Our argument will be named --path. The double dashes in front of the name tell the library that this is an optional argument. By default we want to use the current directory, so set the default value to be ".".

parser = argparse.ArgumentParser( description="Clean up directory and put files into according folders." ) parser.add_argument( "--path", type=str, default=".", help="Directory path of the to be cleaned directory", ) # parse the arguments given by the user and extract the path args = parser.parse_args() path = args.path print(f"Cleaning up directory {path}")

This already finishes the argument parsing section – it's quite simple and readable, right?

Let's execute our script and check for errors.

python directory_clean.py --path ./test => Cleaning up directory ./test

Once executed, we can see the directory name being printed to the console, perfect.

Let's now use the os library to get the files of the given path.

Getting a list of files from the folder

By using the os.listdir(path) method and providing it a valid path, we get a list of all the files and folders inside of that directory.

After listing all elements in the folder, we want to differentiate between files and folders since we don't want to clean up the folders, only the files.

In this case, we use a Python list comprehension to iterate through all the elements and put them into the new lists if they meet the given requirement of being a file or folder.

# get all files from given directory dir_content = os.listdir(path) # create a relative path from the path to the file and the document name path_dir_content = [os.path.join(path, doc) for doc in dir_content] # filter our directory content into a documents and folders list docs = [doc for doc in path_dir_content if os.path.isfile(doc)] folders = [folder for folder in path_dir_content if os.path.isdir(folder)] # counter to keep track of amount of moved files # and list of already created folders to avoid multiple creations moved = 0 created_folders = [] print(f"Cleaning up {len(docs)} of {len(dir_content)} elements.")

As always, let's make sure that our users get feedback. So add a print statement that gives the user an indication about how many files will be moved.

python directory_clean.py --path ./test => Cleaning up directory ./test => Cleaning up 60 of 60 elements.

After re-executing the python script, we can now see that the /test folder I created contains 60 files that will be moved.

Creating a folder for every file extension

The next and more important step now is to create the folder for each of the file extensions. We want to do this by going through all of our filtered files and if they have an extension for which there is no folder already, create one.

The os library helps us with more nice functionality like the splitting of the filetype and path of a given document, extracting the path itself and name of the document.  

# go through all files and move them into according folders for doc in docs: # separte name from file extension full_doc_path, filetype = os.path.splitext(doc) doc_path = os.path.dirname(full_doc_path) doc_name = os.path.basename(full_doc_path) print(filetype) print(full_doc_path) print(doc_path) print(doc_name) break

The break statement at the end of the code above makes sure that our terminal does not get spammed if our directory contains dozens of files.

Once we've set this up, let's execute our script to see an output similar to this:

python directory_clean.py --path ./test => ... => .pdf => ./test/test17 => ./test => test17

We can now see that the implementation above splits off the filetype and then extracts the parts from the full path.

Since we have the filetype now, we can check if a folder with the name of this type already exists.

Before we do that, we want to make sure to skip a few files. If we use the current directory "." as the path, we need to avoid moving the python script itself. A simple if condition takes care of that.

In addition to that, we don't want to move Hidden Files, so let's also include all files that start with a dot. The .DS_Store file on macOS is an example of a hidden file.

 # skip this file when it is in the directory if doc_name == "directory_clean" or doc_name.startswith('.'): continue # get the subfolder name and create folder if not exist subfolder_path = os.path.join(path, filetype[1:].lower()) if subfolder_path not in folders: # create the folder

Once we've taken care of the python script and hidden files, we can now move on to creating the folders on the system.

In addition to our check, if the folder already was there when we read the content of the directory, in the beginning, we need a way to track the folders we've already created. That was the reason we declared the created_folders = [] list. It will serve as the memory to track the names of folders.

To create a new folder, the os library provides a method called os.mkdir(folder_path) that takes a path and creates a folder with the given name there.

This method may throw an exception, telling us that the folder already exists. So let's also make sure to catch that error.

if subfolder_path not in folders and subfolder_path not in created_folders: try: os.mkdir(subfolder_path) created_folders.append(subfolder_path) print(f"Folder {subfolder_path} created.") except FileExistsError as err: print(f"Folder already exists at {subfolder_path}... {err}")

After setting up the folder creation, let's re-execute our script.

python directory_clean.py --path ./test => ... => Folder ./test/pdf created.

On the first run of execution, we can see a list of logs telling us that the folders with the given types of file extensions have been created.

Moving each file into the right subfolder

The last step now is to actually move the files into their new parent folders.

An important thing to understand when working with os operations is that sometimes operations can not be undone. This is, for example, the case with deletion. So it makes sense to first only log out the behavior our script would achieve if we execute it.

This is why the os.rename(...) method has been commented here.

# get the new folder path and move the file new_doc_path = os.path.join(subfolder_path, doc_name) + filetype # os.rename(doc, new_doc_path) moved += 1 print(f"Moved file {doc} to {new_doc_path}")

After executing our script and seeing the correct logging, we can now remove the comment hash before our os.rename() method and give it a final go.

# get the new folder path and move the file new_doc_path = os.path.join(subfolder_path, doc_name) + filetype os.rename(doc, new_doc_path) moved += 1 print(f"Moved file {doc} to {new_doc_path}") print(f"Renamed {moved} of {len(docs)} files.")
python directory_clean.py --path ./test => ... => Moved file ./test/test17.pdf to ./test/pdf/test17.pdf => ... => Renamed 60 of 60 files.

This final execution will now move all the files into their appropriate folders and our directory will be nicely cleaned up without the need for manual actions.

In the next step, we could now use the script we created above and, for example, schedule it to execute every Monday to clean up our Downloads folder for more structure.

That is exactly what we are creating as a follow-up inside of our Bot Creation and Workflow Automation Udemy course.

A Complete Guide to Bot Creation and Automating Your Everyday Work

Felix and I built an online video course to teach you how to create your own bots based on what we've learned building InstaPy and his Travian-Bot. In fact, he was even forced to take down since it was too effective.

Join right in and start learning.

If you have any questions or feedback, feel free to reach out to us on Twitter or directly in the discussion section of the course ?