nb_utils.dict.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp utils.dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modify python dictionaries\n",
    "\n",
    "> Various methods to modify and work with python dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# hide\n",
    "from nbdev.showdoc import *\n",
    "from fastcore.test import *\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export \n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modify values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def apply_to_vals(nested_dict, func, use_key:bool=False):\n",
    "    '''Applies a function \"func\" to all non-dict values of a (nested) dictionary'''\n",
    "    new_dict = dict()\n",
    "\n",
    "    for k, v in nested_dict.items():\n",
    "        if isinstance(v, dict):\n",
    "            new_dict[k] = apply_to_vals(v, func, use_key)\n",
    "        else:\n",
    "            if use_key:\n",
    "                new_dict[k] = func(k, v)\n",
    "            else:\n",
    "                new_dict[k] = func(v)\n",
    "                \n",
    "    return new_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': {'b': 1, 'c': 4}, 'c': {'d': 9, 'e': 16}}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {\"a\": {\"b\": 1, \"c\": 2}, \"c\": {\"d\": 3, \"e\": 4}}\n",
    "apply_to_vals(my_dict, np.square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hide\n",
    "\n",
    "# apply_to_vals unit tests\n",
    "# test empty \n",
    "my_dict = {}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict, {})\n",
    "\n",
    "# test non nested dict \n",
    "my_dict = {\"a\": 1, \"b\": 2, \"c\": 3, \"d\": 4}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict, {\"a\": 1, \"b\": 4, \"c\": 9, \"d\": 16})\n",
    "\n",
    "# test nested dict (both child dicts contain same number of keys)\n",
    "my_dict = {\"a\": {\"b\": 1, \"c\": 2}, \"d\": {\"e\": 3, \"f\": 4}}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict, {\"a\": {\"b\": 1, \"c\": 4}, \"d\": {\"e\": 9, \"f\": 16}})\n",
    "\n",
    "# test nested dict (both child dicts contain uneven number of keys)\n",
    "my_dict = {\"a\": {\"b\": 1, \"c\": 2}, \"d\": {\"e\": 3}}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict,  {\"a\": {\"b\": 1, \"c\": 4}, \"d\": {\"e\": 9}})\n",
    "\n",
    "# test nested dict (only one key has a child dict)\n",
    "my_dict =  {\"a\": {\"b\": 1, \"c\": 2}, \"d\": 3}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict,   {\"a\": {\"b\": 1, \"c\": 4}, \"d\": 9})\n",
    "\n",
    "# test nested dict (child dict is empty)\n",
    "my_dict =  {\"a\": {\"b\": {}}}\n",
    "new_dict = apply_to_vals(my_dict, np.square)\n",
    "test_eq(new_dict,   {\"a\": {\"b\": {}}})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modify keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def remove_key(nested_dict, key):\n",
    "    '''Removes a key, together with its value, from a (nested) dict)'''\n",
    "    new_dict = dict()\n",
    "    \n",
    "    for k, v in nested_dict.items():\n",
    "        if isinstance(v, dict):\n",
    "            if k!=key:\n",
    "                new_dict[k] = remove_key(v, key) \n",
    "        else:\n",
    "            if k!=key:\n",
    "                new_dict[k] = v\n",
    "    return new_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hide\n",
    "\n",
    "# remove_key unit tests\n",
    "# test empty \n",
    "my_dict = {}\n",
    "new_dict = remove_key(my_dict, \"a\")\n",
    "test_eq(new_dict, {})\n",
    "\n",
    "# test non nested dict \n",
    "my_dict = {\"a\": 1, \"b\": 2, \"c\": 3, \"d\": 4}\n",
    "new_dict = remove_key(my_dict, \"a\")\n",
    "test_eq(new_dict, {\"b\": 2, \"c\": 3, \"d\": 4})\n",
    "\n",
    "# test nested dict (one child dict contains key)\n",
    "my_dict = {\"a\": {\"b\": 1, \"c\": 2}, \"d\": {\"e\": 3, \"f\": 4}}\n",
    "new_dict = remove_key(my_dict, \"c\")\n",
    "test_eq(new_dict, {\"a\": {\"b\": 1}, \"d\": {\"e\": 3, \"f\": 4}})\n",
    "\n",
    "# test nested dict (both child dicts contains key)\n",
    "my_dict = {\"a\": {\"b\": 1, \"c\": 2}, \"d\": {\"e\": 3, \"c\": 4}}\n",
    "new_dict = remove_key(my_dict, \"c\")\n",
    "test_eq(new_dict, {\"a\": {\"b\": 1}, \"d\": {\"e\": 3}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def remove_keys(nested_dict:dict, keys:list) -> dict:\n",
    "    '''Removes all keys, together with their values, from a (nested) dict\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    nested_dict : dict\n",
    "    \n",
    "    keys : list\n",
    "        List of dictionnary keys\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    nested_dict : dict\n",
    "        Same as input dict but without keys in ´keys´\n",
    "    '''\n",
    "    for key in keys:\n",
    "        nested_dict = remove_key(nested_dict, key)\n",
    "        \n",
    "    return nested_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modify structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def flatten_intra(nested_dict, include_key:bool=False):\n",
    "    new_dict = dict()\n",
    "    intra_li = list()\n",
    "\n",
    "    for k, v in nested_dict.items():\n",
    "        if isinstance(v, dict):\n",
    "            new_dict[k] = flatten_intra(v, include_key)\n",
    "        else:\n",
    "            if include_key:\n",
    "                intra_li.append((k, v))\n",
    "            else:\n",
    "                intra_li.append(v)\n",
    "\n",
    "    if intra_li:\n",
    "        return intra_li\n",
    "    else:\n",
    "        return new_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def collapse_helper(nested_dict, only_once:bool=True):\n",
    "    \n",
    "    new_dict = dict()\n",
    "    new_dict[\"_collapsed_once\"] = False\n",
    "    \n",
    "    for k, v in nested_dict.items():\n",
    "        if isinstance(v, dict) and len(v)>1:\n",
    "            new_dict[k] = collapse_helper(v)\n",
    "        else: # either item, empty dict or 1-item dict\n",
    "            if isinstance(v, dict) and len(v)==1:\n",
    "                new_dict[k] = list(v.values())[0]\n",
    "                new_dict[\"_collapsed_once\"] = True\n",
    "            elif isinstance(v, dict) and len(v)==0:\n",
    "                new_dict[\"_collapsed_once\"] = True\n",
    "            else:\n",
    "                new_dict[k] = v\n",
    "                \n",
    "    if only_once:\n",
    "        new_dict.pop(\"_collapsed_once\", None)\n",
    "\n",
    "    return new_dict\n",
    "\n",
    "def collapse_once(nested_dict):\n",
    "    return collapse_helper(nested_dict, only_once=True)\n",
    "            \n",
    "def collapse_all(nested_dict):\n",
    "    new_dict = nested_dict.copy()\n",
    "    \n",
    "    flag = True\n",
    "    while flag:\n",
    "        new_dict.pop(\"_collapsed_once\", None)\n",
    "        new_dict = collapse_helper(new_dict, only_once=False)\n",
    "        flag = new_dict.get(\"_collapsed_once\")\n",
    "        \n",
    "    new_dict.pop(\"_collapsed_once\", None)\n",
    "    return new_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def flatten_inter(nested_dict, include_key:bool=False):\n",
    "    \n",
    "    def flatten_inter_helper(nested_dict):\n",
    "        new_dict = dict()\n",
    "        intra_dict = dict()\n",
    "\n",
    "        for k, v in nested_dict.items():\n",
    "            if isinstance(v, dict):\n",
    "                new_dict[k] = flatten_inter_helper(v)\n",
    "            else:\n",
    "                for kk, vv in v:\n",
    "                    if intra_dict.get(kk) is None:\n",
    "                        intra_dict[kk] = [(k, vv),] if include_key else [vv,]\n",
    "                    else:\n",
    "                        if include_key:\n",
    "                            intra_dict[kk].append((k,vv))\n",
    "                        else:\n",
    "                            intra_dict[kk].append(vv)\n",
    "\n",
    "        if intra_dict:\n",
    "            return intra_dict\n",
    "        else:\n",
    "            return new_dict\n",
    "        \n",
    "    temp = flatten_intra(nested_dict, include_key=True)        \n",
    "    return flatten_inter_helper(temp)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}