tutorial_for_boxx.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Tutorial for Box-X</h1>\n",
    "<div align=\"center\">\n",
    "  Tool-box for Efficient Build and Debug in Python. Especially for <strong>Scientific Computing</strong> and <strong>Computer Vision</strong>.\n",
    "</div>\n",
    "\n",
    "----\n",
    "We use [Binder](https://mybinder.org) to run this notebooks in an executable interactive online environment. That mean you can **run those cells rightnow** in your browser without download repository.\n",
    "\n",
    "\n",
    "This tutorial is divided into 2 parts by wether the tool is general:\n",
    "1. [**General Python Tool**](#1.-General-Python-Tool). The tools could be used anywhere in Python\n",
    "2. [**Scientific Computing and Computer Vision Tool**](#2.-Scientific-Computing-and-Computer-Vision-Tool). Those tools only be useful in Scientific Computing and Computer Vision field\n",
    "\n",
    "\n",
    "*P.S. This notebook compatible with Python 2/3*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><!-- START <code>./other/generate_table_of_contents_for_ipynb.py</code> generated TOC please keep comment here to allow auto update -->\n",
    "<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN <code>./other/generate_table_of_contents_for_ipynb.py</code> TO UPDATE --></p>\n",
    "\n",
    "<h2>Table of Contents</h2>\n",
    "\n",
    "<ul>\n",
    "<li><a href=\"#1.-General-Python-Tool\">1. General Python Tool</a>\n",
    "<ul>\n",
    "<li><a href=\"#▶-p-is-a-better-way-to-do-print\">▶ <code>p</code> is a better way to do <code>print</code></a></li>\n",
    "<li><a href=\"#▶-g-and-gg-could-transport-variable-to-Python-interactive-console\">▶ <code>g</code> and <code>gg</code> could transport variable to Python interactive console</a></li>\n",
    "<li><a href=\"#▶-Summary-for-debug-tools\">▶ Summary for debug tools</a></li>\n",
    "<li><a href=\"#▶-timeit-is-convenient-timing-tool-\">▶ <code>timeit</code> is convenient timing tool </a></li>\n",
    "<li><a href=\"#▶-mapmt-is-Multi-Threading-version-of-map\">▶ <code>mapmt</code> is Multi Threading version of <code>map</code></a></li>\n",
    "<li><a href=\"#▶-mapmp-is-Multi-Process-version-of-map\">▶ <code>mapmp</code> is Multi Process version of <code>map</code></a></li>\n",
    "<li><a href=\"#▶-mf-to-quick-add-magic-method-to-function\">▶ <code>mf</code> to quick add magic method to function</a></li>\n",
    "<li><a href=\"#▶-tree-to-visualization-complex-struct-in-tree-format\">▶ <code>tree</code> to visualization complex struct in tree format</a></li>\n",
    "<li><a href=\"#▶-dira(x)-to-show-x's-all-attribute\">▶ <code>dira(x)</code> to show <code>x</code>'s all attribute</a></li>\n",
    "<li><a href=\"#▶-what-to-know-&quot;What's-this?&quot;\">▶ <code>what</code> to know &quot;What's this?&quot;</a></li>\n",
    "<li><a href=\"#▶-logc-to-pretty-print-expression-by-show-every-variable's-value-in-expression\">▶ <code>logc</code> to pretty print expression by show every variable's value in expression</a></li>\n",
    "<li><a href=\"#▶-heatmap-to-show-the-time-heat-map-of-your-code\">▶ <code>heatmap</code> to show the time heat map of your code</a></li>\n",
    "<li><a href=\"#▶-performance-could-statistic-function-calls-and-visualize-code-performance\">▶ <code>performance</code> could statistic function calls and visualize code performance</a></li>\n",
    "<li><a href=\"#▶-dicto-is-a-convenient-version-of-dict\">▶ <code>dicto</code> is a convenient version of <code>dict</code></a></li>\n",
    "<li><a href=\"#▶-ll-is-a-convenient-tool-for-list\">▶ <code>ll</code> is a convenient tool for <code>list</code></a></li>\n",
    "<li><a href=\"#▶-sysi-include-many-infomation-about-operating-environment\">▶ <code>sysi</code> include many infomation about operating environment</a></li>\n",
    "</ul></li>\n",
    "<li><a href=\"#2.-Scientific-Computing-and-Computer-Vision-Tool\">2. Scientific Computing and Computer Vision Tool</a>\n",
    "<ul>\n",
    "<li><a href=\"#▶-loga-for-visualization-matrix-and-tensor\">▶ <code>loga</code> for visualization matrix and tensor</a></li>\n",
    "<li><a href=\"#▶-tree-to-visualization-complex-struct-for-Scientific-Computing\">▶ <code>tree</code> to visualization complex struct for Scientific Computing</a></li>\n",
    "<li><a href=\"#▶-show-is-easy-to-do-imshow,-even-images-are-in-complex-struct\">▶ <code>show</code> is easy to do <code>imshow</code>, even images are in complex struct</a></li>\n",
    "<li><a href=\"#▶-npa-transform-other-array-like-object-to-numpy-in-one-way\">▶ <code>npa</code> transform other array-like object to numpy in one way</a></li>\n",
    "</ul></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. General Python Tool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `p` is a better way to do `print`\n",
    "----\n",
    "#### 1. `p/x` will `print(x)` and return `x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import p \n",
    "\n",
    "s = 'p/x will print(x) and return x'\n",
    "p/s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import p \n",
    "from random import randint\n",
    "\n",
    "s = 'ABCD'\n",
    "print('the output of randint(0, 3) is :')\n",
    "\n",
    "sample = s[p/randint(0, 3)]\n",
    "\n",
    "sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, `p/x` is easy to print value in expression while debugging.   \n",
    "\n",
    "💡 **Note:**   \n",
    "\n",
    "`p/randint(0, 3)` print the value of `randint(0, 3)` and return the value itself, which won't influences the program.\n",
    "\n",
    "---\n",
    "↓ Use pow operator for highest evaluation order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try run this cell online\n",
    "from boxx import p \n",
    "from random import randint \n",
    "tenx = 10 * p**randint(0,9) \n",
    "tenx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. `p()`  to pretty print all variables  in function or module with thier name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import p \n",
    "\n",
    "def f(arg=517):\n",
    "    l = [1, 2]\n",
    "    p()\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`p()` will pretty print all variables in `locals()` and some infomation about the frame.    \n",
    "\n",
    "BTW, `import boxx.p` has the same effect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. `with p:` will pretty print mulit variables under \"with statement\"\n",
    "Only interested variables are printed which is under \"with statement\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import p\n",
    "from random import randint\n",
    "def f():\n",
    "    other_vars = \"No need to pay attention\"\n",
    "    with p:\n",
    "        a = randint(1, 9)\n",
    "        l = [a, a*2]\n",
    "    others = \"No need to pay attention\"\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `g` and `gg` could transport variable to Python interactive console\n",
    "----\n",
    "#### 1. Use `g.name=x` or `g.name/x` to transport variable that in function or module to console.\n",
    "The meaning of `g`,`gg` are \"to Global\", \"to Global and log\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import g\n",
    "\n",
    "def f():\n",
    "    listt = [1,2]\n",
    "    g.l = listt # `listt` is transported to console as `l`\n",
    "f()\n",
    "\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`g.l = listt` create new var `l` In Python interactive console and transport `listt` assign to `l`.   \n",
    "\n",
    "💡 **Note:** if variable name exists in console before, the variable's value will be covered by new value. \n",
    "\n",
    "---\n",
    "`gg` is same usage as `g`, but `gg` will print the transported variable.    \n",
    "Use `g.name/x` to convenient transport value in expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import g, gg\n",
    "\n",
    "def f():\n",
    "    listt = [1,2]\n",
    "    gg.l = listt\n",
    "    return g.by_div/listt\n",
    "\n",
    "listt = f()\n",
    "\n",
    "# l, by_div are transported to console\n",
    "(listt, l, by_div, l is listt, by_div is listt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**\n",
    " * In Python interactive console, variable `l`, `by_div` are created.\n",
    "\n",
    " * All of they are `listt` has the same `id`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. `g()` to transport all variables that in the function to Python interactive console\n",
    "`g()` in a function ,can transport all variables that in the function (or module) to console. It's a useful tool for debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import g\n",
    "def f(arg=517):\n",
    "    l = [1, 2]\n",
    "    g()\n",
    "f()\n",
    "\n",
    "# transport all variables in function to console \n",
    "arg, l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**\n",
    "\n",
    " * `g()` only transport the `locals()` to console, the `globals()` will save to `boxx.p`\n",
    " \n",
    " * `gg()` is a print version of `g`, `gg()` will pretty print all variable with thier name and some infomation about the frame.\n",
    "\n",
    " * `import boxx.g` is convenient way to use `g()` instead of `from boxx import g;g()`(`import boxx.gg` is avaliable too)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try run this cell online\n",
    "\n",
    "def f(arg):\n",
    "    a = 2\n",
    "    import boxx.gg\n",
    "    \n",
    "inp = [5 ,1 , 7]\n",
    "f(inp)\n",
    "\n",
    "# gg will pretty print all variables in f\n",
    "# and `a` and `arg` are transported to console \n",
    "a, arg, arg is inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. `with g:` will transport mulit variables under \"with statement\"\n",
    "`with g` will transport the interested variables to Python interactive console under \"with statement\"(`with gg:` is avaliable too)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import g\n",
    "from random import randint\n",
    "def f():\n",
    "    other_vars = \"No need to pay attention\"\n",
    "    with g:  # only transport a, l\n",
    "        a = randint(1, 9)\n",
    "        l = [a, a*2]\n",
    "    others = \"No need to pay attention\"\n",
    "f()\n",
    "\n",
    "print('In console:',a , l, 'others' in locals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**   \n",
    "\n",
    "1 . `with p`, `with g`, `with gg` only act on assignment variables under \"with statement\".     \n",
    "\n",
    "2 . If variable's name exists in `locals()` before and `id(variable)` not change ,variable may not be detected \n",
    "Especially following cases：\n",
    "    1. var is int and < 256\n",
    "    2. `id(var)` not change"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ Summary for debug tools\n",
    "---\n",
    "\n",
    "<center>\n",
    "<h4>\n",
    "    <code>boxx</code> debug tool matrix\n",
    "</h4>\n",
    "</center>\n",
    "\n",
    "| How many vars \\ Operation | print | transport | print & transport |\n",
    "| :---- | :---- | :---- | :---- |\n",
    "| Single variable | `p/x` | `g.name/x` | `gg.name/x`|\n",
    "|Multi variables | `with p:` | `with g:` | `with gg:` |\n",
    "|All `locals()`| `p()` | `g()` | `gg()` |\n",
    "|All `locals()`\\_2 | `import boxx.p` | `import boxx.g` | `import boxx.gg` |    \n",
    "\n",
    "  💡 **Note:**   \n",
    "  * **transport** mean \"transport variable to Python interactive console\"\n",
    "  * **All `locals()`** mean operation will act on all variables in the function or module\n",
    "  * **All `locals()`\\_2 :** when `boxx` are not imported, `import boxx.{operation}` is a convenient way to execution operation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `timeit` is convenient timing tool "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from boxx import timeit\n",
    "from time import sleep\n",
    "\n",
    "with timeit():\n",
    "    sleep(0.01) # simulation timing code\n",
    "\n",
    "with timeit(name='sleep'):\n",
    "    sleep(0.1) # simulation timing code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`timeit` will timing code block under \"with statement\" and print spend time in blue color."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `mapmt` is Multi Threading version of `map`\n",
    "`mapmt` is the meaning of \"MAP for Multi Threading\", has almost same usage as `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import mapmt, timeit\n",
    "from time import sleep\n",
    "\n",
    "def io_block(x): # simulation io block\n",
    "    sleep(0.1)\n",
    "    return x\n",
    "xs = range(10)\n",
    "\n",
    "with timeit('map'):\n",
    "    resoult_1 = list(map(io_block, xs))\n",
    "with timeit('mapmt'):\n",
    "    resoult_2 = mapmt(io_block, xs, pool=10)\n",
    "    # pool=10 mean 10 threadings\n",
    "\n",
    "resoult_1 == resoult_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `mapmp` is Multi Process version of `map`\n",
    "`mapmp` is the meaning of \"MAP for Multi Process\", has the same usage as `map` and `mapmt` but faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import mapmp, timeit\n",
    "def bad_fibonacci(x): # simulation Complex calculations\n",
    "    return x<=1 or x*bad_fibonacci(x-1)\n",
    "\n",
    "xs = [800]*10000\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    with timeit('map'):\n",
    "        resoult_1 = list(map(bad_fibonacci, xs))\n",
    "\n",
    "    with timeit('mapmp'):\n",
    "        resoult_2 = mapmp(bad_fibonacci, xs)\n",
    "    \n",
    "    resoult_1 == resoult_2\n",
    "    # the time printed below is run on a Intel i5 CPU on Ubuntu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**   \n",
    "\n",
    "`mapmp` and `mapmt` has same usage, they both support two parameters\n",
    "\n",
    "**pool** : int, default None   \n",
    ">    the number of Process or Threading, the default is the number of CPUs in the system   \n",
    "\n",
    "**printfreq** : int or float, default None   \n",
    ">    the meaning of `print frequent`, auto print program progress in `mapmt` and `mapmp`   \n",
    ">    if `printfreq < 1` then `printfreq = len(iterables[0])*printfreq`\n",
    "\n",
    "* It's better to run multi process under `if __name__ == '__main__':`, [see multiprocessing programming guidelines](https://docs.python.org/3/library/multiprocessing.html#multiprocessing-programming)\n",
    "\n",
    "* `multiprocessing` may not work on Windows\n",
    "\n",
    "* If you speed up the `numpy` program, note that in the MKL version of `numpy`, multiple processes will be slower. You can run `boxx.testNumpyMultiprocessing()` to test how friendly the current environment is to a multi-process `numpy`.\n",
    "\n",
    "---\n",
    "\n",
    "In multi process programs, display processing progress is troublesome.   \n",
    "**printfreq** parameter in `mapmp` can handle this problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try run this cell\n",
    "from boxx import mapmp\n",
    "from operator import add\n",
    "\n",
    "xs = list(range(100))\n",
    "double_xs = mapmp(add, xs, xs, pool=2, printfreq=.2)\n",
    "\n",
    "double_xs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `mf` to quick add magic method to function\n",
    "`mf` is the meaning of \"Magic Method\", to wrap the function that often used while debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import mf\n",
    "\n",
    "l = mf(list)\n",
    "tuplee = (5, 1, 7)\n",
    "print('- :', l-tuplee)\n",
    "print('* :', l*tuplee)\n",
    "print('**:', l**tuplee)\n",
    "print('/ :', l/tuplee)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**   \n",
    "\n",
    " * when `-`, `*`, `**` as magic method: do `f(x)` and return `f(x)`\n",
    "\n",
    " * when `/` as magic metho: do `f(x)` but return `x`\n",
    "\n",
    " * **Functions that wraps by `mf` in `boxx`**:  `stdout`, `log`, `logc`, `printt`, `pblue`, `pred`, `pdanger`, `perr`, `pinfo`, `typestr`, `getfathers`, `getfather`, `nextiter`, `mf`, `plot`, `show`, `showb`, `shows`, `loga`, `tree`, `treem`, `treea`, `dira`, `what`, `wtf`, `tprgb`, `torgb`, `normalizing`, `norma`, `npa`, `histEqualize`, `boolToIndex`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `tree` to visualization complex struct in tree format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from boxx import tree\n",
    "\n",
    "complex_struct = dict(key=[0, 'str', ('in_tuple', None)], tree=tree)\n",
    "\n",
    "tree(complex_struct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like `tree` command in shell, `boxx.tree` could visualization any struct in  tree format.   \n",
    "\n",
    "Support types include `list`, `tuple`, `dict`, `numpy`, `torch.tensor`， `mxnet.ndarray`, `PIL.Image`.etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `dira(x)` to show `x`'s all attribute\n",
    "`dira(x)` is the meaning of \"dir Attribute\".   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from boxx import dira\n",
    "\n",
    "dira(LookupError)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dira(x)` will pretty print `x`'s all attribute in tree format.    \n",
    "And `dira(x)` will print `x`'s Father Classes too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `what` to know \"What's this?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import what\n",
    "\n",
    "from boxx import ylsys\n",
    "what(ylsys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`what(x)` will show \"what is `x`?\" by pretty print it's **Document**, **Father Classes**, **Inner Struct** and **Attributes**. It is a supplement of `help(x)`\n",
    "\n",
    "💡 **Note:** \n",
    "\n",
    "`boxx.what` is a useful tool when learn a new module or package.It reduce the time to check the API document.\n",
    "\n",
    "`wtf` is the short of `what`, use `wtf-x` for convenience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try run this cell\n",
    "from collections import defaultdict\n",
    "from boxx import wtf\n",
    "\n",
    "ddict = defaultdict(lambda x:'boxx', Starman='Bowie')\n",
    "wtf-ddict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `logc` to pretty print expression by show every variable's value in expression\n",
    "`logc` is the meaning of \"Log Code\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from random import random\n",
    "from boxx import logc\n",
    "a = random()\n",
    "b = random()\n",
    "logc(\"mean = (a + b) / 2\", exe=True) # exe=True mean exec(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `heatmap` to show the time heat map of your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from boxx import heatmap\n",
    "\n",
    "heatmap('./yllab.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`heatmap` also support python code string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from boxx import heatmap\n",
    "\n",
    "code = '''\n",
    "def bad_fibonacci(x): # simulation Complex calculations\n",
    "    if x<=1 :\n",
    "        return 1\n",
    "    return x*bad_fibonacci(x-1)\n",
    "bad_fibonacci(3)\n",
    "'''\n",
    "heatmap(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `performance` could statistic function calls and visualize code performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import performance\n",
    "\n",
    "performance('./yllab.py') \n",
    "# broswer will open a web page to visualization code perfomance if possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:** if you are runing this Notebook on [Binder](https://mybinder.org/v2/gh/DIYer22/boxx/master?filepath=tutorial_for_boxx.ipynb), Browser won't open the web page. Please see demo here [performance demo.gif](https://raw.githubusercontent.com/DIYer22/boxx/master/other/gif/performance.gif)\n",
    "\n",
    "---\n",
    "\n",
    "`performance` also support python code string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = '''\n",
    "def bad_fibonacci(x): # simulation Complex calculations\n",
    "    if x<=1 :\n",
    "        return 1\n",
    "    return x*bad_fibonacci(x-1)\n",
    "bad_fibonacci(5)\n",
    "'''\n",
    "performance(code) \n",
    "# broswer will open a web page to visualization code perfomance if possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `dicto` is a convenient version of `dict`\n",
    "`dicto` is the meaning of \"dict that like Object\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import dicto\n",
    "d = {'a':22}\n",
    "\n",
    "dd = dicto(d)\n",
    "print(dd.a)\n",
    "\n",
    "dd.b = 517\n",
    "dd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**  `dicto` is sub-class of `dict` that is easy to use, allows to get and set `dict` values as attributes.  \n",
    "\n",
    "BTW, `boxx.cf` is a `dicto` instance that could save your global config, and it could be used at all your `.py` files by `from boxx import cf` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `ll` is a convenient tool for `list`\n",
    "`ll` is the meaning of \"List tooL\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from boxx import ll\n",
    "\n",
    "print(ll * 5) # instead of list(range(5))\n",
    "\n",
    "print(ll/zip([0, 1])) # quick way to do `list(x)` when x iterable\n",
    "\n",
    "ll # BTW, ll self is a list "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `sysi` include many infomation about operating environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from boxx import dira, sysi\n",
    "\n",
    "dira(sysi, pattern='^[^_]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `sysi.cpun`, `sysi.user`, `sysi.host` to let code know wether the environment is local or remote."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Scientific Computing and Computer Vision Tool\n",
    "\n",
    "The tools introduced in [**General Python Tool**](#1.-General-Python-Tool) are also useful in Scientific Computing and Computer Vision(SC&CV) field. \n",
    "\n",
    "In this section we will introduce tools that only uesed in SC&CV field.\n",
    "\n",
    "BTW. Those tools support many array-like types include `numpy`, `torch.tensor`， `mxnet.ndarray`, `PIL.Image`.etc   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `loga` for visualization matrix and tensor\n",
    "`loga` is the meaning of \"log array\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "array = np.random.normal(size=(5,3, 244, 244))\n",
    "\n",
    "from boxx import loga\n",
    "loga(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**\n",
    "\n",
    "* `loga` analysis the `numpy.ndarray` by it's shape, max, min, mean, and distribute.  \n",
    "\n",
    "* `loga` support other array-like types include list, `numpy`, `torch.tensor`, `mxnet.ndarray`, `PIL.Image`.etc\n",
    "\n",
    "* `loga` will tell you how many `nan`, `inf` in the array if array include `nan`, `inf`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "array[...,:10] = np.inf\n",
    "array[...,-10:] = -np.inf\n",
    "array[...,:10,:] = np.nan\n",
    "loga(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `tree` to visualization complex struct for Scientific Computing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# prepare images\n",
    "import numpy as np\n",
    "from skimage.io import imread\n",
    "image_path = 'test/imgForTest/img.jpg'\n",
    "ground_truth_path = 'test/imgForTest/gt_seg.png'\n",
    "Lenna = imread('test/imgForTest/Lenna.jpg')\n",
    "\n",
    "image = imread(image_path)\n",
    "ground_truth = imread(ground_truth_path)\n",
    "\n",
    "# complex struct\n",
    "batch = dict(\n",
    "    path=(image_path, ground_truth_path),\n",
    "    img=image, \n",
    "    gt=ground_truth, \n",
    "    listt=[\n",
    "        np.append(image, ground_truth[..., None], -1),\n",
    "        np.array([Lenna, Lenna]),\n",
    "    ],\n",
    ")\n",
    "\n",
    "from boxx import  tree\n",
    "print('visualization the struct:')\n",
    "tree(batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like `tree` command in shell, `boxx.tree` could visualization  complex struct (like `a batch of data`) in tree format.   \n",
    "💡 **Note:**\n",
    "\n",
    " * Support types include `list`, `tuple`, `dict`, `numpy`, `torch.tensor`， `mxnet.ndarray`, `PIL.Image`.etc   \n",
    "\n",
    " * Support sample a batch from `torch.Dataset`, `torch.DataLoader`. then visualization the batch's struct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `show` is easy to do `imshow`, even images are in complex struct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from skimage.io import imread\n",
    "Lenna = imread('test/imgForTest/Lenna.jpg')\n",
    "\n",
    "from boxx import show\n",
    "show(Lenna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "↓ `show` could find every image in complex struct and `plt.imshow` they."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# prepare images\n",
    "import numpy as np\n",
    "from skimage.io import imread\n",
    "image_path = 'test/imgForTest/img.jpg'\n",
    "ground_truth_path = 'test/imgForTest/gt_seg.png'\n",
    "Lenna = imread('test/imgForTest/Lenna.jpg')\n",
    "\n",
    "image = imread(image_path)\n",
    "ground_truth = imread(ground_truth_path)\n",
    "\n",
    "# complex struct\n",
    "batch = dict(\n",
    "    path=(image_path, ground_truth_path),\n",
    "    img=image, \n",
    "    gt=ground_truth, \n",
    "    listt=[\n",
    "        np.append(image, ground_truth[..., None], -1),\n",
    "        np.array([Lenna, Lenna]),\n",
    "    ],\n",
    ")\n",
    "\n",
    "from boxx import show, tree\n",
    "print('the struct of batch:')\n",
    "tree(batch)\n",
    "print('show all images in batch:')\n",
    "show(batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💡 **Note:**\n",
    "\n",
    " * Support image types include `numpy`, `torch.tensor`， `mxnet.ndarray`, `PIL.Image`.etc   \n",
    "\n",
    " * And Support sample a batch from `torch.Dataset`, `torch.DataLoader`, then `plt.imshow` the batch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ▶ `npa` transform other array-like object to numpy in one way\n",
    "`npa` is the meaning of \"numpy.array\", use magic method to quick transform other numpy like object to numpy, suport `torch.tensor`, `mxnet.ndarray`, `PIL.Image`, `list`, `tuple` .etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from boxx import npa\n",
    "\n",
    "print(npa-range(3))\n",
    "\n",
    "import numpy as np\n",
    "r = npa-range(3)\n",
    "npa**[r, r]"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}