notebooks.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b37f205c",
   "metadata": {},
   "source": [
    "---\n",
    "title: \"Un panorama des pratiques informatiques dans les publications de recherche dans la base de données HAL.\"\n",
    "subject: \"Découverte de librairies et API.\"\n",
    "subtitle: \"Un exemple des bonnes pratiques à mettre en place pour constituer un Notebook.\"\n",
    "authors:\n",
    "  - name: \"POPINEAU Maxime\"\n",
    "    affiliations: \"Digit_Hum\"\n",
    "    email: \"maxime.popineau@etu.univ-tours.fr\"\n",
    "license: CC-BY-4.0\n",
    "keywords: \"Jupyter Notebooks, API, tutoriel\"\n",
    "venue:\n",
    "  title: Lien vers la documentation de l'API de HAL.\n",
    "  url: \"https://api.archives-ouvertes.fr/docs/search\"\n",
    "open_access: true\n",
    "repository:\n",
    "  url: https://github.com/MaximePop/Jupyter-Notebook-in-social-science\n",
    "html:\n",
    "  use_issues_button: true\n",
    "kernelspec:\n",
    "  display_name: Python 3\n",
    "  name: python3\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "cd8d5540",
   "metadata": {},
   "source": [
    "# <span style=\"font-size:18pt;\"><mark style=\"background-color: white;\">Un panorama des pratiques informatiques dans les publications de recherche dans la base de données HAL.</mark></span>\n",
    "Un exemple des bonnes pratiques à mettre en place pour constituer un Notebook.\n",
    "\n",
    "Créer par POPINEAU Maxime, en avril-mai 2023."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0c83109e-44de-4c55-a2ab-0d0fd8c34b30",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 14pt\"> Information sur les données.</span>\n",
    "\n",
    "Les données utilisées dans ce notebook proviennent du site des archives ouvertes (https://hal.science/). Les archives ouvertes sont une plateforme numérique qui permet aux chercheurs de publier, partager et diffuser leurs travaux scientifiques en ligne.\n",
    "\n",
    "Les données sont fournies au format texte en open source et sont accessibles via le site internet ou via l'API (Interface de programmation d'application). Une API fournit des \"endpoints\" permettant d'interagir avec leur site web et de récupérer des informations grâce à des recherches. Les APIs facilitent la communication entre plusieurs applications informatiques, ce qui facilite l'échange d'informations et permet aux développeurs de construire de nouvelles applications avec diverses utilisations.\n",
    "\n",
    "L'utilisation d'une API nécessite également une chaîne de requête (query string en anglais), qui est une partie à ajouter à droite de l'URL de base pour inclure des paramètres et des valeurs.\n",
    "\n",
    "Un exemple de chaîne de requête est : https://api.archives-ouvertes.fr/search/?q=%22jupyter%20notebook%22. Cette URL fonctionne directement dans notre navigateur web et renvoie les résultats de notre recherche.\n",
    "\n",
    "https://api.archives-ouvertes.fr/search est la première partie qui permet de rechercher dans l'API des archives ouvertes. La deuxième partie, ?q=%22jupyter%20notebook%22, permet de spécifier notre requête, qui est \"jupyter notebook\".\n",
    "\n",
    "Certains caractères, tels que l'espace ou les guillemets doubles, doivent être transmis correctement via le protocole HTTP pour être encodés. Le %22 correspond à l'encodage ASCII du caractère double guillemet et le %20 correspond à l'encodage de l'espace. Cela permet à l'ordinateur d'effectuer la requête sur \"jupyter notebook\" et non  \"jupyter\" et \"notebook\" séparément.\n",
    "\n",
    "L'utilisation d'une API permet d'interroger les données en utilisant des paramètres, par exemple pour connaître le nombre d'articles publiés dans HAL en 2014.\n",
    "\n",
    "Dans ce notebook, nous allons voir comment utiliser l'API des archives ouvertes ainsi que les bibliothèques pandas et matplotlib."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b59cb0e1-6e4d-4cbb-8fed-826fa958b7a9",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 14pt\"> Objectifs de ce Jupyter Notebook.</span>\n",
    "\n",
    "Ce Jupyter Notebook a plusieurs buts :\n",
    "\n",
    "1. Faire un panorama des pratiques numériques des chercheurs.\n",
    "2. Fournir un exemple de Jupyter Notebook reproductible et de qualité.\n",
    "3. Enseigner des compétences aux utilisateurs débutants ou expérimentés avec Python."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3f28feab-54d8-4417-8ebd-381b0488f7ca",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"font-size: 14pt\"> Compétences.</span>\n",
    "\n",
    "Ce Jupyter Notebook est à destination d'un public débutant. Il est conseillé de connaître le langage informatique Python pour suivre le Notebook mais pas obligatoire.\n",
    "\n",
    "Le document permet d'acquérir des compétences variées comme :\n",
    "\n",
    "1. Savoir utiliser les différentes librairies comme pandas et matplotlib.\n",
    "2. Utiliser les fonctions en Python pour éviter la duplication du code.\n",
    "3. Savoir faire une requête dans une API.\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1b6b7886-1071-4c7f-8b0d-f469bab9030e",
   "metadata": {},
   "source": [
    "## Section 0 : Importation des librairies.\n",
    "\n",
    "Dans cette section, nous allons importer les librairies nécessaires à notre analyse.\n",
    "\n",
    "1. La librairie requests et json permet de faire les requêtes dans l'API de HAL.\n",
    "2. Pandas est utilisé pour faire de l'analyse de données. La librarie fournit des fonctions pour créer, manipuler et analyser les DataFrames.\n",
    "3. Matplotlib permet de faire des graphiques et de visualiser les données."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "697b9fbb-0dfb-4e50-bfae-858c3d49a22f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests, json\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6bd40303-6c83-42e5-854d-8f0be99aa680",
   "metadata": {},
   "source": [
    "## Section 1 : Analyse du nombre de publications concernant Python et les Jupyter Notebooks dans l'API de HAL."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6da9edf4-ba44-4631-b793-05c0cd73fca1",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\">1.0 : Utilisation d'une fonction qui retourne le nombre d'articles par année en fonction d'une recherche.</span>\n",
    "\n",
    "Les fonctions permettent de rendre le code plus lisible et de réduire la duplication du code."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9885ad96-3cce-4a2d-abd1-0d48f840f69d",
   "metadata": {},
   "source": [
    "Pour faire une requête dans l'API, il est nécessaire de lire la documentation du site HAL disponible à cette adresse : https://api.archives-ouvertes.fr/docs/search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eddbb371-ac45-4591-9966-7f691ded5327",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_publication_counts(query):\n",
    "    # Effectue une requête pour obtenir le nombre total de publications\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query})&rows=0&facet=true&facet.field=publicationDateY_i\")\n",
    "    req_json = req.json()\n",
    "    nb = req_json[\"response\"][\"numFound\"]\n",
    "    print(f\"Le nombre total de résultats est de : {nb}\\n\")\n",
    "\n",
    "    # Effectue une requête pour obtenir le nombre de publications par année\n",
    "    year_counts = []\n",
    "    for year in range(1995, 2023):\n",
    "        req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query}) AND publicationDateY_i:{year}&rows=0\")\n",
    "        req_json = req.json()\n",
    "        year_count = req_json[\"response\"][\"numFound\"]\n",
    "        year_counts.append((year, year_count))\n",
    "\n",
    "    # Transforme la liste de tuples en un DataFrame pandas et le renvoie\n",
    "    df = pd.DataFrame(year_counts, columns=[\"Année\", \"Nombre de publications\"])\n",
    "    return df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8197672c-eb6f-4f57-8a09-6db0ff482f33",
   "metadata": {},
   "source": [
    "Nous allons ensuite appelé cette fonction et imprimer le dataframe créé grâce à la librairie Pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4ed5b820-2c56-4a3c-bf4b-49ab497d69da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le nombre total de résultats est de : 29737\n",
      "\n",
      "    Année  Nombre de publications\n",
      "0    1995                       2\n",
      "1    1996                       1\n",
      "2    1997                       3\n",
      "3    1998                       4\n",
      "4    1999                       7\n",
      "5    2000                       8\n",
      "6    2001                      10\n",
      "7    2002                      13\n",
      "8    2003                      32\n",
      "9    2004                      32\n",
      "10   2005                      68\n",
      "11   2006                     114\n",
      "12   2007                     108\n",
      "13   2008                     161\n",
      "14   2009                     224\n",
      "15   2010                     328\n",
      "16   2011                     444\n",
      "17   2012                     566\n",
      "18   2013                     660\n",
      "19   2014                     877\n",
      "20   2015                    1048\n",
      "21   2016                    1386\n",
      "22   2017                    1930\n",
      "23   2018                    2606\n",
      "24   2019                    3577\n",
      "25   2020                    4154\n",
      "26   2021                    5148\n",
      "27   2022                    5169\n"
     ]
    }
   ],
   "source": [
    "df = get_publication_counts(\"python\")\n",
    "print(df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9e18c57d-79c4-4aac-95b6-17e36ce5051c",
   "metadata": {},
   "source": [
    "Le dataframe montre une augmentation importante des articles concernant Python dans la base de donnée HAL. Le nombre d'articles sur Python passe de 10 en 2001 à 444 en 2011 puis 5143 en 2021 soit une multiplication par 500 en l'espace d'une vingtaine d'années. Il est important de noter que l'année 2022 est la première année de baisse du nombre d'articles concernant Python par rapport à l'année précédente depuis 1996."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2bf778ba-4b90-4b42-b204-422eee59eb2b",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\">1.1 : Faire un graphique avec la librairie Matplotlib pour voir le nombre de publications sur Python en fonction des années.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e6387388-95ac-4e7a-ae85-e4cbae57e35d",
   "metadata": {},
   "source": [
    "Nous allons passer maintenant à la représentation graphique avec la librairie Matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bc27ef87-b97a-4c5b-b067-7ea1f39a82c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le nombre d'articles contenant le mot clé 'python' est de : 29737\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Effectue une requête pour obtenir le nombre d'articles avec le mot-clé \"Python\"\n",
    "query = \"python\"\n",
    "req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:({query})&rows=0&facet=true&facet.field=producedDateY_i\")\n",
    "req_json = req.json()\n",
    "nb = req_json[\"response\"][\"numFound\"]\n",
    "print(f\"Le nombre d'articles contenant le mot clé '{query}' est de : {nb}\\n\")\n",
    "\n",
    "# Effectue uen requête pour obtenir le nombre d'articles avec le mot-clé \"Python\" par année\n",
    "year_counts = req_json[\"facet_counts\"][\"facet_fields\"][\"producedDateY_i\"]\n",
    "year_counts = [year_counts[i:i+2] for i in range(0, len(year_counts), 2) if int(year_counts[i]) >= 1995]\n",
    "years = [int(year) for year, count in year_counts]\n",
    "counts = [count for year, count in year_counts]\n",
    "\n",
    "# Création du graphique\n",
    "plt.bar(years, counts)\n",
    "plt.title(\"Nombre de résultats concernant Python dans la base de HAL par années(après 1995)\")\n",
    "plt.xlabel(\"Year\")\n",
    "plt.ylabel(\"Number of publications\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6210bcf5-f5dc-40f5-83ef-9f4434fcc781",
   "metadata": {},
   "source": [
    "Matplotlib est une librairie qui permet de faire ce graphique pour visualiser l'augmentation des articles sur Python dans la base de données HAL. \n",
    "L'année 2023 marquera probablement une baisse dans le nombre d'articles publiés sur Python dans la base de données de HAL car 5 mois se sont déjà écoulés et il n'y a même pas 1000 articles."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e49dc79b-6f80-4be6-9022-72d3d7bb5995",
   "metadata": {},
   "source": [
    "### <span style=\"font-size: 12pt\"> 1.2 : Obtenir les résultats pour les Jupyter Notebooks.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d220aec9-0e1a-4c8c-82aa-93c0fd9cd505",
   "metadata": {},
   "source": [
    "Nous appelons la même fonction que dans le 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ac172faa-5f98-45f3-a6f5-748ee89a2b96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le nombre total de résultats est de : 845\n",
      "\n",
      "    Année  Nombre de publications\n",
      "0    1995                       0\n",
      "1    1996                       0\n",
      "2    1997                       0\n",
      "3    1998                       0\n",
      "4    1999                       0\n",
      "5    2000                       0\n",
      "6    2001                       0\n",
      "7    2002                       0\n",
      "8    2003                       0\n",
      "9    2004                       0\n",
      "10   2005                       0\n",
      "11   2006                       0\n",
      "12   2007                       0\n",
      "13   2008                       0\n",
      "14   2009                       0\n",
      "15   2010                       0\n",
      "16   2011                       0\n",
      "17   2012                       0\n",
      "18   2013                       0\n",
      "19   2014                       0\n",
      "20   2015                       1\n",
      "21   2016                      12\n",
      "22   2017                      24\n",
      "23   2018                      69\n",
      "24   2019                     107\n",
      "25   2020                     138\n",
      "26   2021                     213\n",
      "27   2022                     224\n"
     ]
    }
   ],
   "source": [
    "df = get_publication_counts(\"jupyter AND (notebook OR notebooks)\")\n",
    "print(df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0a32e892-2b5a-4123-a0f6-d32f4479a650",
   "metadata": {},
   "source": [
    "Le dataframe montre une augmentation importante des articles concernant les Jupyter Notebooks dans la base de donnée HAL. Le nombre d'articles concernant les Jupyter Notebooks (avec et sans s) passent de 12 en 2016 à 70 (multiplé par 5) en 2018 puis à 223 en 2022. Le nombre de publications a été multiplé à peu près par 19 entre 2016 et 2022."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7d5b20d5-d460-488b-b53d-1aed7e8606d7",
   "metadata": {},
   "source": [
    "Il est important de comparer cette hausse d'intérêt pour Python et pour les Jupyter Notebooks à la hausse du nombre d'articles dans HAL. \n",
    "Cette hausse du nombre d'articles pourrait ne pas être la conséquence d'une hausse d'intérêt mais d'une hausse dans le nombre d'articles."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "283dabcc-f7ac-4088-8aed-fbda4124be20",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\"> 1.3 : Calculer le pourcentage d'articles concernant Python et les Jupyter Notebooks sur le nombre total d'articles dans la base de données HAL en fonction des années.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0f6e7a0d-29ec-4a84-910e-69f72572e8f2",
   "metadata": {},
   "source": [
    "Nous utilisons l'API de HAL et la librairie pandas pour créer un tableau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1e06648a-9d28-4c94-870f-60c189d0aefc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    year  total_articles  python_articles  jupyter_articles  percent_python  \\\n",
      "0   1995           22489                2                 0        0.008893   \n",
      "1   1996           24106                1                 0        0.004148   \n",
      "2   1997           25854                4                 0        0.015471   \n",
      "3   1998           27630                4                 0        0.014477   \n",
      "4   1999           28524                6                 0        0.021035   \n",
      "5   2000           32962                8                 0        0.024270   \n",
      "6   2001           34906               10                 0        0.028648   \n",
      "7   2002           42052               13                 0        0.030914   \n",
      "8   2003           51433               31                 0        0.060273   \n",
      "9   2004           62754               34                 0        0.054180   \n",
      "10  2005           83609               67                 0        0.080135   \n",
      "11  2006           99794              114                 0        0.114235   \n",
      "12  2007          109924              109                 0        0.099159   \n",
      "13  2008          115399              160                 0        0.138649   \n",
      "14  2009          124946              227                 0        0.181678   \n",
      "15  2010          137047              332                 0        0.242253   \n",
      "16  2011          142782              447                 0        0.313065   \n",
      "17  2012          149234              564                 0        0.377930   \n",
      "18  2013          158251              662                 0        0.418323   \n",
      "19  2014          164624              874                 0        0.530907   \n",
      "20  2015          175373             1055                 1        0.601575   \n",
      "21  2016          186786             1390                13        0.744167   \n",
      "22  2017          194924             1940                23        0.995260   \n",
      "23  2018          198273             2596                68        1.309306   \n",
      "24  2019          199952             3580               108        1.790430   \n",
      "25  2020          172297             4138               138        2.401667   \n",
      "26  2021          180873             5157               212        2.851172   \n",
      "27  2022          156396             5162               221        3.300596   \n",
      "\n",
      "    percent_jupyter  \n",
      "0          0.000000  \n",
      "1          0.000000  \n",
      "2          0.000000  \n",
      "3          0.000000  \n",
      "4          0.000000  \n",
      "5          0.000000  \n",
      "6          0.000000  \n",
      "7          0.000000  \n",
      "8          0.000000  \n",
      "9          0.000000  \n",
      "10         0.000000  \n",
      "11         0.000000  \n",
      "12         0.000000  \n",
      "13         0.000000  \n",
      "14         0.000000  \n",
      "15         0.000000  \n",
      "16         0.000000  \n",
      "17         0.000000  \n",
      "18         0.000000  \n",
      "19         0.000000  \n",
      "20         0.000570  \n",
      "21         0.006960  \n",
      "22         0.011799  \n",
      "23         0.034296  \n",
      "24         0.054013  \n",
      "25         0.080094  \n",
      "26         0.117209  \n",
      "27         0.141308  \n"
     ]
    }
   ],
   "source": [
    "# Récupère le nombre total d'articles pour chaque année\n",
    "total_counts = []\n",
    "for year in range(1995, 2023):\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=*&fq=producedDateY_i:{year}&rows=0\")\n",
    "    req_json = req.json()\n",
    "    year_count = req_json[\"response\"][\"numFound\"]\n",
    "    total_counts.append((year, year_count))\n",
    "total_df = pd.DataFrame(total_counts, columns=[\"year\", \"total_articles\"])\n",
    "\n",
    "# Récupère le nombre d'articles concernant Python pour chaque année\n",
    "python_counts = []\n",
    "for year in range(1995, 2023):\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:(Python)&fq=producedDateY_i:{year}&rows=0\")\n",
    "    req_json = req.json()\n",
    "    year_count = req_json.get(\"response\", {}).get(\"numFound\", 0)\n",
    "    python_counts.append((year, year_count))\n",
    "python_df = pd.DataFrame(python_counts, columns=[\"year\", \"python_articles\"])\n",
    "\n",
    "# le nombre d'articles concernant les Jupyter Notebooks pour chaque année\n",
    "jupyter_counts = []\n",
    "for year in range(1995, 2023):\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:(jupyter AND (notebook OR notebooks))&fq=producedDateY_i:{year}&rows=0\")\n",
    "    req_json = req.json()\n",
    "    year_count = req_json.get(\"response\", {}).get(\"numFound\", 0)\n",
    "    jupyter_counts.append((year, year_count))\n",
    "jupyter_df = pd.DataFrame(jupyter_counts, columns=[\"year\", \"jupyter_articles\"])\n",
    "\n",
    "# Fusionne les trois dataframes\n",
    "merged_df = pd.merge(total_df, python_df, on=\"year\")\n",
    "merged_df = pd.merge(merged_df, jupyter_df, on=\"year\")\n",
    "\n",
    "# Calcul le pourcentage des articles concernant Python et les JupyterNotebooks pour chaque année.\n",
    "merged_df[\"percent_python\"] = merged_df[\"python_articles\"] / merged_df[\"total_articles\"] * 100\n",
    "merged_df[\"percent_jupyter\"] = merged_df[\"jupyter_articles\"] / merged_df[\"total_articles\"] * 100\n",
    "\n",
    "# Visualise le tableau\n",
    "print(merged_df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5d096e3a-47f8-48c7-b957-d257a1d0e7db",
   "metadata": {},
   "source": [
    "Le tableau montre que le pourcentage des documents concernant Python et les Jupyter Notebooks augmente dans le total de documents publiés dans HAL. L'intérêt pour Python et les Jupyter Notebooks augmente dans le cadre de la recherche.\n",
    "\n",
    "En 2002, les documents relatifs à Python ne représentaient que 0,03% du total des documents présents dans la base de données HAL. Ce chiffre est passé à 0,37% en 2012 et a atteint 3,31% en 2022. \n",
    "\n",
    "Le Projet Jupyter a été lancé en 2014. Les premiers résultats apparaissent en 2015 avec un document traitant des Jupyter Notebooks. En 2019, le pourcentage des documents relatifs aux Jupyter Notebooks représentaient 0,05% du nombre total de documents présents. Ce chiffre est de 0,14% en 2022.\n",
    "\n",
    "Bien que l'intérêt pour Python et les Jupyter Notebooks soit en hausse, le nombre d'articles les concernant reste relativement faible dans la base de données de HAL."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fea5204c-8305-4d2b-ac08-f82a525aa6f8",
   "metadata": {},
   "source": [
    "Il est intéressant de voir quelles sont les mots clés les plus cherchés dans la base des archives ouvertes si Python ne représente que 3.30% des documents présents et les Jupyter Notebooks que 0,14% des documents présents."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "beebf154-6f3a-4bbd-935c-f2ae0647579f",
   "metadata": {},
   "source": [
    "## Section 2 : Travail d'analyse sur la recherche \"Python\" et \"Jupyter Notebook\".\n",
    "\n",
    "Cette section permet de voir comment faire une requête dans l'API de HAL pour obtenir le type de documents concernant une recherche précise (dans notre exemple : Python et les Jupyter Notebooks).\n",
    "\n",
    "Nous verrons aussi comment récupérer dans l'API de HAL le domaine d'une recherche."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c09fc3dc-6e3c-438f-96df-01890c7de2e1",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"font-size: 12pt\"> 2.0 : Obtenir le type de document en fonction d'une recherche.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1d1dfafb-7e72-4c30-b2a4-b6e4d152d4d4",
   "metadata": {},
   "source": [
    "Pour faire une requête dans l'API, il est nécessaire de lire la documentation du site HAL disponible à cette adresse : https://api.archives-ouvertes.fr/docs/search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ab0fc7b1-3a79-46ba-9877-7dcacd84ce58",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_doc_types(query):\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q={query}&rows=0&facet=true&facet.field=docType_s\")\n",
    "    req_json = req.json()\n",
    "    doc_types = req_json[\"facet_counts\"][\"facet_fields\"][\"docType_s\"]\n",
    "    doc_types = [doc_types[i:i+2] for i in range(0, len(doc_types), 2)]\n",
    "    total_docs = req_json[\"response\"][\"numFound\"]\n",
    "    doc_types_dict = {doc_type: count/total_docs*100 for doc_type, count in doc_types}\n",
    "    return doc_types_dict"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f23700fb-27e7-46ec-8581-9352cbb81e0d",
   "metadata": {},
   "source": [
    "Nous faisons une fonction que nous allons appeler dans la suite de notre code comme dans la Section 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1df107f7-a086-481d-a0fe-2638b7768e33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ART': 47.17355483068231, 'COMM': 25.587651746981876, 'THESE': 11.974980663819485, 'UNDEFINED': 5.346874264384437, 'REPORT': 2.649897434172916, 'MEM': 2.2564481958502873, 'COUV': 1.4863637892188184, 'POSTER': 0.8339778726838618, 'HDR': 0.6860140565625316, 'OTHER': 0.5481386824494737, 'OUV': 0.41362612233917345, 'LECTURE': 0.32283014426472073, 'PROCEEDINGS': 0.211857282173723, 'SOFTWARE': 0.1715035141406329, 'BLOG': 0.11433567609375525, 'PRESCONF': 0.09079597807445271, 'ISSUE': 0.030265326024817567, 'VIDEO': 0.023539698019302554, 'OTHERREPORT': 0.016814070013787537, 'REPORT_FORM': 0.013451256011030031, 'REPORT_LICE': 0.013451256011030031, 'REPORT_LABO': 0.010088442008272523, 'ETABTHESE': 0.0033628140027575078, 'MAP': 0.0033628140027575078, 'MEMLIC': 0.0033628140027575078, 'REPORT_LPRO': 0.0033628140027575078, 'REPORT_MAST': 0.0033628140027575078, 'SYNTHESE': 0.0033628140027575078, 'TRAD': 0.0033628140027575078, 'CREPORT': 0.0, 'DOUV': 0.0, 'IMG': 0.0, 'MANUAL': 0.0, 'NOTE': 0.0, 'NOTICE': 0.0, 'PATENT': 0.0, 'REPACT': 0.0, 'REPORT_COOR': 0.0, 'REPORT_DOCT': 0.0, 'REPORT_ETAB': 0.0, 'REPORT_FPROJ': 0.0, 'REPORT_GLICE': 0.0, 'REPORT_GMAST': 0.0, 'REPORT_RETABINT': 0.0, 'REPORT_RFOINT': 0.0, 'SON': 0.0}\n"
     ]
    }
   ],
   "source": [
    "doc_types = get_doc_types(\"text_fulltext:(python)\")\n",
    "print(doc_types)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d6b3b3fc-17ae-42eb-85af-fc60deb199fb",
   "metadata": {},
   "source": [
    "Parmi les documents liés à Python dans la base de données HAL, les articles scientifiques représentent 47%, suivis des communications à 25%, et des thèses à 11%. En revanche, les cours ne représentent qu'une faible proportion de 0,32%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d3c690ca-86e7-49aa-bc43-48d05c1fcb13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'ART': 39.130434782608695, 'COMM': 32.608695652173914, 'BLOG': 6.521739130434782, 'LECTURE': 6.521739130434782, 'UNDEFINED': 5.434782608695652, 'OUV': 2.1739130434782608, 'REPORT': 2.1739130434782608, 'SOFTWARE': 2.1739130434782608, 'POSTER': 1.0869565217391304, 'THESE': 1.0869565217391304, 'VIDEO': 1.0869565217391304, 'COUV': 0.0, 'CREPORT': 0.0, 'DOUV': 0.0, 'ETABTHESE': 0.0, 'HDR': 0.0, 'IMG': 0.0, 'ISSUE': 0.0, 'MANUAL': 0.0, 'MAP': 0.0, 'MEM': 0.0, 'MEMLIC': 0.0, 'NOTE': 0.0, 'NOTICE': 0.0, 'OTHER': 0.0, 'OTHERREPORT': 0.0, 'PATENT': 0.0, 'PRESCONF': 0.0, 'PROCEEDINGS': 0.0, 'REPACT': 0.0, 'REPORT_COOR': 0.0, 'REPORT_DOCT': 0.0, 'REPORT_ETAB': 0.0, 'REPORT_FORM': 0.0, 'REPORT_FPROJ': 0.0, 'REPORT_GLICE': 0.0, 'REPORT_GMAST': 0.0, 'REPORT_LABO': 0.0, 'REPORT_LICE': 0.0, 'REPORT_LPRO': 0.0, 'REPORT_MAST': 0.0, 'REPORT_RETABINT': 0.0, 'REPORT_RFOINT': 0.0, 'SON': 0.0, 'SYNTHESE': 0.0, 'TRAD': 0.0}\n"
     ]
    }
   ],
   "source": [
    "doc_types = get_doc_types(\"jupyter AND (notebook OR notebooks)\")\n",
    "print(doc_types)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "52a7d308-5b4c-433a-bbfb-ba7e61dfadd6",
   "metadata": {},
   "source": [
    "Parmi les documents liés aux Jupyter Notebooks dans la base de données HAL, les articles scientifiques représesentent 39%, les communications 32% et des blogs à 6,52%. Les cours représentent eux seulement 6%."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c9726618-d48c-42a4-bd4c-358b4bb99c6b",
   "metadata": {},
   "source": [
    "Nous pouvons nous demander aussi dans quelle discipline les Jupyter Notebooks sont utilisés. Notre hypothèse est dire que ce format est plus utilisé en informatique et dans les disciplines scientifiques comme en physique par exemple."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7c935c5e-d733-48c3-87a5-d1b57e05f4c4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"font-size: 12pt\"> 2.1 : Obtenir le domaine des articles concernant les Jupyter Notebooks.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "73db9e10-517e-4bc7-8048-b2164ec7b4b1",
   "metadata": {},
   "source": [
    "Nous allons voir comment obtenir le domaine d'une recherche grâce à l'API de HAL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1f7a85a8-0e76-4f6b-8914-de66254af588",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Domaine  Pourcentage\n",
      "0   0.info    17.933810\n",
      "1    0.sdv     7.245081\n",
      "2   0.phys     4.338104\n",
      "3    0.sdu     4.069767\n",
      "4    0.shs     3.890877\n",
      "5   0.math     2.996422\n",
      "6    0.spi     2.862254\n",
      "7    0.sde     1.833631\n",
      "8   0.stat     1.654741\n",
      "9   0.scco     1.162791\n",
      "10  0.chim     0.983900\n"
     ]
    }
   ],
   "source": [
    "# Faire la requête pour obtenir le nombre de documents contenant \"jupyter\" et \"notebook(s)\"\n",
    "req = requests.get(\"https://api.archives-ouvertes.fr/search/?q=text_fulltext:(jupyter AND (notebook OR notebooks))&rows=0&facet=true&facet.field=domain_s\")\n",
    "\n",
    "# Obtenir les données de la requête au format JSON\n",
    "req_json = req.json()\n",
    "\n",
    "# Extraire les domaines et leur nombre de la réponse JSON\n",
    "domain_counts = req_json[\"facet_counts\"][\"facet_fields\"][\"domain_s\"]\n",
    "domain_counts = [(domain_counts[i], domain_counts[i+1]) for i in range(0, len(domain_counts), 2)]\n",
    "\n",
    "# Séparer les domaines multiples et leur nombre de documents en entrées individuelles\n",
    "domain_counts_split = []\n",
    "for domain_count in domain_counts:\n",
    "    domains = domain_count[0].split(';')\n",
    "    for domain in domains:\n",
    "        domain_counts_split.append((domain.strip(), domain_count[1]))  # Garder le domaine complet\n",
    "\n",
    "# Calculer le nombre total de documents\n",
    "total = sum([count for _, count in domain_counts_split])\n",
    "\n",
    "# Calculer le pourcentage de documents par domaine\n",
    "domain_percents = [(domain[0], domain[1]/total*100) for domain in domain_counts_split]\n",
    "\n",
    "# Filtrer les domaines ayant un seul mot et un pourcentage supérieur à 0,5% et supprimer les domaines spécifiques\n",
    "domain_percents_filtered = [(domain, percent) for domain, percent in domain_percents if percent > 0.5 and len(domain.split()) == 1\n",
    "                            and not any(domain_specific in domain for domain_specific in [\"1.info.info-ai\", \"1.info.info-bi\", \"1.phys.astr\", \"info.info-lg\", \"sdv.neu\", \"sdu.ocean\", \"math.math-st\"])]\n",
    "\n",
    "# Supprimer les domaines qui commencent par \"1\"\n",
    "domain_percents_filtered = [(domain, percent) for domain, percent in domain_percents_filtered if not domain.startswith(\"1\")]\n",
    "\n",
    "# Créer un dataframe à partir des pourcentages filtrés et trier par ordre décroissant\n",
    "df = pd.DataFrame(domain_percents_filtered, columns=[\"Domaine\", \"Pourcentage\"])\n",
    "df = df.sort_values(by=[\"Pourcentage\"], ascending=False)\n",
    "\n",
    "# Afficher le dataframe\n",
    "print(df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "254e8d2a-a128-432a-8cba-b44b8be9b508",
   "metadata": {},
   "source": [
    "Les Jupyter Notebooks commencent à être utiliser en SHS mais très peu (3,8%) par rapport à l'informatique (17%) ou en Statisques et Données de la Vie (7%).\n",
    "\n",
    "Il est encore assez compliqué de trouver des Notebooks disponibles en SHS que cela soit en Histoire ou en Géographie. Une explication peut être le fait que la pratique des Notebooks en SHS est nouvelle et aussi le fait que les sciences sociales ont moins besoin d'utiliser des langages informatiques qu'en informatique et qu'en Statistiques et Données de la Vie. Le manque de ressources sur comment bien utiliser les Jupyter Notebooks dans le cadre des SHS peut être une cause aussi de ce faible pourcentage."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "eacdf6fb-0258-4d0a-8bcd-0a39942011d0",
   "metadata": {},
   "source": [
    "## Section 3 : Travail général sur les pratiques numériques des chercheurs.\n",
    "\n",
    "Nous allons voir dans cette partie quels sont les logiciels et les différents langages informatiques (autre que Python) que les chercheurs utilisent le plus dans la base de HAL."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8f3018ec-52c7-4aeb-b535-a6c67764640f",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\"> 3.0 : Les autres pratiques numériques des chercheurs.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7e4842cc-1c8d-4bd5-ab7b-dcf3525ef902",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                Nombre de documents\n",
      "SAS                                           10756\n",
      "Matlab                                         2848\n",
      "HTML                                           2729\n",
      "Python                                         2632\n",
      "Rust                                           1111\n",
      "Perl                                            852\n",
      "Excel                                           661\n",
      "Fortran                                         541\n",
      "Javascript                                      432\n",
      "Stata                                           423\n",
      "Spss                                            354\n",
      "pascal langage informatique                     214\n",
      "Bash                                             47\n",
      "Rstudio                                          42\n",
      "Libreoffice                                      12\n",
      "langage de programmation Julia                    8\n"
     ]
    }
   ],
   "source": [
    "# Liste des termes de recherche\n",
    "terms = [\"langage de programmation Julia\", \"Rstudio\", \"Python\", \"pascal langage informatique\", \"Matlab\", \"Javascript\", \"Spss\", \"Stata\", \"Fortran\", \"Javascript\", \"Bash\", \"Rust\", \"SAS\", \"Excel\", \"Libreoffice\", \"Perl\", \"HTML\"]\n",
    "\n",
    "# Dictionnaire pour stocker les résultats\n",
    "results = {}\n",
    "\n",
    "# Pour chaque terme de recherche, faire une requête et extraire le nombre total de résultats\n",
    "for term in terms:\n",
    "    req = requests.get(f\"https://api.archives-ouvertes.fr/search/?q={term}&rows=0\")\n",
    "    req_json = req.json()\n",
    "    total = req_json[\"response\"][\"numFound\"]\n",
    "    results[term] = total\n",
    "\n",
    "# Afficher les résultats sous forme de tableau\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame.from_dict(results, orient=\"index\", columns=[\"Nombre de documents\"])\n",
    "df = df.sort_values(by=[\"Nombre de documents\"], ascending=False)\n",
    "\n",
    "print(df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "23725088-0084-4a26-bcae-29f0b8f96ea1",
   "metadata": {},
   "source": [
    "Il est intéressant de voir les différentes pratiques numériques des chercheurs. Python a pris beaucoup d'importance mais il est important de voir que les chercheurs utilisent aussi d'autres langages informatiques comme HTML, Perl, Pascal ou bien Javascript. Les chercheurs utilisent aussi des logiciels comme Rstudio, LibreOffice mais surtout Excel."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "be534a0f-e253-46ac-9145-ad6ed1879458",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\"> 3.1 : Les principaux types de documents.</span>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2afd5e72-e4d5-4664-a6eb-c8dfdf6827d2",
   "metadata": {},
   "source": [
    "Il est important de voir les autres pratiques numériques des chercheurs et de comparer le type de document produit dans la plateforme HAL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fb2d8d8c-57be-459a-bed6-62e3df028bb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          langage de programmation Julia    Rstudio     Python  \\\n",
      "COMM                                62.5  33.333333  24.620061   \n",
      "THESE                               25.0              6.458967   \n",
      "LECTURE                             12.5                         \n",
      "ART                                       23.809524  48.138298   \n",
      "REPORT                                      9.52381              \n",
      "COUV                                                             \n",
      "POSTER                                                           \n",
      "MEM                                                              \n",
      "BLOG                                                             \n",
      "UNDEFINED                                                        \n",
      "OTHER                                                            \n",
      "\n",
      "          pascal langage informatique     Matlab Javascript       Spss  \\\n",
      "COMM                        41.588785  42.029494  55.092593   17.79661   \n",
      "THESE                       13.084112  14.255618   6.712963  11.864407   \n",
      "LECTURE                                                                  \n",
      "ART                         21.495327  31.671348  16.203704  53.954802   \n",
      "REPORT                                                                   \n",
      "COUV                                                                     \n",
      "POSTER                                                                   \n",
      "MEM                                                                      \n",
      "BLOG                                                                     \n",
      "UNDEFINED                                                                \n",
      "OTHER                                                                    \n",
      "\n",
      "               Stata    Fortran       Bash       Rust        SAS      Excel  \\\n",
      "COMM                  22.365989  21.276596  20.432043  27.789141  20.121029   \n",
      "THESE      12.056738                         5.310531                         \n",
      "LECTURE                                                                       \n",
      "ART        39.479905   38.44732  38.297872  64.626463  55.076237  32.526475   \n",
      "REPORT                15.711645                                               \n",
      "COUV       11.820331             10.638298                                    \n",
      "POSTER                                                  4.555597              \n",
      "MEM                                                               24.054463   \n",
      "BLOG                                                                          \n",
      "UNDEFINED                                                                     \n",
      "OTHER                                                                         \n",
      "\n",
      "          Libreoffice       Perl       HTML  \n",
      "COMM        41.666667  20.657277  26.419934  \n",
      "THESE                                        \n",
      "LECTURE                                      \n",
      "ART                     72.41784  47.196775  \n",
      "REPORT      16.666667                        \n",
      "COUV                                         \n",
      "POSTER                                       \n",
      "MEM                                          \n",
      "BLOG             25.0                        \n",
      "UNDEFINED               1.643192             \n",
      "OTHER                               4.87358  \n"
     ]
    }
   ],
   "source": [
    "# Liste des termes de recherche\n",
    "terms = [\"langage de programmation Julia\", \"Rstudio\", \"Python\", \"pascal langage informatique\", \"Matlab\", \"Javascript\", \"Spss\", \"Stata\", \"Fortran\", \"Javascript\", \"Bash\", \"Rust\", \"SAS\", \"Excel\", \"Libreoffice\", \"Perl\", \"HTML\"]\n",
    "\n",
    "# Dictionnaire pour stocker les résultats\n",
    "results = {}\n",
    "\n",
    "# Pour chaque terme de recherche, faire une requête et extraire les pourcentages de chaque type de document\n",
    "for term in terms:\n",
    "    doc_types_dict = get_doc_types(term)\n",
    "    results[term] = doc_types_dict\n",
    "\n",
    "# Afficher les résultats sous forme de tableau\n",
    "df_list = []\n",
    "for term, doc_types_dict in results.items():\n",
    "    df = pd.DataFrame.from_dict(doc_types_dict, orient=\"index\", columns=[term])\n",
    "    df = df.loc[df[term] > 0].sort_values(by=[term], ascending=False).head(3)\n",
    "    df.dropna(axis=1, inplace=True)\n",
    "    df_list.append(df)\n",
    "\n",
    "df_final = pd.concat(df_list, axis=1)\n",
    "df_final.fillna(\"\", inplace=True)\n",
    "df_final.dropna(axis=0, how='all', inplace=True)\n",
    "print(df_final)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d2b951f3-e580-494b-a662-0f7d245c3260",
   "metadata": {},
   "source": [
    "D'après les résultats obtenus, il apparaît que les types de documents les plus fréquemment associés à nos termes de recherche sont très majoritairement soit des articles scientifiques ou des communications ce qui est le même résultat que pour \"Python\" et les \"Jupyter Notebooks\" obtenu dans la section 2.0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc2833aa-b947-4e16-ac77-8eea51e28d88",
   "metadata": {},
   "source": [
    "Nous avons vu comment mettre des paramètres dans notre query avec le \"query string\" mais il y a une autre manière de faire.\n",
    "\n",
    "On peut créer un dictionnaire et les paramètres sont passés en tant qu'arguments. Lorsque la requête est effectuée, la bibliothèque requests construit automatiquement l'URL avec les paramètres spécifiés dans le dictionnaire params. Cela permet de spécifier les paramètres de manière plus structurée et flexible, en utilisant une syntaxe de dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6289c56f-7fd4-48d5-829a-0742685a75d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                 Nombre de documents  Pourcentage\n",
      "ART                          1626205    47.971201\n",
      "COMM                          803641    23.706497\n",
      "COUV                          290548     8.570836\n",
      "THESE                         143901     4.244916\n",
      "OUV                            98939     2.918588\n",
      "UNDEFINED                      66741     1.968784\n",
      "MEM                            60481     1.784121\n",
      "OTHER                          59962     1.768811\n",
      "REPORT                         59718     1.761613\n",
      "IMG                            56724     1.673294\n",
      "POSTER                         49283     1.453793\n",
      "ISSUE                           9996     0.294871\n",
      "NOTICE                          8268     0.243897\n",
      "PROCEEDINGS                     8016     0.236463\n",
      "HDR                             6845     0.201920\n",
      "PATENT                          6110     0.180238\n",
      "BLOG                            6028     0.177819\n",
      "REPORT_LABO                     5205     0.153542\n",
      "VIDEO                           3965     0.116963\n",
      "REPORT_MAST                     3413     0.100680\n",
      "LECTURE                         3036     0.089559\n",
      "REPORT_LPRO                     2747     0.081033\n",
      "REPORT_LICE                     2701     0.079676\n",
      "TRAD                            1810     0.053393\n",
      "SOFTWARE                         879     0.025930\n",
      "PRESCONF                         832     0.024543\n",
      "CREPORT                          808     0.023835\n",
      "REPORT_DOCT                      581     0.017139\n",
      "REPORT_ETAB                      491     0.014484\n",
      "MAP                              413     0.012183\n",
      "SON                              326     0.009617\n",
      "REPORT_FORM                      270     0.007965\n",
      "REPORT_GMAST                     222     0.006549\n",
      "OTHERREPORT                      164     0.004838\n",
      "NOTE                             145     0.004277\n",
      "SYNTHESE                         124     0.003658\n",
      "REPORT_FPROJ                     115     0.003392\n",
      "REPORT_GLICE                      91     0.002684\n",
      "REPACT                            70     0.002065\n",
      "ETABTHESE                         50     0.001475\n",
      "MEMLIC                            41     0.001209\n",
      "REPORT_RFOINT                     24     0.000708\n",
      "REPORT_COOR                       20     0.000590\n",
      "REPORT_RETABINT                   11     0.000324\n",
      "MANUAL                             1     0.000029\n",
      "DOUV                               0     0.000000\n"
     ]
    }
   ],
   "source": [
    "# Effectuer une requête pour obtenir les types de document pour tous les documents dans HAL\n",
    "params = {\n",
    "    \"q\": \"*:*\",\n",
    "    \"rows\": 0,\n",
    "    \"fl\": \"docType_s\",\n",
    "    \"facet\": \"true\",\n",
    "    \"facet.field\": \"docType_s\"\n",
    "}\n",
    "req = requests.get(\"https://api.archives-ouvertes.fr/search/\", params=params)\n",
    "req_json = req.json()\n",
    "\n",
    "# Extraire les types de document et leurs nombres de la réponse JSON\n",
    "doc_types = req_json[\"facet_counts\"][\"facet_fields\"][\"docType_s\"]\n",
    "doc_types_dict = {doc_type: count for doc_type, count in zip(doc_types[::2], doc_types[1::2])}\n",
    "\n",
    "# Créer un DataFrame à partir des types de document\n",
    "df = pd.DataFrame.from_dict(doc_types_dict, orient=\"index\", columns=[\"Nombre de documents\"])\n",
    "df = df.sort_values(by=[\"Nombre de documents\"], ascending=False)\n",
    "\n",
    "# Calculer les pourcentages de chaque type de document par rapport au total\n",
    "total_documents = df[\"Nombre de documents\"].sum()\n",
    "df[\"Pourcentage\"] = df[\"Nombre de documents\"] / total_documents * 100\n",
    "\n",
    "# Afficher le DataFrame\n",
    "print(df)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ee5d1acc-74a5-4076-b67d-50406e20aefc",
   "metadata": {},
   "source": [
    "En analysant le nombre total de documents dans la base de HAL, on constate que les deux types de documents les plus fréquents sont des articles scientifiques et des communications. Cela correspond aux mêmes résultats obtenus pour \"Python\" et les \"Jupyter Notebooks\". Environ 70% des documents présents dans la base des archives ouvertes sont des articles scientifiques ou des communications."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ee93dcb8-47e7-4959-85e3-67e636d1ba47",
   "metadata": {},
   "source": [
    "Notre Jupyter Notebook est fini : en espérant qu'il vous a plu et qu'il était clair !\n",
    "\n",
    "Si vous avez des questions ou des retours, merci de m'écrire à mon adresse email universitaire : maxime.popineau@etu.univ-tours.fr."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8ae0876a-4a12-4fd1-9247-cd17049df3f1",
   "metadata": {},
   "source": [
    "Les IpyWidgets permettent à des utilisateurs qui ne savent pas coder d'utiliser l'API des HAL avec des paramètres comme le type de documents ou les années."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "892a7d22-a42b-4c31-a9ca-6ff1221b0263",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "15855ff75a194364be23386fa2f97725",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Textarea(value='', description='Requête:', placeholder='Saisissez votre requête ici')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08b6672f73274672962c30713cbee0c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Année:', options=('Toutes les années', 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a96f4644483c404882eeb9c0e40e996a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Type de document:', options=('Tous les types', 'ART', 'COMM', 'OUV', 'THESE'), value='To…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ee3a1c1946e4673b13624b343f85ebe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "RadioButtons(description='Affichage:', options=('Tableau', 'Graphique'), value='Tableau')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5fcb71df95484ae8b96c38bade83edff",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Effectuer la requête', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "# Fonction pour effectuer la requête sur l'API HAL\n",
    "def make_hal_request(query, year, doc_type):\n",
    "    url = f\"https://api.archives-ouvertes.fr/search/?q={query}&fq=docType_s:{doc_type}&fq=producedDateY_i:{year}&wt=json\"\n",
    "    response = requests.get(url)\n",
    "    try:\n",
    "        data = response.json()\n",
    "        return data\n",
    "    except json.JSONDecodeError:\n",
    "        print('Erreur lors de l\\'analyse de la réponse JSON de l\\'API.')\n",
    "        return None\n",
    "\n",
    "# Options de requête\n",
    "doc_types = ['ART', 'COMM', 'OUV', 'THESE']\n",
    "\n",
    "# Création des widgets\n",
    "query_widget = widgets.Textarea(value='', placeholder='Saisissez votre requête ici', description='Requête:')\n",
    "year_widget = widgets.Dropdown(options=['Toutes les années'] + list(range(2010, 2023)), description='Année:')\n",
    "doc_type_widget = widgets.Dropdown(options=['Tous les types'] + doc_types, description='Type de document:')\n",
    "display_type_widget = widgets.RadioButtons(options=['Tableau', 'Graphique'], description='Affichage:')\n",
    "button = widgets.Button(description='Effectuer la requête')\n",
    "\n",
    "# Fonction de rappel du bouton\n",
    "def on_button_click(b):\n",
    "    query = query_widget.value.strip()\n",
    "    year = year_widget.value\n",
    "    doc_type = doc_type_widget.value\n",
    "    \n",
    "    # Vérification de la validité de la requête\n",
    "    if not query:\n",
    "        print('Veuillez saisir une requête valide.')\n",
    "        return\n",
    "    \n",
    "    # Si l'option \"Toutes les années\" est sélectionnée, on utilise un caractère générique '*' pour la requête\n",
    "    if year == 'Toutes les années':\n",
    "        year = '*'\n",
    "    \n",
    "    # Si l'option \"Tous les types\" est sélectionnée, on utilise un caractère générique '*' pour le type de document\n",
    "    if doc_type == 'Tous les types':\n",
    "        doc_type = '*'\n",
    "    \n",
    "    # Appel de la fonction pour effectuer la requête\n",
    "    data = make_hal_request(query, year, doc_type)\n",
    "    \n",
    "    # Vérification de la réponse de l'API\n",
    "    if data is None:\n",
    "        return\n",
    "    \n",
    "    # Traitement des résultats\n",
    "    num_results = data['response']['numFound']\n",
    "    print(f\"Nombre total de documents : {num_results}\")\n",
    "    \n",
    "    # Exemple d'affichage sous forme de tableau\n",
    "    if display_type_widget.value == 'Tableau':\n",
    "        if year == '*':\n",
    "            if doc_type == '*':\n",
    "                years = list(range(2010, 2023))\n",
    "                counts = []\n",
    "                for year in years:\n",
    "                    data = make_hal_request(query, year, doc_type)\n",
    "                    if data is not None:\n",
    "                        counts.append(data['response']['numFound'])\n",
    "                \n",
    "                df = pd.DataFrame({'Année': years, 'Nombre de documents': counts})\n",
    "                display(df)\n",
    "            else:\n",
    "                print('Veuillez sélectionner \"Toutes les années\" pour afficher les résultats sous forme de tableau.')\n",
    "        else:\n",
    "            print('Veuillez sélectionner \"Toutes les années\" pour afficher les résultats sous forme de tableau.')\n",
    "    \n",
    "    # Exemple d'affichage sous forme de graphique\n",
    "    elif display_type_widget.value == 'Graphique':\n",
    "        if year == '*':\n",
    "            if doc_type == '*':\n",
    "                years = list(range(2010, 2023))\n",
    "                counts = []\n",
    "                for year in years:\n",
    "                    data = make_hal_request(query, year, doc_type)\n",
    "                    if data is not None:\n",
    "                        counts.append(data['response']['numFound'])\n",
    "                \n",
    "                plt.figure(figsize=(10, 6))\n",
    "                plt.plot(years, counts, marker='o')\n",
    "                plt.xlabel('Année')\n",
    "                plt.ylabel(\"Nombre de documents\")\n",
    "                plt.title('Nombre de documents publiés par année')\n",
    "                plt.show()\n",
    "            else:\n",
    "                print('Veuillez sélectionner \"Toutes les années\" pour afficher les résultats sous forme de graphique.')\n",
    "        else:\n",
    "            print('Veuillez sélectionner \"Toutes les années\" pour afficher les résultats sous forme de graphique.')\n",
    "\n",
    "# Lier la fonction de rappel au bouton\n",
    "button.on_click(on_button_click)\n",
    "\n",
    "# Afficher les widgets\n",
    "display(query_widget, year_widget, doc_type_widget, display_type_widget, button)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "286799d6-ccf8-43b8-af30-5b1d4df400b7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e2e31c9-6a71-4b4b-9d28-8568060c3531",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": true,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}