experimentation_aide.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scan for Yaml files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "root = '.'\n",
    "path = './ressources_from_aides_jeunes/aides/'\n",
    "\n",
    "current_path = f'{root}/{path}'\n",
    "benefits_folder = Path(current_path)\n",
    "\n",
    "def extract_benefits_paths(benefits_folder):\n",
    "    isYAMLfile = lambda path : str(path).endswith('.yml') or str(path).endswith('.yaml')\n",
    "    liste_fichiers = [str(benefit) for benefit in benefits_folder.iterdir() if isYAMLfile(benefit)]\n",
    "    return liste_fichiers\n",
    "\n",
    "benefits_files_paths = extract_benefits_paths(benefits_folder)\n",
    "benefits_files_paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Open and parse files: make a list of Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "\n",
    "def extract_benefit_file_content(aide_path):\n",
    "    benefit:dict = yaml.safe_load(open(aide_path))\n",
    "    benefit['file_path'] = aide_path\n",
    "    return benefit\n",
    "\n",
    "def extract_benefits_from_yamls(path):\n",
    "    benefits_files_paths = extract_benefits_paths(path)\n",
    "    benefits = [extract_benefit_file_content(path) for path in benefits_files_paths]\n",
    "    return benefits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Making benefits objects (bad idea, dont use `benefits_objects`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from benefit import Benefit\n",
    "def parse_benefits_from_yamls(path):\n",
    "    benefits_files_paths = extract_benefits_paths(path)\n",
    "    benefits = [Benefit(extract_benefit_file_content(path)) for path in benefits_files_paths]\n",
    "    return benefits\n",
    "\n",
    "benefits_objects = parse_benefits_from_yamls(benefits_folder)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benefits = extract_benefits_from_yamls(benefits_folder)\n",
    "len(benefits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "##  Make a list of [profils] [type] in all aides given"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from functools import reduce\n",
    "from benefit import BenefitProfile\n",
    "\n",
    "def accumulate_profils(profils: list, benefit: BenefitProfile):\n",
    "        return profils + benefit.get_profils_types()\n",
    "\n",
    "profiles_names = reduce(accumulate_profils, benefits_objects, [])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make a list with all conditons:\n",
    "\t- conditions generales\n",
    "\t- conditions in [profils][type]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "\n",
    "from benefit import BenefitCondition\n",
    "\n",
    "def accumulate_conditions(conditions: list, benefit: BenefitCondition):\n",
    "    return conditions + benefit.get_all_conditions_types()\n",
    "\n",
    "conditions_names = reduce(accumulate_conditions, benefits_objects, [])\n",
    "conditions_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Count frequence of profils and conditions appearances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_list_item_frequence(list : list):\n",
    "    elements_counter = {}\n",
    "    for element in list:\n",
    "        if element in elements_counter:\n",
    "            elements_counter[element] +=1\n",
    "        else:\n",
    "            elements_counter[element] = 1\n",
    "    return (sorted(elements_counter.items(), key=lambda x:x[1]))\n",
    "\n",
    "profil_names_frequence = count_list_item_frequence(profiles_names)\n",
    "condition_frequence = count_list_item_frequence(conditions_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition_frequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "profil_names_frequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference benefits with no profils:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contains_profils(benefit :dict):\n",
    "    return 'profils' in benefit and benefit['profils'] != []\n",
    "\n",
    "def extract_benefit_without_profile(benefit: Benefit):\n",
    "    if benefit.profils == []:\n",
    "        return [benefit.file_path]\n",
    "    else:\n",
    "        return []\n",
    "\n",
    "def accumulate_benefit_without_profile(list:list, benefit):\n",
    "    \n",
    "    return list + extract_benefit_without_profile(benefit)\n",
    "    \n",
    "    \n",
    "benefits_without_profils = reduce(accumulate_benefit_without_profile, benefits_objects, [])\n",
    "benefits_without_profils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benefits using only age as condition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_only_condition_age(benefit: Benefit):\n",
    "    conditions = benefit.get_all_conditions_types()\n",
    "    return all(condition == \"age\" for condition in conditions) and conditions != []\n",
    "\n",
    "def extract_benefit_with_only_condition(benefit : Benefit):\n",
    "    if is_only_condition_age(benefit):\n",
    "        return [benefit.file_path]\n",
    "    else:\n",
    "        return []\n",
    "\n",
    "def accumulate_benefit_with_only_condition(list:list, benefit: Benefit):\n",
    "    \n",
    "    return list + extract_benefit_with_only_condition(benefit)\n",
    "\n",
    "benefits_with_only_age_condition = reduce(accumulate_benefit_with_only_condition, benefits_objects, [])\n",
    "benefits_with_only_age_condition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting benefits Conditions (tools)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_benefit_profil_conditions(benefit):\n",
    "    conditions = []\n",
    "    if 'profile' in benefit and 'conditions' in benefit['profile']:\n",
    "        conditions= [condition for profile in benefit['profils'] for condition in profile['conditions']]\n",
    "    return conditions\n",
    "\n",
    "def get_benefit_general_conditions(benefit):\n",
    "    return [condition for condition in benefit['conditions_generales']]\n",
    "\n",
    "def get_all_benefit_conditions(benefit) -> \"list[dict]\":\n",
    "    return get_benefit_general_conditions(benefit) + get_benefit_profil_conditions(benefit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Benefits with 1 conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_benefit_with_X_conditions(benefits, condition_qty):\n",
    "    return [benefit for benefit in benefits if len(get_all_benefit_conditions(benefit)) == condition_qty]\n",
    "\n",
    "benefits_with_1_conditions =  get_benefit_with_X_conditions(benefits, 1)\n",
    "len(benefits_with_1_conditions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Benefit conditions tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_condition_type(condition):\n",
    "    return condition['type']\n",
    "\n",
    "def contains_age_condition(benefit):\n",
    "    conditions = get_all_benefit_conditions(benefit)\n",
    "    return 'age' in [get_condition_type(condition) for condition in conditions]\n",
    "\n",
    "def contains_departments_condition(benefit):\n",
    "    conditions = get_all_benefit_conditions(benefit)\n",
    "    return 'departements' in [get_condition_type(condition) for condition in conditions]\n",
    "\n",
    "def contains_regions_condition(benefit):\n",
    "    conditions = get_all_benefit_conditions(benefit)\n",
    "    return 'regions' in [get_condition_type(condition) for condition in conditions]\n",
    "\n",
    "def unwanted_conditions(benefit):\n",
    "    return contains_age_condition(benefit) or contains_departments_condition(benefit) or contains_regions_condition(benefit)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get Benefits with 1 conditions which is not age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benefits_with_1_conditions_not_age = [benefit for benefit in benefits_with_1_conditions if not contains_age_condition(benefit)]\n",
    "len(benefits_with_1_conditions_not_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[(benefit['file_path'].split('/')[-1]) for benefit in benefits_with_1_conditions_not_age]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Benefits with 1 conditions which is not age nor region nor departements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benefits_with_1_conditions_not_age_regions_departments = [benefit for benefit in benefits_with_1_conditions if not unwanted_conditions(benefit)]\n",
    "len(benefits_with_1_conditions_not_age_regions_departments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Benefits with 2 conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benefits_with_2_conditions =  get_benefit_with_X_conditions(benefits, 2)\n",
    "len(benefits_with_2_conditions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "benefits_with_2_conditions_without_region = [benefit for benefit in benefits_with_2_conditions if not contains_regions_condition(benefit)]\n",
    "len(benefits_with_2_conditions_without_region)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benefits_with_2_conditions_without_departments = [benefit for benefit in benefits_with_2_conditions if not contains_departments_condition(benefit)] \n",
    "len(benefits_with_2_conditions_without_departments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[(benefit['file_path'].split('/')[-1]) for benefit in benefits_with_2_conditions_without_departments]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting all used benefit's types "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set(benefit['type'] for benefit in benefits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get all benefits regions used (in conditions)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_conditions = [condition for benefit in benefits for condition in get_all_benefit_conditions(benefit) if condition['type'] == \"regions\"]\n",
    "all_conditions\n",
    "regions_list = [condition[\"values\"][0] for condition in all_conditions]\n",
    "set(regions_list)"
   ]
  }
 ],
 "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.8.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}