add init of rest api python course

.gitignore

@@ -0,0 +1 @@
+geany/

docs/cours/index.md

@@ -0,0 +1,5 @@
+# Introduction
+
+Les cours du Garage concernent:
+
+- [La présentation de l'association](presentation-garage)

docs/cours/presentation-garage/index.md

@@ -0,0 +1,3 @@
+# Présentation du Garage Numérique
+
+Ces documents présentent le fonctionnement de l'association.

docs/cours/python/1_workspace.md

@@ -1,203 +0,0 @@
-# Configurer l'espace de travail
-
-## Installer python
-
-Python est peut-être déjà installé sur votre système, mais il faut vérifier la version:
-
-```
-user@host:~$ python --version
-Python 3.7.3
-```
-
-et la liste des versions disponibles:
-
-```
-user@host:~$ update-alternatives --list python
-/usr/bin/python2
-/usr/bin/python3
-```
-
-Pour installer la version qui vous manque:
-```
-sudo apt install python2
-# OU
-sudo apt install python3
-```
-
-Nous avons besoin du numéro de version pour python2 et python3:
-```
-user@host:~$ ls -l /usr/bin/python{2,3}
-lrwxrwxrwx 1 root root 9 mars   4  2019 /usr/bin/python2 -> python2.7
-lrwxrwxrwx 1 root root 9 mars  26  2019 /usr/bin/python3 -> python3.7
-```
-
-Nous allons donner la priorité 1 à python2 et la priorité 2 à python3:
-
-```
-sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 2
-sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
-```
-
----
-
-## Installer pip
-
-pip (Package installer for python or "Pip Installs Packages") est un outil très utile pour gérer les dépendances dans un projet python.
-
-Là aussi, il y a pip pou python2 et pip pour python3, mais Debian utilisera la version correpondante à la version de python définie avec `update-alternatives`.
-
-```
-user@host:~$  sudo apt install python3-pip python-pip
-user@host:~$  pip --version
-pip 18.1 from /usr/lib/python3/dist-packages/pip (python 3.7)
-```
-
----
-
-## Utiliser la console python
-
-Pour découvrir python, rien de plus simple, on saisit la commande `python` dans le terminal:
-
-```
-user@host:~$ python
-Python 3.7.3 (default, Dec 20 2019, 18:57:59) 
-[GCC 8.3.0] on linux
-Type "help", "copyright", "credits" or "license" for more information.
->>> 
-```
-Les trois chevrons `>>>` vous indiquent que vous êtes dans la console python.  
-Faites ++ctrl+d++ pour en sortir.
-
-Vous pouvez déclarer une variable, la transformer et l'afficher:
-
-```
->>> MA_VARIABLE = " ceci est le contenu de ma variable "
->>>
->>> print(MA_VARIABLE)
- ceci est le contenu de ma variable 
->>> 
->>> VAR_2 = MA_VARIABLE + " et celle-ci est plus longue"
->>> 
->>> print(VAR_2)
- ceci est le contenu de ma variable  et celle-ci est plus longue
-```
-
----
-
-
-## Commencer un projet
-
-On démarre un projet simplement en créant un dossier, dans lequel (par convention), on crée le fichier `main.py`
-```
-user@host:~$  mkdir mon_projet && cd mon_projet && touch main.py
-```
-
-Ce fichier main.py contiendra les instructions principales du programme, et pourra appeler d'autres fichiers python.
-
-On met un **shebang** en 1ère ligne pour indiquer la version de python:
-```
-#!/usr/bin/env python3
-
-VAR_1 = " ce serpent "
-print(VAR_2)
-VAR_2 = VAR_1 + " est dangereux"
-print(VAR_2)
-```
-
-On peut simplement exécuter ce script avec `python poi.py` ou l'exécuter en mode **interactif** (-i) pour continuer à manipuler les variables et les fonctions du programme:
-
-``` 
-user@host:~$ python -i poi.py 
- ce serpent 
- ce serpent est dangereux
->>> 
->>>  type(VAR_2)
-<class 'str'>
-```
-
----
-
-## Les types de variables dans python
-
-### Les chaînes de caractères
-
-Les variables que nous avons utilisées sont du type `str` ou `string`, c'est à-dire une **chaîne de caractères**.
-On les déclare entre guillemets:
-
-```
->>> VAR_A = " some random string, with 6 words"
->>> type(VAR_A)
-<class 'str'>
-```
-
-### Autres variables simples
-
-Il y a d'autre variables simples: 
-
-```
->>> VAR_B=True
->>> type(VAR_B)
-<class 'bool'>    # VAR_B est un `boolean`, une valeur booléenne, \
-		  	# qui ne peut être que `True` ou `False`
-
->>> VAR_C = 10
->>> type(VAR_C)
-<class 'int'>       # VAR_C est un `integer`, un nombre entier
->>> 
->>> 
->>> VAR_D=3.141592
->>> type(VAR_E)
-<class 'float'>     # VAR_E est un `float`, un nombre décimal
-```
-
-### Les listes et les tuples
-
-Il y a des variables qui permettent de stocker plusieurs valeurs: les **listes** ( `list`), les **tuples**, et les **dictionnaires** (`dictionary`).
-
-Les listes sont déclarées entre crochets ( `brackets [ ] `) et contiennent plusieurs éléments (int, str, list...) séparés par une virgule.
-
-```
->>> VAR_F = ["object",150,"proc","package",2000]
->>> type(VAR_F)
-<class 'list'>
-```
-
-On peut modifier les éléments de la liste en les indexant entre crochets:
-
-```
->>> print(VAR_F[0:2])
-['object', 150]
->>> 
->>> VAR_F[1] = 250
->>> print(VAR_F[0:2])
-['object', 250]
-```
-
-Les **tuples** sont des listes qu'on ne peut pas modifier. On les appelle entre parenthèses:
-```
->>> VAR_F = ( "elem1", "elem2", "elem3")
->>> 
->>> print(type(VAR_F))
-<class 'tuple'>
-```
-
-### Les dictionnaires
-
-Les dictionnaires sont des séries de paires clé-valeur, déclarées entre accolades ( `curly brackets { } `)
-
-```
->>> VAR_G = { "name": "python", "version_number": 3.8, "use": "coding"}
->>> type(VAR_G)
-<class 'dict'>
-```
-
-Comme pour les listes, on peut accéder aux valeurs et les modifier en indexant avec les crochets:
-```
->>> VAR_G["use"] = VAR_G["use"] + " and playing"
->>> 
->>> print(VAR_G)
-{'name': 'python', 'version': '3.8', 'version_number': 3.8, 'use': 'coding and playing'}
-```
-
-
-

docs/cours/python/1stproject.md

@@ -0,0 +1,142 @@
+# Démarrer un projet
+
+## Création du projet
+
+??? important "Note importante pour les étudiants"
+	Ne créez pas un nouveau dossier, 
+	1. clonez plutôt le projet d'évaluation 
+	2. basculez sur la branche start
+	3. Créez une nouvelle branche nommée `start-votre-id-gitlab`
+	```
+	git clone https://gitlab.com/devopsp1/python-webscrap.git`  
+	cd python-webscrap
+	git checkout start
+	git checkout -b start-mon-id-gitlab
+	```
+
+On démarre un projet simplement en créant un dossier, dans lequel (par convention), on crée le fichier `main.py`
+
+```
+user@host:~$  mkdir mon_projet && cd mon_projet && touch main.py
+```
+
+Ce fichier main.py contiendra les instructions principales du programme, et pourra appeler d'autres fichiers python.
+
+On met un **shebang** en 1ère ligne pour indiquer la version de python.
+
+Dans ce script on déclare deux variables, qu'on nomme `base_url`et `endpoint1`, auxquelles on donne une valeur.
+
+```
+#!/usr/bin/env python3
+
+base_url = "https://gitlab.com/api/v4"
+print(base_url)
+endpoint1 = base_url + "/groups"
+print(endpoint1)
+```
+
+On peut simplement exécuter ce script avec `python poi.py` ou l'exécuter en mode **interactif** (-i) pour continuer à manipuler les variables et les fonctions du programme:
+
+``` 
+user@host:~$  python -i main.py 
+https://gitlab.com/api/v4
+https://gitlab.com/api/v4/groups
+>>> 
+>>> type(endpoint1)
+<class 'str'>
+
+```
+La fonction `type` nous affiche le type de variable utilisé: il s'agit d'une chaîne de caractères (`str`)
+
+
+
+---
+
+
+
+## Les types de variables dans python
+
+### Les chaînes de caractères
+
+Les variables que nous avons utilisées sont du type `str` ou `string`, c'est à-dire une **chaîne de caractères**.
+On les déclare entre guillemets:
+
+```
+>>> VAR_A = " some random string, with 6 words"
+>>> type(VAR_A)
+<class 'str'>
+```
+
+### Autres variables simples
+
+Il y a d'autre variables simples: 
+
+```
+>>> VAR_B=True
+>>> type(VAR_B)
+<class 'bool'>    # VAR_B est un `boolean`, une valeur booléenne, \
+		  	# qui ne peut être que `True` ou `False`
+
+>>> VAR_C = 10
+>>> type(VAR_C)
+<class 'int'>       # VAR_C est un `integer`, un nombre entier
+>>> 
+>>> 
+>>> VAR_D=3.141592
+>>> type(VAR_E)
+<class 'float'>     # VAR_E est un `float`, un nombre décimal
+```
+
+### Les listes et les tuples
+
+Il y a des variables qui permettent de stocker plusieurs valeurs: les **listes** ( `list`), les **tuples**, et les **dictionnaires** (`dictionary`).
+
+Les listes sont déclarées entre crochets ( `brackets [ ] `) et contiennent plusieurs éléments (int, str, list...) séparés par une virgule.
+
+```
+>>> VAR_F = ["object",  150,  "proc",  "package",  2000]
+>>> type(VAR_F)
+<class 'list'>
+```
+
+On peut modifier les éléments de la liste en les indexant entre crochets:
+
+```
+>>> print(VAR_F[0:2])
+['object', 150]
+>>> 
+>>> VAR_F[1] = 250
+>>> print(VAR_F[0:2])
+['object', 250]
+```
+
+Les **tuples** sont des listes qu'on ne peut pas modifier. On les appelle entre parenthèses:
+```
+>>> VAR_F = ( "elem1", "elem2", "elem3")
+>>> 
+>>> print(type(VAR_F))
+<class 'tuple'>
+```
+
+### Les dictionnaires
+
+Les dictionnaires sont des séries de paires clé-valeur, déclarées entre accolades ( `curly brackets { } `)
+
+```
+>>> VAR_G = { "name": "python",   "version_number": 3.8,   "use": "coding"}
+>>> type(VAR_G)
+<class 'dict'>
+```
+
+Comme pour les listes, on peut accéder aux valeurs et les modifier en indexant avec les crochets:
+```
+>>> VAR_G["use"] = VAR_G["use"] + " and playing"
+>>> 
+>>> print(VAR_G["use"])
+coding and playing
+```
+
+??? important "Note importante pour les étudiants"
+	Pour l'évaluation, vous devez demander une merge request depuis votre branche vers la branche start.
+	![Faire une merge request](img/creating-merge-request.png)
+

docs/cours/python/rest.md

@@ -0,0 +1,96 @@
+# Utiliser une API REST
+
+## Introduction 
+
+Pour découvrir Python, nous allons d'abord apprendre à manipuler des données.
+
+Pour cela nous nous appuierons sur un jeu de données accessible via une API REST.
+
+Une APi (Application Programming Interface) est un programme qui permet à deux programmes de communiquer ensemble.
+
+Ici nous voulons accéder aux données proposées par un site web.
+
+L'API utilisée, appellée REST API communique avec le site web par des requêtes http.
+
+Nous allons utiliser l'APi de Gitlab qui contient énormément d'informations sur les projets hébergés.
+
+
+
+---
+
+
+
+## Générer un jeton d'authentification
+
+Pour accéder aux données présentées par l'API (par exemple, la liste des 'issues' qui me sont attribuées),
+Gitlab a besoin de m'identifier.
+
+Pour cela, à partir de notre interface web utilisateur de Gitlab, nous allons générer un **jeton d'authentification**.
+
+Vous pouvez utiliser ce [tutoriel pour générer votre jeton d'API](https://screenful.com/gitlab/gitlab-apikey){target=_blank}
+
+
+
+---
+
+
+
+## Import des librairies utiles
+
+En plus des fonctions intégrées à python (comme la fonction `print()` que nous avons utilisée), 
+nous allons importer des fonctions provenant d'autres librairies.
+
+Il nous faut donc:  
+1. installer les librairies sur notre système  
+2. importer les fonctions utiles dans notre projet
+
+
+
+### Installer les librairies
+
+Pour installer des librairies python supplémentaires, nous allons utiliser `pip`
+
+On peut utiliser pip pour installer directement une librairie:
+```
+pip install pytest
+```
+**[Pytest](https://docs.pytest.org/en/stable/){target=_blank}** est une librairie pour réaliser des tests sur le code. 
+
+
+Pour notre projet, il y a deux librairies dont nous aurons absolument besoin: `requests` et `json`  
+- **requests** permet d'envoyer et de recevoir des requêtes html. C'est un peu l'équivalent de `curl`en bash.   
+- **json** permet de traiter des données au format **[json](https://www.json.org/json-fr.html){target=_blank}**  
+
+Comme ces deux librairies sont nécessaires au fonctionnement du projet, nous allons créer un fichier requirements.txt à la racine de notre projet.
+
+!!! note "requirements.txt"
+    requests  
+    json
+
+Pour les installer, un simple:
+```
+pip install -r requirements.txt
+```
+
+
+### Importation dans le projet
+
+Dans notre fichier `main.py` nous devons maintenant importer les libraires
+
+!!! note "main.py"
+    ```
+    #!/usr/bin/env python3
+
+    import requests
+    import json
+
+    base_url = "https://gitlab.com/api/v4"
+    endpoint1 = base_url + "/groups"
+    ```
+
+---
+
+## Accès à l'API
+
+Nous allons ajouter à notre code une fonction, issue de la bibliothèque requests, pour accéder aux données via l'API REST.
+

docs/cours/python/workspace.md

@@ -0,0 +1,85 @@
+# Configurer l'espace de travail
+
+## Installer python
+
+Python est peut-être déjà installé sur votre système, mais il faut vérifier la version:
+
+```
+user@host:~$ python --version
+Python 3.7.3
+```
+
+et la liste des versions disponibles:
+
+```
+user@host:~$ update-alternatives --list python
+/usr/bin/python2
+/usr/bin/python3
+```
+
+Pour installer la version qui vous manque:
+```
+sudo apt install python2
+# OU
+sudo apt install python3
+```
+
+Nous avons besoin du numéro de version pour python2 et python3:
+```
+user@host:~$ ls -l /usr/bin/python{2,3}
+lrwxrwxrwx 1 root root 9 mars   4  2019 /usr/bin/python2 -> python2.7
+lrwxrwxrwx 1 root root 9 mars  26  2019 /usr/bin/python3 -> python3.7
+```
+
+Nous allons donner la priorité 1 à python2 et la priorité 2 à python3:
+
+```
+sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 2
+sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
+```
+
+---
+
+## Installer pip
+
+pip (Package installer for python or "Pip Installs Packages") est un outil très utile pour gérer les dépendances dans un projet python.
+
+Là aussi, il y a pip pou python2 et pip pour python3, mais Debian utilisera la version correpondante à la version de python définie avec `update-alternatives`.
+
+```
+user@host:~$  sudo apt install python3-pip python-pip
+user@host:~$  pip --version
+pip 18.1 from /usr/lib/python3/dist-packages/pip (python 3.7)
+```
+
+---
+
+## Utiliser la console python
+
+Pour découvrir python, rien de plus simple, on saisit la commande `python` dans le terminal:
+
+```
+user@host:~$ python
+Python 3.7.3 (default, Dec 20 2019, 18:57:59) 
+[GCC 8.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>> 
+```
+Les trois chevrons `>>>` vous indiquent que vous êtes dans la console python.  
+Faites ++ctrl+d++ pour en sortir.
+
+Vous pouvez déclarer une variable, la transformer et l'afficher:
+
+```
+>>> MA_VARIABLE = " ceci est le contenu de ma variable "
+>>>
+>>> print(MA_VARIABLE)
+ ceci est le contenu de ma variable 
+>>> 
+>>> VAR_2 = MA_VARIABLE + " et celle-ci est plus longue"
+>>> 
+>>> print(VAR_2)
+ ceci est le contenu de ma variable  et celle-ci est plus longue
+```
+
+

mkdocs.yml

@@ -17,8 +17,27 @@ markdown_extensions:
     - footnotes
     - toc:
         permalink: true
+    - attr_list
 extra_javascript:
-  - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/highlight.min.js
+    - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/highlight.min.js
-  - javascripts/config.js
+    - javascripts/config.js
 extra_css:
-  - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/styles/default.min.css
+    - https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.1.1/styles/default.min.css
+nav:
+    - Accueil: index.md
+    - Cours: 
+        - Introduction: cours/index.md
+        - "Présentation du Garage":
+            - cours/presentation-garage/index.md
+            - cours/presentation-garage/equipe.md
+            - cours/presentation-garage/histoire.md
+            - cours/presentation-garage/projets.md
+            - cours/presentation-garage/statut.md
+            - Ressources:
+                - cours/presentation-garage/ressources/sites-web.md
+        - Python: 
+            - cours/python/index.md
+            - cours/python/workspace.md
+            - cours/python/1stproject.md
+            - cours/python/rest.md
+            - cours/python/os-script.md