notebooks (2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66103bf4-a9ef-4f5a-840c-5613ad441acb",
   "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",
    "\n",
    "Un exemple des bonnes pratiques à mettre en place pour constituer un Notebook.\n",
    "\n",
    "Par POPINEAU Maxime (rapport réalisé en stage de Master 2 coencadré par Marie-Laure Massot, Emilien Schultz et Agnès Tricoche, dans le cadre de l'initiative Digit_Hum, d'avril-juillet 2023)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c83109e-44de-4c55-a2ab-0d0fd8c34b30",
   "metadata": {},
   "source": [
    "\n",
    "## <span style=\"font-size: 14pt\"> Information sur les données.</span>\n",
    "\n",
    "Les données utilisées dans ce notebook proviennent du site HAL (https://hal.science/). L’archive ouverte pluridisciplinaire HAL est destinée au dépôt et à la diffusion en libre accès des travaux scientifiques des chercheurs, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés. Son interface en ligne permet de partager librement les savoirs. Il est également possible d’interagir avec la base de données de HAL via une API*, et notamment de l’interroger pour y effectuer des recherches selon divers critères puis de récupérer les résultats dans différents formats de données structurées.\n",
    "\n",
    "Une API (Interface de programmation d'application) fournit des \"endpoints\" permettant d'interagir avec leur site web afin de récupérer des informations grâce à des recherches. Les APIs facilitent la communication entre plusieurs applications informatiques : cela sert à ce que les applications puissent échanger des informations entre-elles. Cela permet aux développeurs de créer des applications utilisant plusieurs APIS en même temps.\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 ,pour l'API de HAL, 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 d'accéder au serveur 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 encodés correctement pour être transmis via le protocole HTTP. 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 de cette 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 HAL ainsi que les bibliothèques pandas et matplotlib. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c92ee9e-46ea-4475-88f1-ad518e26c9a0",
   "metadata": {},
   "source": [
    "Pour les personnes qui ne connaissent pas Python.\n",
    "\n",
    "Un ipywidget est disponible à la fin du Notebook pour permettre à des non-programmeurs d'interagir avec l'API de HAL !"
   ]
  },
  {
   "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 vise à  :\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."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f28feab-54d8-4417-8ebd-381b0488f7ca",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## <span style=\"font-size: 14pt\"> Compétences requises.</span>\n",
    "\n",
    "Ce Jupyter Notebook est à destination d'un public débutant. Il est préférable de connaître le langage informatique Python pour suivre le Notebook, mais cela n'est 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 via une API."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b6b7886-1071-4c7f-8b0d-f469bab9030e",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Section 0 : Importation des librairies.\n",
    "\n",
    "Dans cette section, nous allons importer les librairies nécessaires à notre analyse.\n",
    "\n",
    "Le rôle des libraries\n",
    "\n",
    "La librairie requests et json permetttent de faire les requêtes via l'API de HAL.\n",
    "\n",
    "Pandas est utilisé pour faire de l'analyse de données. La librairie fournit des fonctions pour créer, manipuler et analyser des DataFrames (les tableaux).\n",
    "\n",
    "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bd40303-6c83-42e5-854d-8f0be99aa680",
   "metadata": {},
   "source": [
    "## Section 1 : Analyse du nombre de publications citant Python et les Jupyter Notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "237d88ad-4269-4f76-b188-34fb528ca9aa",
   "metadata": {},
   "source": [
    "Nous pouvons faire une analyse statistique du nombre de publications dans la base de données HAL mentionnant Python et les Jupyter Notebooks."
   ]
  },
  {
   "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 d'éviter de le dupliquer. Elles font parties des bonnes pratiques à adopter dans un notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9885ad96-3cce-4a2d-abd1-0d48f840f69d",
   "metadata": {},
   "source": [
    "Pour faire une requête via l'API, il est nécessaire de lire la documentation du site HAL disponible à cette adresse : https://api.archives-ouvertes.fr/docs/search\n"
   ]
  },
  {
   "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"
   ]
  },
  {
   "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 : 30093\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                      14\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                     661\n",
      "19   2014                     877\n",
      "20   2015                    1047\n",
      "21   2016                    1387\n",
      "22   2017                    1932\n",
      "23   2018                    2610\n",
      "24   2019                    3604\n",
      "25   2020                    4154\n",
      "26   2021                    5163\n",
      "27   2022                    5240\n"
     ]
    }
   ],
   "source": [
    "df = get_publication_counts(\"python\")\n",
    "print(df)"
   ]
  },
  {
   "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."
   ]
  },
  {
   "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>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6387388-95ac-4e7a-ae85-e4cbae57e35d",
   "metadata": {},
   "source": [
    "Nous allons passer maintenant à la représentation graphique avec la librairie Matplotlib.\n"
   ]
  },
  {
   "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 : 30093\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 une 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ée (après 1995)\")\n",
    "plt.xlabel(\"Year\")\n",
    "plt.ylabel(\"Number of publications\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6210bcf5-f5dc-40f5-83ef-9f4434fcc781",
   "metadata": {},
   "source": [
    "Matplotlib nous permet de visualiser l'augmentation du nombre des articles sur Python ces 25 dernières années dans HAL. Nous constatons que l'année 2023 marquera peut être une baisse du nombre d'articles publiés sur Python car cinq mois se sont déjà écoulés et il y a à peine 1000 articles dans la base de données.\n"
   ]
  },
  {
   "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>"
   ]
  },
  {
   "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 : 861\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                      70\n",
      "24   2019                     108\n",
      "25   2020                     139\n",
      "26   2021                     213\n",
      "27   2022                     228\n"
     ]
    }
   ],
   "source": [
    "df = get_publication_counts(\"jupyter AND (notebook OR notebooks)\")\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a32e892-2b5a-4123-a0f6-d32f4479a650",
   "metadata": {},
   "source": [
    "Le Dataframe montre une augmentation importante des articles mentionnant les Jupyter Notebooks (avec et sans \"s\") dans la base de donnée HAL. Ils passent en effet de 12 en 2016 à 70 (multiplé par 5) en 2018 puis à 223 en 2022. Ainsi, le nombre de publications déposées dans HAL citant les Jupyter Notebooks a été multiplé à peu près par 19 entre 2016 et 2022."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d5b20d5-d460-488b-b53d-1aed7e8606d7",
   "metadata": {},
   "source": [
    "Il est néanmoinq important de comparer cette hausse d'intérêt pour Python et pour les Jupyter Notebooks à la hausse du nombre d'articles dans HAL. En effet, cette hausse du nombre d'articles pourrait ne pas être la conséquence d'une hausse d'intérêt mais d'une simple hausse dans le nombre d'articles déposés dans l'archive ouverte."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "283dabcc-f7ac-4088-8aed-fbda4124be20",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\"> 1.3 : Calculer le pourcentage d'articles mentionnant Python et les Jupyter Notebooks par rapport au nombre total d'articles publiés dans HAL au cours du temps.</span>"
   ]
  },
  {
   "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           22530                2                 0        0.008877  \\\n",
      "1   1996           24144                1                 0        0.004142   \n",
      "2   1997           25886                4                 0        0.015452   \n",
      "3   1998           27661                4                 0        0.014461   \n",
      "4   1999           28578                6                 0        0.020995   \n",
      "5   2000           33218                8                 0        0.024083   \n",
      "6   2001           35176               10                 0        0.028428   \n",
      "7   2002           42254               14                 0        0.033133   \n",
      "8   2003           51667               31                 0        0.060000   \n",
      "9   2004           62975               34                 0        0.053990   \n",
      "10  2005           83732               67                 0        0.080017   \n",
      "11  2006          100016              114                 0        0.113982   \n",
      "12  2007          110145              109                 0        0.098960   \n",
      "13  2008          115646              160                 0        0.138353   \n",
      "14  2009          125243              227                 0        0.181248   \n",
      "15  2010          137342              332                 0        0.241732   \n",
      "16  2011          142997              447                 0        0.312594   \n",
      "17  2012          149464              564                 0        0.377348   \n",
      "18  2013          158500              663                 0        0.418297   \n",
      "19  2014          164879              874                 0        0.530086   \n",
      "20  2015          175671             1054                 1        0.599985   \n",
      "21  2016          187089             1391                13        0.743496   \n",
      "22  2017          195352             1942                23        0.994103   \n",
      "23  2018          198886             2600                69        1.307282   \n",
      "24  2019          200627             3607               109        1.797864   \n",
      "25  2020          173079             4138               139        2.390816   \n",
      "26  2021          182203             5171               212        2.838043   \n",
      "27  2022          159150             5234               225        3.288721   \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.000569  \n",
      "21         0.006949  \n",
      "22         0.011774  \n",
      "23         0.034693  \n",
      "24         0.054330  \n",
      "25         0.080310  \n",
      "26         0.116354  \n",
      "27         0.141376  \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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d096e3a-47f8-48c7-b957-d257a1d0e7db",
   "metadata": {},
   "source": [
    "Le tableau montre que le pourcentage des documents mentionnant Python et les Jupyter Notebooks augmente au fil des années dans le total de documents publiés dans HAL. L'intérêt pour ce langage de programmation et ce type de carnets interactifs semble donc augmenter sensiblement dans le cadre de la recherche.\n",
    "\n",
    "En effet, si en 2002, les documents relatifs à Python ne représentaient que 0,03% du total des documents présents dans HAL, ce chiffre est passé à 0,37% en 2012 et a atteint 3,31% en 2022. Notons aussi, que le projet Jupyter a été lancé en 2014 et que 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 dans HAL. Ce chiffre est de 0,14% en 2022. Bien que l'intérêt pour Python et les Jupyter Notebooks soit en hausse, le nombre d'articles les concernant reste relativement faible par rapport au nombre d'articles total dans la base de données de HAL."
   ]
  },
  {
   "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 d'apprendre à faire une requête multicritères dans l'API de HAL pour obtenir un type particulier de documents (articles, communicatoin ou autres) au sein d'une recherche précise (dans notre exemple, la recherche des mots clés \"Python\" ou \"Jupyter Notebook(s)).\n",
    "\n",
    "Nous verrons aussi comment récupérer dans l'API de HAL le domaine de recherche pour identifier les disciplines qui intègrent le plus les Jupyter Notebooks dans leur pratique de recherche ou d'enseignement. Notre hypothèse étant bien sûr que ces outils sont plus présents en informatique et dans les disciplines scientifiques qu'en sciences humaines et sociales. Cela nous permettra d'affiner l'analyse des résulats obtenus dans les sections précédentes."
   ]
  },
  {
   "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>"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f23700fb-27e7-46ec-8581-9352cbb81e0d",
   "metadata": {},
   "source": [
    "Nous rédigeons une fonction que nous invoquerons 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.279917583330565, 'COMM': 25.462762952377787, 'THESE': 11.996942607424147, 'UNDEFINED': 5.343790502143498, 'REPORT': 2.645309228673025, 'MEM': 2.2465188926921673, 'COUV': 1.4821707487288558, 'POSTER': 0.8341364527599614, 'HDR': 0.6812668239672992, 'OTHER': 0.5549832175733609, 'OUV': 0.41540659998006046, 'LECTURE': 0.32567877438436743, 'PROCEEDINGS': 0.2226579375893124, 'SOFTWARE': 0.17613239839154565, 'BLOG': 0.11299059519457645, 'PRESCONF': 0.08972782559569306, 'ISSUE': 0.029909275198564355, 'VIDEO': 0.023262769598883386, 'OTHERREPORT': 0.016616263999202418, 'REPORT_FORM': 0.013293011199361937, 'REPORT_LICE': 0.013293011199361937, 'REPORT_LABO': 0.009969758399521451, 'ETABTHESE': 0.0033232527998404843, 'MAP': 0.0033232527998404843, 'MEMLIC': 0.0033232527998404843, 'REPORT_LPRO': 0.0033232527998404843, 'REPORT_MAST': 0.0033232527998404843, 'SYNTHESE': 0.0033232527998404843, 'TRAD': 0.0033232527998404843, '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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6b3b3fc-17ae-42eb-85af-fc60deb199fb",
   "metadata": {},
   "source": [
    "Nous contastons que 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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52a7d308-5b4c-433a-bbfb-ba7e61dfadd6",
   "metadata": {},
   "source": [
    "Le constat est le même pour les Jupyter Notebooks : les documents sont à 39% des articles scientifiques, les communications 32% et des blogs à 6,52%. Les cours représentent seulement 6%."
   ]
  },
  {
   "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 que ce format est plus utilisé en informatique et dans les disciplines scientifiques comme en physique par exemple."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c935c5e-d733-48c3-87a5-d1b57e05f4c4",
   "metadata": {
    "tags": []
   },
   "source": [
    "## <span style=\"font-size: 12pt\"> 2.1 : De quel domaine de recherche relèvent les Jupyter Notebooks? </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73db9e10-517e-4bc7-8048-b2164ec7b4b1",
   "metadata": {},
   "source": [
    "Nous allons à présent nous intéresser aux disciplines qui mentionnent les Jupyter Notebooks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1f7a85a8-0e76-4f6b-8914-de66254af588",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Domaine  Pourcentage\n",
      "0   0.info    17.926186\n",
      "1    0.sdv     7.117750\n",
      "2   0.phys     4.481547\n",
      "3    0.sdu     4.086116\n",
      "4    0.shs     3.822496\n",
      "5   0.math     3.031634\n",
      "6    0.spi     2.899824\n",
      "7    0.sde     1.845343\n",
      "8   0.stat     1.625659\n",
      "9   0.scco     1.142355\n",
      "10  0.chim     1.054482\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 le nombre de publications par domaine\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "254e8d2a-a128-432a-8cba-b44b8be9b508",
   "metadata": {},
   "source": [
    "Les résultats obtenus confirment notre hypothèse. Les Jupyter Notebooks commencent à être utilisés dans les disciplines SHS, mais très peu : 3,8%. L'évolution de l'utilisation des Notebooks est plus marquée en informatique : (17%) en Sciences de la Vie (7%) ou bien en physique (4,4%).\n",
    "\n",
    "En effet, il y a encore peu de Notebooks en SHS que cela soit en Histoire ou en Géographie (sans parler de l'archéologie, de la la littérature ou de la philosophie). Une explication pourrait être que la pratique des Notebooks en SHS est nouvelle et aussi que les sciences sociales ont moins besoin d'utiliser des langages de programmation dans leur pratique quotidienne. \n",
    "\n",
    "Enfin, le manque de ressources pour se former et cas d'études sur l'utilisation des Jupyter Notebooks dans le cadre des SHS semblent un frein à l'appropriation de cet outil par les praticiens SHS."
   ]
  },
  {
   "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."
   ]
  },
  {
   "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                                           10814\n",
      "Matlab                                         2867\n",
      "HTML                                           2739\n",
      "Python                                         2651\n",
      "Rust                                           1121\n",
      "Perl                                            854\n",
      "Excel                                           670\n",
      "Fortran                                         546\n",
      "Javascript                                      434\n",
      "Stata                                           428\n",
      "Spss                                            364\n",
      "pascal langage informatique                     215\n",
      "Bash                                             47\n",
      "Rstudio                                          43\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)"
   ]
  },
  {
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be534a0f-e253-46ac-9145-ad6ed1879458",
   "metadata": {},
   "source": [
    "## <span style=\"font-size: 12pt\"> 3.1 : Les principaux types de documents.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afd5e72-e4d5-4664-a6eb-c8dfdf6827d2",
   "metadata": {},
   "source": [
    "Il est important de voir les autres pratiques numériques des chercheurs anglais ou français 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   32.55814  24.594493  \\\n",
      "THESE                               25.0              6.450396   \n",
      "LECTURE                             12.5                         \n",
      "ART                                       25.581395   48.13278   \n",
      "REPORT                                     9.302326              \n",
      "COUV                                                             \n",
      "POSTER                                                           \n",
      "MEM                                                              \n",
      "BLOG                                                             \n",
      "UNDEFINED                                                        \n",
      "OTHER                                                            \n",
      "\n",
      "          pascal langage informatique     Matlab Javascript       Spss   \n",
      "COMM                        41.860465  41.890478   54.83871  17.307692  \\\n",
      "THESE                       13.023256  14.161144   6.912442  12.087912   \n",
      "LECTURE                                                                  \n",
      "ART                         21.395349  31.845134  16.359447  54.120879   \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.161172  21.276596  20.517395  27.751063  20.597015  \\\n",
      "THESE      12.383178                         5.263158                         \n",
      "LECTURE                                                                       \n",
      "ART        39.485981  39.010989  38.297872  64.674398  55.113741  32.089552   \n",
      "REPORT                15.567766                                               \n",
      "COUV       11.682243             10.638298                                    \n",
      "POSTER                                                  4.549658              \n",
      "MEM                                                               24.029851   \n",
      "BLOG                                                                          \n",
      "UNDEFINED                                                                     \n",
      "OTHER                                                                         \n",
      "\n",
      "          Libreoffice       Perl       HTML  \n",
      "COMM        41.666667  20.725995  26.359985  \n",
      "THESE                                        \n",
      "LECTURE                                      \n",
      "ART                     72.36534   47.24352  \n",
      "REPORT      16.666667                        \n",
      "COUV                                         \n",
      "POSTER                                       \n",
      "MEM                                          \n",
      "BLOG             25.0                        \n",
      "UNDEFINED               1.639344             \n",
      "OTHER                              4.819277  \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)"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc2833aa-b947-4e16-ac77-8eea51e28d88",
   "metadata": {},
   "source": [
    "Nous avons vu comment mettre des paramètres avec le \"query string\" mais il y a une autre manière de faire.\n",
    "\n",
    "Nous pouvons construire un dictionnaire et ensuite passer le dictionnaire en tant qu'argument à la fonction requests.get. 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.\n",
    "\n",
    "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                          1635154    47.978238\n",
      "COMM                          807187    23.684258\n",
      "COUV                          292385     8.579080\n",
      "THESE                         144670     4.244867\n",
      "OUV                            99364     2.915511\n",
      "UNDEFINED                      67160     1.970590\n",
      "MEM                            61028     1.790667\n",
      "OTHER                          60279     1.768690\n",
      "REPORT                         59981     1.759946\n",
      "IMG                            56883     1.669045\n",
      "POSTER                         49558     1.454117\n",
      "ISSUE                          10122     0.296997\n",
      "NOTICE                          8360     0.245297\n",
      "PROCEEDINGS                     8127     0.238460\n",
      "HDR                             6876     0.201754\n",
      "BLOG                            6153     0.180540\n",
      "PATENT                          6142     0.180217\n",
      "REPORT_LABO                     5205     0.152724\n",
      "VIDEO                           4000     0.117367\n",
      "REPORT_MAST                     3413     0.100143\n",
      "LECTURE                         3070     0.090079\n",
      "REPORT_LPRO                     2747     0.080602\n",
      "REPORT_LICE                     2701     0.079252\n",
      "TRAD                            1857     0.054488\n",
      "SOFTWARE                         888     0.026055\n",
      "PRESCONF                         832     0.024412\n",
      "CREPORT                          808     0.023708\n",
      "REPORT_DOCT                      581     0.017048\n",
      "REPORT_ETAB                      491     0.014407\n",
      "MAP                              414     0.012147\n",
      "SON                              332     0.009741\n",
      "REPORT_FORM                      270     0.007922\n",
      "REPORT_GMAST                     222     0.006514\n",
      "OTHERREPORT                      164     0.004812\n",
      "NOTE                             145     0.004255\n",
      "SYNTHESE                         124     0.003638\n",
      "REPORT_FPROJ                     115     0.003374\n",
      "REPORT_GLICE                      91     0.002670\n",
      "REPACT                            70     0.002054\n",
      "ETABTHESE                         50     0.001467\n",
      "MEMLIC                            41     0.001203\n",
      "REPORT_RFOINT                     24     0.000704\n",
      "REPORT_COOR                       20     0.000587\n",
      "REPORT_RETABINT                   11     0.000323\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)"
   ]
  },
  {
   "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. \n",
    "Nous pouvons comparer cela aux résultats obtenus pour \"Python\" et les \"Jupyter Notebooks\" dans la section 2.\n",
    "\n",
    "Pour Python, les articles (47%) et les communications (25%) représentent 72% des documents présents. \n",
    "Pour les Jupyter Notebooks, les articles (39%) et les communications (32%) représentent 71% des documents présents.\n",
    "\n",
    "Les résultats sont donc similaires pour l'ensemble des documents, les articles scientifiques (47%) et les communications (23%) représentent aussi la majorité des documents dans la base HAL avec environ 70% des documents présents."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee93dcb8-47e7-4959-85e3-67e636d1ba47",
   "metadata": {},
   "source": [
    "Pour finir notre Notebook interactif, voici l'ipywidget comme promis en introduction pour les utilisateurs non programmeurs mais intéréssés pour interagir avec le document !"
   ]
  },
  {
   "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": 14,
   "id": "892a7d22-a42b-4c31-a9ca-6ff1221b0263",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3f712e32830a4caabcaf93f9b5fae99a",
       "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": "ccb0d929474440f89a527dfcd623e082",
       "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": "18e3e67128604d3c860ed9fc9acca20d",
       "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": "779c1b0296d448468003c1c98c3ffdc1",
       "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": "ae59f1b1580e4f5a97eac70f2188509a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Effectuer la requête', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import requests\n",
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from IPython.display import display\n",
    "import json\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": "markdown",
   "id": "49ca4570-a1aa-4eb4-a690-b34b8b45958c",
   "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."
   ]
  }
 ],
 "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
}