test_jinja2_yaml_conda-envs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# conda environments:\n",
      "#\n",
      "                         C:\\Users\\raysu\\Anaconda3\n",
      "RL_env                   C:\\Users\\raysu\\Anaconda3\\envs\\RL_env\n",
      "base_py_36               C:\\Users\\raysu\\Anaconda3\\envs\\base_py_36\n",
      "kedro_mlflow_env         C:\\Users\\raysu\\Anaconda3\\envs\\kedro_mlflow_env\n",
      "ml_env_py37              C:\\Users\\raysu\\Anaconda3\\envs\\ml_env_py37\n",
      "point_cloud_env          C:\\Users\\raysu\\Anaconda3\\envs\\point_cloud_env\n",
      "sphynx_env               C:\\Users\\raysu\\Anaconda3\\envs\\sphynx_env\n",
      "test_env                 C:\\Users\\raysu\\Anaconda3\\envs\\test_env\n",
      "tf2_env_py36             C:\\Users\\raysu\\Anaconda3\\envs\\tf2_env_py36\n",
      "                         C:\\Users\\raysu\\Documents\\GitHub\\test_flask\\.env\n",
      "base                     c:\\Users\\raysu\\Anaconda3\n",
      "RL_env                   c:\\Users\\raysu\\Anaconda3\\envs\\RL_env\n",
      "base_py_36               c:\\Users\\raysu\\Anaconda3\\envs\\base_py_36\n",
      "fav_env                  c:\\Users\\raysu\\Anaconda3\\envs\\fav_env\n",
      "kedro_mlflow_env         c:\\Users\\raysu\\Anaconda3\\envs\\kedro_mlflow_env\n",
      "ml_env_py37              c:\\Users\\raysu\\Anaconda3\\envs\\ml_env_py37\n",
      "point_cloud_env          c:\\Users\\raysu\\Anaconda3\\envs\\point_cloud_env\n",
      "sphynx_env               c:\\Users\\raysu\\Anaconda3\\envs\\sphynx_env\n",
      "test_env                 c:\\Users\\raysu\\Anaconda3\\envs\\test_env\n",
      "tf2_env_py36             c:\\Users\\raysu\\Anaconda3\\envs\\tf2_env_py36\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!conda env list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import StringIO\n",
    "from jinja2 import Template, Environment, PackageLoader\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"\"\"\n",
    "# Instruction:\n",
    "## For an environment installed locally\n",
    "# cd ./.env\n",
    "# mkdir venv && cd venv\n",
    "# conda env create --prefix . -f ../environment.yml\n",
    "## For Updating local environment\n",
    "# conda env update --prefix . -f ../environment.yml  --prune\n",
    "#\n",
    "## For an environment installed globally\n",
    "## with a name: fav_env\n",
    "# conda env create -f environment.yml\n",
    "\n",
    "name: fav_env # favorite env\n",
    "channels:\n",
    "  - conda-forge\n",
    "  - anaconda\n",
    "  - default\n",
    "dependencies:\n",
    "  - python=3.7\n",
    "  - numpy\n",
    "  - pandas\n",
    "  - scipy\n",
    "  - matplotlib\n",
    "  - plotly\n",
    "  - jupyter\n",
    "  - jupyterlab\n",
    "  - tqdm\n",
    "  - flask # -c conda-forge, anaconda\n",
    "  - flask-wtf # -c conda-forge, anaconda\n",
    "  - werkzeug==0.16.1   # https://github.com/pallets/flask/issues/3481#issuecomment-583293364\n",
    "  - requests\n",
    "  - codecov\n",
    "  - pip\n",
    "  - sphinx\n",
    "  - pandoc # -c conda-forge\n",
    "  - tensorflow\n",
    "  - scikit-learn\n",
    "  - scikit-image\n",
    "  - imageio\n",
    "  - pylint\n",
    "  - autopep8\n",
    "  - beautifulsoup4 # -c conda-forge\n",
    "  - kaggle # -c conda-forge\n",
    "  - pip:\n",
    "    - Flask-Testing\n",
    "    - hypothesis\n",
    "    - sphinx_rtd_theme\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'fav_env',\n",
       " 'channels': ['conda-forge', 'anaconda', 'default'],\n",
       " 'dependencies': ['python=3.7',\n",
       "  'numpy',\n",
       "  'pandas',\n",
       "  'scipy',\n",
       "  'matplotlib',\n",
       "  'plotly',\n",
       "  'jupyter',\n",
       "  'jupyterlab',\n",
       "  'tqdm',\n",
       "  'flask',\n",
       "  'flask-wtf',\n",
       "  'werkzeug==0.16.1',\n",
       "  'requests',\n",
       "  'codecov',\n",
       "  'pip',\n",
       "  'sphinx',\n",
       "  'pandoc',\n",
       "  'tensorflow',\n",
       "  'scikit-learn',\n",
       "  'scikit-image',\n",
       "  'imageio',\n",
       "  'pylint',\n",
       "  'autopep8',\n",
       "  'beautifulsoup4',\n",
       "  'kaggle',\n",
       "  {'pip': ['Flask-Testing', 'hypothesis', 'sphinx_rtd_theme']}]}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yaml_data = yaml.load(StringIO(s), Loader=yaml.FullLoader)\n",
    "yaml_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"<class 'list'>\""
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'name'"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(yaml_data.keys())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dict_keys(['name', 'channels', 'dependencies']),\n",
       " ['Flask-Testing', 'hypothesis', 'sphinx_rtd_theme'])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yaml_data.keys(), list(yaml_data['dependencies'][-1].values())[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"field_name\": \"dependencies_pip\",\n",
      "  \"field_value\": [\n",
      "    \"Flask-Testing\",\n",
      "    \"hypothesis\",\n",
      "    \"sphinx_rtd_theme\"\n",
      "  ],\n",
      "  \"parent\": \"dependencies\",\n",
      "  \"dtype\": \"list\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "subfield = Field(name = yaml_data['dependencies'][-1], value=None, parent='dependencies')\n",
    "print(subfield)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy, json\n",
    "class Field(object):\n",
    "    def __init__(self, name=None, value=None, parent=None):\n",
    "        self.name = name\n",
    "        self.value = value\n",
    "        self.parent = parent\n",
    "        self._update_dtype()\n",
    "        self._update_name()\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return \"a 'Field' class object\"\n",
    "    \n",
    "    def __str__(self, indent=2):\n",
    "        return json.dumps({'field_name': self.name, \n",
    "                           'field_value': self.value, \n",
    "                           'parent': self.parent, \n",
    "                           'dtype': self.dtype}, \n",
    "                          indent=indent)\n",
    "        \n",
    "    def _update_dtype(self):    \n",
    "        self._dtypes = {'list': list, 'dict': dict, 'str': str}\n",
    "        if (self.value is None):\n",
    "            check = self.name\n",
    "        else:\n",
    "            check = self.value\n",
    "        #print(check)\n",
    "        #check = copy.deepcopy(self.name) if (self.value is None) else copy.deepcopy(self.value)\n",
    "        self.dtype = [key for key, val in self._dtypes.items() if isinstance(check, val)][0]        \n",
    "        \n",
    "    def _update_name(self):\n",
    "        if self.dtype=='dict':\n",
    "            prefix = f'{self.parent}_' if (self.parent is not None) else ''\n",
    "            name, value = prefix + list(self.name.keys())[0], list(self.name.values())[0]\n",
    "            self.name, self.value = name, value\n",
    "            #print((name,value))\n",
    "            self._update_dtype()\n",
    "            #self.dtype = [key for key, val in self._dtypes.items() if isinstance(value, val)][0]\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "fields = list()\n",
    "for field_name, field_value in yaml_data.items():\n",
    "    fields.append(Field(name=field_name, value=field_value, parent=None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "template = '''\\n\n",
    "<html>\n",
    "<body>\n",
    "{% for field_name, field_value in fields.items() %}\n",
    "    {% set field = Field(name=field_name, value=field_value, parent=None) %}\n",
    "    {% if field.dtype==\"str\" %}\n",
    "        {{ field.name }}: {{ field.value }} <br/>\n",
    "    {% else %}\n",
    "        {% set nitems = LEN(field.value) %}\n",
    "        {% set ndigits = LEN(STR(nitems)) %}\n",
    "        {{ field.name }}: Total {{ nitems }} subfields. <br/>\n",
    "        <!--- <tab/> {{ \"SL#\" }}  <tab/>  {{ \"SUBFIELD VALUE\" }} <br/> --->\n",
    "        {% for idx, item in ENUMERATE(field.value) %}\n",
    "            {% set subfield = Field(name=item, value=None, parent=field.name) %}\n",
    "            {% if subfield.dtype!=\"list\" %}\n",
    "                {{ \" |---\" }} {{ STR(idx).zfill(ndigits) }}. {{ subfield.name }} <br/>\n",
    "            {% elif subfield.dtype==\"list\" %}\n",
    "                {% set nndigits = LEN(STR(LEN(subfield.value))) %}\n",
    "                {% for iidx, iitem in ENUMERATE(subfield.value) %}\n",
    "                    {% set subfield = Field(name=iitem, value=None, parent=field.name) %}              \n",
    "                    {{ \" |---\" }} {{ STR(iidx).zfill(ndigits) }}. {{ subfield.name }} <br/>\n",
    "                {% endfor %}\n",
    "            {% endif %}            \n",
    "        {% endfor %}\n",
    "    {% endif %}\n",
    "{% endfor %}\n",
    "</body>\n",
    "</html>\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance([1,2], list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, IFrame, HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm = Template(template, autoescape=False)\n",
    "msg = tm.render(fields=yaml_data, Field = Field, LEN = len, STR = str, ENUMERATE = enumerate)\n",
    "\n",
    "#print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "\n",
       "<html>\n",
       "<body>\n",
       "\n",
       "    \n",
       "    \n",
       "        name: fav_env <br/>\n",
       "    \n",
       "\n",
       "    \n",
       "    \n",
       "        \n",
       "        \n",
       "        channels: Total 3 subfields. <br/>\n",
       "        <!--- <tab/> SL#  <tab/>  SUBFIELD VALUE <br/> --->\n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 0. conda-forge <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 1. anaconda <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 2. default <br/>\n",
       "                        \n",
       "        \n",
       "    \n",
       "\n",
       "    \n",
       "    \n",
       "        \n",
       "        \n",
       "        dependencies: Total 26 subfields. <br/>\n",
       "        <!--- <tab/> SL#  <tab/>  SUBFIELD VALUE <br/> --->\n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 00. python=3.7 <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 01. numpy <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 02. pandas <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 03. scipy <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 04. matplotlib <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 05. plotly <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 06. jupyter <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 07. jupyterlab <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 08. tqdm <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 09. flask <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 10. flask-wtf <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 11. werkzeug==0.16.1 <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 12. requests <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 13. codecov <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 14. pip <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 15. sphinx <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 16. pandoc <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 17. tensorflow <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 18. scikit-learn <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 19. scikit-image <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 20. imageio <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 21. pylint <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 22. autopep8 <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 23. beautifulsoup4 <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                 |--- 24. kaggle <br/>\n",
       "                        \n",
       "        \n",
       "            \n",
       "            \n",
       "                \n",
       "                \n",
       "                                  \n",
       "                     |--- 00. Flask-Testing <br/>\n",
       "                \n",
       "                                  \n",
       "                     |--- 01. hypothesis <br/>\n",
       "                \n",
       "                                  \n",
       "                     |--- 02. sphinx_rtd_theme <br/>\n",
       "                \n",
       "                        \n",
       "        \n",
       "    \n",
       "\n",
       "</body>\n",
       "</html>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(10)\n",
    "y = 3*x**2 + 5*x - 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'x': x, 'y': y})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>-6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>62</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>5</td>\n",
       "      <td>94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>132</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>8</td>\n",
       "      <td>226</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>9</td>\n",
       "      <td>282</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   x    y\n",
       "0  0   -6\n",
       "1  1    2\n",
       "2  2   16\n",
       "3  3   36\n",
       "4  4   62\n",
       "5  5   94\n",
       "6  6  132\n",
       "7  7  176\n",
       "8  8  226\n",
       "9  9  282"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>4.50000</td>\n",
       "      <td>102.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>median</th>\n",
       "      <td>NaN</td>\n",
       "      <td>78.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>3.02765</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              x      y\n",
       "mean    4.50000  102.0\n",
       "median      NaN   78.0\n",
       "std     3.02765    NaN"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.agg({\n",
    "    'x': ['mean', 'std'], \n",
    "    'y': ['mean', 'median']\n",
    "       }\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Aggregate using one or more operations over the specified axis.\n",
      "\n",
      ".. versionadded:: 0.20.0\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "func : function, str, list or dict\n",
      "    Function to use for aggregating the data. If a function, must either\n",
      "    work when passed a DataFrame or when passed to DataFrame.apply.\n",
      "\n",
      "    Accepted combinations are:\n",
      "\n",
      "    - function\n",
      "    - string function name\n",
      "    - list of functions and/or function names, e.g. ``[np.sum, 'mean']``\n",
      "    - dict of axis labels -> functions, function names or list of such.\n",
      "axis : {0 or 'index', 1 or 'columns'}, default 0\n",
      "        If 0 or 'index': apply function to each column.\n",
      "        If 1 or 'columns': apply function to each row.\n",
      "*args\n",
      "    Positional arguments to pass to `func`.\n",
      "**kwargs\n",
      "    Keyword arguments to pass to `func`.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "scalar, Series or DataFrame\n",
      "\n",
      "    The return can be:\n",
      "\n",
      "    * scalar : when Series.agg is called with single function\n",
      "    * Series : when DataFrame.agg is called with a single function\n",
      "    * DataFrame : when DataFrame.agg is called with several functions\n",
      "\n",
      "    Return scalar, Series or DataFrame.\n",
      "\n",
      "The aggregation operations are always performed over an axis, either the\n",
      "index (default) or the column axis. This behavior is different from\n",
      "`numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`,\n",
      "`var`), where the default is to compute the aggregation of the flattened\n",
      "array, e.g., ``numpy.mean(arr_2d)`` as opposed to\n",
      "``numpy.mean(arr_2d, axis=0)``.\n",
      "\n",
      "`agg` is an alias for `aggregate`. Use the alias.\n",
      "\n",
      "See Also\n",
      "--------\n",
      "DataFrame.apply : Perform any type of operations.\n",
      "DataFrame.transform : Perform transformation type operations.\n",
      "core.groupby.GroupBy : Perform operations over groups.\n",
      "core.resample.Resampler : Perform operations over resampled bins.\n",
      "core.window.Rolling : Perform operations over rolling window.\n",
      "core.window.Expanding : Perform operations over expanding window.\n",
      "core.window.EWM : Perform operation over exponential weighted\n",
      "    window.\n",
      "\n",
      "Notes\n",
      "-----\n",
      "`agg` is an alias for `aggregate`. Use the alias.\n",
      "\n",
      "A passed user-defined-function will be passed a Series for evaluation.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> df = pd.DataFrame([[1, 2, 3],\n",
      "...                    [4, 5, 6],\n",
      "...                    [7, 8, 9],\n",
      "...                    [np.nan, np.nan, np.nan]],\n",
      "...                   columns=['A', 'B', 'C'])\n",
      "\n",
      "Aggregate these functions over the rows.\n",
      "\n",
      ">>> df.agg(['sum', 'min'])\n",
      "        A     B     C\n",
      "sum  12.0  15.0  18.0\n",
      "min   1.0   2.0   3.0\n",
      "\n",
      "Different aggregations per column.\n",
      "\n",
      ">>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})\n",
      "        A    B\n",
      "max   NaN  8.0\n",
      "min   1.0  2.0\n",
      "sum  12.0  NaN\n",
      "\n",
      "Aggregate over the columns.\n",
      "\n",
      ">>> df.agg(\"mean\", axis=\"columns\")\n",
      "0    2.0\n",
      "1    5.0\n",
      "2    8.0\n",
      "3    NaN\n",
      "dtype: float64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(df.agg.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.0.1'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0mdf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;34m'DataFrame'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "Call ``func`` on self producing a DataFrame with transformed values.\n",
       "\n",
       "Produced DataFrame will have same axis length as self.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "func : function, str, list or dict\n",
       "    Function to use for transforming the data. If a function, must either\n",
       "    work when passed a DataFrame or when passed to DataFrame.apply.\n",
       "\n",
       "    Accepted combinations are:\n",
       "\n",
       "    - function\n",
       "    - string function name\n",
       "    - list of functions and/or function names, e.g. ``[np.exp. 'sqrt']``\n",
       "    - dict of axis labels -> functions, function names or list of such.\n",
       "axis : {0 or 'index', 1 or 'columns'}, default 0\n",
       "    If 0 or 'index': apply function to each column.\n",
       "    If 1 or 'columns': apply function to each row.\n",
       "*args\n",
       "    Positional arguments to pass to `func`.\n",
       "**kwargs\n",
       "    Keyword arguments to pass to `func`.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "DataFrame\n",
       "    A DataFrame that must have the same length as self.\n",
       "\n",
       "Raises\n",
       "------\n",
       "ValueError : If the returned DataFrame has a different length than self.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "DataFrame.agg : Only perform aggregating type operations.\n",
       "DataFrame.apply : Invoke function on a DataFrame.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> df = pd.DataFrame({'A': range(3), 'B': range(1, 4)})\n",
       ">>> df\n",
       "   A  B\n",
       "0  0  1\n",
       "1  1  2\n",
       "2  2  3\n",
       ">>> df.transform(lambda x: x + 1)\n",
       "   A  B\n",
       "0  1  2\n",
       "1  2  3\n",
       "2  3  4\n",
       "\n",
       "Even though the resulting DataFrame must have the same length as the\n",
       "input DataFrame, it is possible to provide several input functions:\n",
       "\n",
       ">>> s = pd.Series(range(3))\n",
       ">>> s\n",
       "0    0\n",
       "1    1\n",
       "2    2\n",
       "dtype: int64\n",
       ">>> s.transform([np.sqrt, np.exp])\n",
       "       sqrt        exp\n",
       "0  0.000000   1.000000\n",
       "1  1.000000   2.718282\n",
       "2  1.414214   7.389056\n",
       "\u001b[1;31mFile:\u001b[0m      c:\\users\\raysu\\anaconda3\\lib\\site-packages\\pandas\\core\\frame.py\n",
       "\u001b[1;31mType:\u001b[0m      method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.transform?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('xvals', array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])),\n",
       " ('yvals', array([ -6,   2,  16,  36,  62,  94, 132, 176, 226, 282]))]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(*[1,2,3])\n",
    "params = {'xvals': x, 'yvals': y}\n",
    "[e for e in params.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.transform()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}