{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from textwrap import dedent\n",
    "\n",
    "import pytablewriter\n",
    "\n",
    "table_name = \"example_table\"\n",
    "headers = [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"]\n",
    "data = [\n",
    "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
    "    [2, \"-2.23\", \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
    "    [3, 0, \"bar\", \"true\", \"inf\", \"2017-03-03 22:44:55+0900\"],\n",
    "    [-10, -9.9, \"\", \"FALSE\", \"nan\", \"2017-01-01 00:00:00+0900\"],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adoc\n",
      "asciidoc\n",
      "bold_unicode\n",
      "borderless\n",
      "css\n",
      "csv\n",
      "elasticsearch\n",
      "excel\n",
      "htm\n",
      "html\n",
      "javascript\n",
      "js\n",
      "json\n",
      "json_lines\n",
      "jsonl\n",
      "latex_matrix\n",
      "latex_table\n",
      "ldjson\n",
      "ltsv\n",
      "markdown\n",
      "md\n",
      "mediawiki\n",
      "ndjson\n",
      "null\n",
      "numpy\n",
      "pandas\n",
      "pandas_pickle\n",
      "py\n",
      "python\n",
      "rst\n",
      "rst_csv\n",
      "rst_csv_table\n",
      "rst_grid\n",
      "rst_grid_table\n",
      "rst_simple\n",
      "rst_simple_table\n",
      "space_aligned\n",
      "sqlite\n",
      "ssv\n",
      "toml\n",
      "tsv\n",
      "unicode\n",
      "yaml\n"
     ]
    }
   ],
   "source": [
    "for name in pytablewriter.TableWriterFactory.get_format_names():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adoc\n",
      "asc\n",
      "asciidoc\n",
      "css\n",
      "csv\n",
      "htm\n",
      "html\n",
      "js\n",
      "json\n",
      "jsonl\n",
      "ldjson\n",
      "ltsv\n",
      "md\n",
      "ndjson\n",
      "py\n",
      "rst\n",
      "sqlite\n",
      "sqlite3\n",
      "tex\n",
      "toml\n",
      "tsv\n",
      "xls\n",
      "xlsx\n",
      "yml\n"
     ]
    }
   ],
   "source": [
    "for name in pytablewriter.TableWriterFactory.get_extensions():\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# zone\n",
      "|zone_id|country_code|   zone_name    |\n",
      "|------:|------------|----------------|\n",
      "|      1|AD          |Europe/Andorra  |\n",
      "|      2|AE          |Asia/Dubai      |\n",
      "|      3|AF          |Asia/Kabul      |\n",
      "|      4|AG          |America/Antigua |\n",
      "|      5|AI          |America/Anguilla|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"zone\"\n",
    "writer.headers = [\"zone_id\", \"country_code\", \"zone_name\"]\n",
    "writer.value_matrix = [\n",
    "    [\"1\", \"AD\", \"Europe/Andorra\"],\n",
    "    [\"2\", \"AE\", \"Asia/Dubai\"],\n",
    "    [\"3\", \"AF\", \"Asia/Kabul\"],\n",
    "    [\"4\", \"AG\", \"America/Antigua\"],\n",
    "    [\"5\", \"AI\", \"America/Anguilla\"],\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Markdown table with GitHub flavor\n",
      "|                 A                 |                       B                       |\n",
      "| --------------------------------- | --------------------------------------------: |\n",
      "| $$\\textcolor{#cd3131}{\\tt{abc}}$$ |   $$\\textcolor{#0dbc79}{\\underline{\\tt{1}}}$$ |\n",
      "| $$\\textcolor{#cd3131}{\\tt{efg}}$$ |   $$\\textcolor{#0dbc79}{\\underline{\\tt{2}}}$$ |\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Style\n",
    "\n",
    "writer = MarkdownTableWriter(\n",
    "    table_name=\"Markdown table with GitHub flavor\",\n",
    "    column_styles=[\n",
    "        Style(fg_color=\"red\"),\n",
    "        Style(fg_color=\"green\", decoration_line=\"underline\"),\n",
    "    ],\n",
    "    headers=[\"A\", \"B\"],\n",
    "    value_matrix=[\n",
    "        [\"abc\", 1],\n",
    "        [\"efg\", 2],\n",
    "    ],\n",
    "    margin=1,\n",
    "    flavor=\"github\",\n",
    "    enable_ansi_escape=False,\n",
    ")\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# style filter example\n",
      "|Key|Value 1|Value 2|\n",
      "|---|------:|------:|\n",
      "|**A**|$$\\textcolor{#cd3131}{\\underline{\\tt{\\bf{95}}}}$$|$$\\textcolor{#0dbc79}{\\tt{40}}$$|\n",
      "|**B**|$$\\textcolor{#e5e510}{\\tt{\\bf{55}}}$$|$$\\textcolor{#3b8eea}{\\tt{5}}$$|\n",
      "|**C**|$$\\textcolor{#0dbc79}{\\tt{30}}$$|$$\\textcolor{#cd3131}{\\underline{\\tt{\\bf{85}}}}$$|\n",
      "|**D**|$$\\textcolor{#3b8eea}{\\tt{0}}$$|$$\\textcolor{#e5e510}{\\tt{\\bf{69}}}$$|\n"
     ]
    }
   ],
   "source": [
    "from typing import Any, Optional\n",
    "\n",
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Cell, Style\n",
    "\n",
    "\n",
    "def style_filter(cell: Cell, **kwargs: Any) -> Optional[Style]:\n",
    "    if cell.is_header_row():\n",
    "        return None\n",
    "\n",
    "    if cell.col == 0:\n",
    "        return Style(font_weight=\"bold\")\n",
    "\n",
    "    value = int(cell.value)\n",
    "\n",
    "    if value > 80:\n",
    "        return Style(fg_color=\"red\", font_weight=\"bold\", decoration_line=\"underline\")\n",
    "    elif value > 50:\n",
    "        return Style(fg_color=\"yellow\", font_weight=\"bold\")\n",
    "    elif value > 20:\n",
    "        return Style(fg_color=\"green\")\n",
    "\n",
    "    return Style(fg_color=\"lightblue\")\n",
    "\n",
    "\n",
    "writer = MarkdownTableWriter(\n",
    "    table_name=\"style filter example\",\n",
    "    headers=[\"Key\", \"Value 1\", \"Value 2\"],\n",
    "    value_matrix=[\n",
    "        [\"A\", 95, 40],\n",
    "        [\"B\", 55, 5],\n",
    "        [\"C\", 30, 85],\n",
    "        [\"D\", 0, 69],\n",
    "    ],\n",
    "    flavor=\"github\",\n",
    "    enable_ansi_escape=False,\n",
    ")\n",
    "writer.add_style_filter(style_filter)\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"int\",\"float\",\"str\",\"bool\",\"mix\",\"time\"\n",
      "0,0.1,\"hoge\",True,0,\"2017-01-01 03:04:05+0900\"\n",
      "2,-2.23,\"foo\",False,,\"2017-12-23 12:34:51+0900\"\n",
      "3,0,\"bar\",True,Infinity,\"2017-03-03 22:44:55+0900\"\n",
      "-10,-9.9,,False,NaN,\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.CsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " PID   USER  PR  NI    VIRT   RES   SHR   S  %CPU  %MEM   TIME+     COMMAND   \n",
      "32866  root  20    0   48344  3924  3448  R   5.6   0.2  0:00.03  top         \n",
      "    1  root  20    0  212080  7676  5876  S   0.0   0.4  1:06.56  systemd     \n",
      "    2  root  20    0       0     0     0  S   0.0   0.0  0:01.92  kthreadd    \n",
      "    4  root   0  -20       0     0     0  S   0.0   0.0  0:00.00  kworker/0:0H\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.SpaceAlignedTableWriter()\n",
    "writer.headers = [\n",
    "    \"PID\",\n",
    "    \"USER\",\n",
    "    \"PR\",\n",
    "    \"NI\",\n",
    "    \"VIRT\",\n",
    "    \"RES\",\n",
    "    \"SHR\",\n",
    "    \"S\",\n",
    "    \"%CPU\",\n",
    "    \"%MEM\",\n",
    "    \"TIME+\",\n",
    "    \"COMMAND\",\n",
    "]\n",
    "writer.value_matrix = csv1 = [\n",
    "    [32866, \"root\", 20, 0, 48344, 3924, 3448, \"R\", 5.6, 0.2, \"0:00.03\", \"top\"],\n",
    "    [1, \"root\", 20, 0, 212080, 7676, 5876, \"S\", 0, 0.4, \"1:06.56\", \"systemd\"],\n",
    "    [2, \"root\", 20, 0, 0, 0, 0, \"S\", 0, 0, \"0:01.92\", \"kthreadd\"],\n",
    "    [4, \"root\", 0, -20, 0, 0, 0, \"S\", 0, 0, \"0:00.00\", \"kworker/0:0H\"],\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"int\"\t\"float\"\t\"str\"\t\"bool\"\t\"mix\"\t\"time\"\n",
      "0\t0.1\t\"hoge\"\tTrue\t0\t\"2017-01-01 03:04:05+0900\"\n",
      "2\t-2.23\t\"foo\"\tFalse\t\t\"2017-12-23 12:34:51+0900\"\n",
      "3\t0\t\"bar\"\tTrue\tInfinity\t\"2017-03-03 22:44:55+0900\"\n",
      "-10\t-9.9\t\tFalse\tNaN\t\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.TsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<table id=\"example_table\">\n",
      "    <caption>example_table</caption>\n",
      "    <thead>\n",
      "        <tr>\n",
      "            <th>int</th>\n",
      "            <th>float</th>\n",
      "            <th>str</th>\n",
      "            <th>bool</th>\n",
      "            <th>mix</th>\n",
      "            <th>time</th>\n",
      "        </tr>\n",
      "    </thead>\n",
      "    <tbody>\n",
      "        <tr>\n",
      "            <td align=\"right\">0</td>\n",
      "            <td align=\"right\">0.10</td>\n",
      "            <td align=\"left\">hoge</td>\n",
      "            <td align=\"left\">True</td>\n",
      "            <td align=\"right\">0</td>\n",
      "            <td align=\"left\">2017-01-01 03:04:05+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">2</td>\n",
      "            <td align=\"right\">-2.23</td>\n",
      "            <td align=\"left\">foo</td>\n",
      "            <td align=\"left\">False</td>\n",
      "            <td align=\"right\"></td>\n",
      "            <td align=\"left\">2017-12-23 12:34:51+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">3</td>\n",
      "            <td align=\"right\">0.00</td>\n",
      "            <td align=\"left\">bar</td>\n",
      "            <td align=\"left\">True</td>\n",
      "            <td align=\"right\">Infinity</td>\n",
      "            <td align=\"left\">2017-03-03 22:44:55+0900</td>\n",
      "        </tr>\n",
      "        <tr>\n",
      "            <td align=\"right\">-10</td>\n",
      "            <td align=\"right\">-9.90</td>\n",
      "            <td align=\"left\"></td>\n",
      "            <td align=\"left\">False</td>\n",
      "            <td align=\"right\">NaN</td>\n",
      "            <td align=\"left\">2017-01-01 00:00:00+0900</td>\n",
      "        </tr>\n",
      "    </tbody>\n",
      "</table>\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.HtmlTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "const example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", true, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", false, null, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", true, Infinity, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", \"FALSE\", NaN, \"2017-01-01 00:00:00+0900\"]\n",
      "];\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JavaScriptTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "    {\n",
      "        \"int\": 0,\n",
      "        \"float\": 0.1,\n",
      "        \"str\": \"hoge\",\n",
      "        \"bool\": true,\n",
      "        \"mix\": 0,\n",
      "        \"time\": \"2017-01-01 03:04:05+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": 2,\n",
      "        \"float\": -2.23,\n",
      "        \"str\": \"foo\",\n",
      "        \"bool\": false,\n",
      "        \"mix\": null,\n",
      "        \"time\": \"2017-12-23 12:34:51+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": 3,\n",
      "        \"float\": 0,\n",
      "        \"str\": \"bar\",\n",
      "        \"bool\": \"true\",\n",
      "        \"mix\": \"Infinity\",\n",
      "        \"time\": \"2017-03-03 22:44:55+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": -10,\n",
      "        \"float\": -9.9,\n",
      "        \"str\": \"\",\n",
      "        \"bool\": \"FALSE\",\n",
      "        \"mix\": \"NaN\",\n",
      "        \"time\": \"2017-01-01 00:00:00+0900\"\n",
      "    }\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonTableWriter()\n",
    "# writer.table_name = \"Timezone\"\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"int\": 0, \"float\": 0.1, \"str\": \"hoge\", \"bool\": true, \"mix\": 0, \"time\": \"2017-01-01 03:04:05+0900\"}\n",
      "{\"int\": 2, \"float\": -2.23, \"str\": \"foo\", \"bool\": false, \"mix\": null, \"time\": \"2017-12-23 12:34:51+0900\"}\n",
      "{\"int\": 3, \"float\": 0, \"str\": \"bar\", \"bool\": \"true\", \"mix\": \"Infinity\", \"time\": \"2017-03-03 22:44:55+0900\"}\n",
      "{\"int\": -10, \"float\": -9.9, \"str\": \"\", \"bool\": \"FALSE\", \"mix\": \"NaN\", \"time\": \"2017-01-01 00:00:00+0900\"}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonLinesTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{ \"example_table\" : [\n",
      "    {\n",
      "        \"int\": 0,\n",
      "        \"float\": 0.1,\n",
      "        \"str\": \"hoge\",\n",
      "        \"bool\": true,\n",
      "        \"mix\": 0,\n",
      "        \"time\": \"2017-01-01 03:04:05+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": 2,\n",
      "        \"float\": -2.23,\n",
      "        \"str\": \"foo\",\n",
      "        \"bool\": false,\n",
      "        \"mix\": null,\n",
      "        \"time\": \"2017-12-23 12:34:51+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": 3,\n",
      "        \"float\": 0,\n",
      "        \"str\": \"bar\",\n",
      "        \"bool\": \"true\",\n",
      "        \"mix\": \"Infinity\",\n",
      "        \"time\": \"2017-03-03 22:44:55+0900\"\n",
      "    },\n",
      "    {\n",
      "        \"int\": -10,\n",
      "        \"float\": -9.9,\n",
      "        \"str\": \"\",\n",
      "        \"bool\": \"FALSE\",\n",
      "        \"mix\": \"NaN\",\n",
      "        \"time\": \"2017-01-01 00:00:00+0900\"\n",
      "    }\n",
      "]}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.JsonTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{equation}\n",
      "    A = \\left( \\begin{array}{rrr}\n",
      "        0.01 &      0.00125 & 0.000 \\\\\n",
      "        1.00 &     99.90000 & 0.010 \\\\\n",
      "        1.20 & 999999.12300 & 0.001 \\\\\n",
      "    \\end{array} \\right)\n",
      "\\end{equation}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexMatrixWriter()\n",
    "writer.table_name = \"A\"\n",
    "writer.value_matrix = [\n",
    "    [0.01, 0.00125, 0.0],\n",
    "    [1.0, 99.9, 0.01],\n",
    "    [1.2, 999999.123, 0.001],\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "    A = \\left( \\begin{array}{rrr}\n",
    "        0.01 &      0.0012 & 0.000 \\\\\n",
    "        1.00 &     99.9000 & 0.010 \\\\\n",
    "        1.20 & 999999.1230 & 0.001 \\\\\n",
    "    \\end{array} \\right)\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{equation}\n",
      "    B = \\left( \\begin{array}{llll}\n",
      "        a_{11} & a_{12} & \\ldots & a_{1n} \\\\\n",
      "        a_{21} & a_{22} & \\ldots & a_{2n} \\\\\n",
      "        \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
      "        a_{n1} & a_{n2} & \\ldots & a_{nn} \\\\\n",
      "    \\end{array} \\right)\n",
      "\\end{equation}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexMatrixWriter()\n",
    "writer.table_name = \"B\"\n",
    "writer.value_matrix = [\n",
    "    [\"a_{11}\", \"a_{12}\", \"\\\\ldots\", \"a_{1n}\"],\n",
    "    [\"a_{21}\", \"a_{22}\", \"\\\\ldots\", \"a_{2n}\"],\n",
    "    [r\"\\vdots\", \"\\\\vdots\", \"\\\\ddots\", \"\\\\vdots\"],\n",
    "    [\"a_{n1}\", \"a_{n2}\", \"\\\\ldots\", \"a_{nn}\"],\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{equation}\n",
    "    B = \\left( \\begin{array}{llll}\n",
    "        a_{11} & a_{12} & \\ldots & a_{1n} \\\\\n",
    "        a_{21} & a_{22} & \\ldots & a_{2n} \\\\\n",
    "        \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "        a_{n1} & a_{n2} & \\ldots & a_{nn} \\\\\n",
    "    \\end{array} \\right)\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{array}{r | r | l | l | l | l} \\hline\n",
      "    \\verb|int| & \\verb|float| & \\verb|str | & \\verb|bool | & \\verb| mix  | & \\verb|          time          | \\\\ \\hline\n",
      "    \\hline\n",
      "      0 &  0.10 & hoge & True  &      0 & \\verb|2017-01-01 03:04:05+0900| \\\\ \\hline\n",
      "      2 & -2.23 & foo  & False &        & \\verb|2017-12-23 12:34:51+0900| \\\\ \\hline\n",
      "      3 &  0.00 & bar  & True  & \\infty & \\verb|2017-03-03 22:44:55+0900| \\\\ \\hline\n",
      "    -10 & -9.90 &      & False & NaN    & \\verb|2017-01-01 00:00:00+0900| \\\\ \\hline\n",
      "\\end{array}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LatexTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{array}{r | r | l | l | l | l} \\hline\n",
    "    \\verb|int| & \\verb|float| & \\verb|str| & \\verb|bool| & \\verb|mix| & \\verb|time| \\\\ \\hline\n",
    "    \\hline\n",
    "    0 & 0.10 & hoge & True & 0 & \\verb|2017-01-01 03:04:05+0900| \\\\ \\hline\n",
    "    2 & -2.23 & foo & False &  & \\verb|2017-12-23 12:34:51+0900| \\\\ \\hline\n",
    "    3 & 0.00 & bar & True & \\infty & \\verb|2017-03-03 22:44:55+0900| \\\\ \\hline\n",
    "    -10 & -9.90 &  & False & NaN & \\verb|2017-01-01 00:00:00+0900| \\\\ \\hline\n",
    "\\end{array}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# example_table\n",
      "|int|float|str |bool |  mix   |          time          |\n",
      "|--:|----:|----|-----|-------:|------------------------|\n",
      "|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "|  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|\n",
      "|  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|\n",
      "|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# write example with margin=1\n",
      "| int | float | str  | bool  |   mix    |           time           |\n",
      "| --: | ----: | ---- | ----- | -------: | ------------------------ |\n",
      "|   0 |  0.10 | hoge | True  |        0 | 2017-01-01 03:04:05+0900 |\n",
      "|   2 | -2.23 | foo  | False |          | 2017-12-23 12:34:51+0900 |\n",
      "|   3 |  0.00 | bar  | True  | Infinity | 2017-03-03 22:44:55+0900 |\n",
      "| -10 | -9.90 |      | False |      NaN | 2017-01-01 00:00:00+0900 |\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "writer = MarkdownTableWriter(\n",
    "    table_name=\"write example with margin=1\",\n",
    "    headers=headers,\n",
    "    value_matrix=data,\n",
    "    margin=1,  # add a whitespace for both sides of each cell\n",
    ")\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{| class=\"wikitable\"\n",
      "|+example_table\n",
      "! int\n",
      "! float\n",
      "! str\n",
      "! bool\n",
      "! mix\n",
      "! time\n",
      "|-\n",
      "| style=\"text-align:right\"| 0\n",
      "| style=\"text-align:right\"| 0.10\n",
      "| hoge\n",
      "| True\n",
      "| style=\"text-align:right\"| 0\n",
      "| 2017-01-01 03:04:05+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| 2\n",
      "| style=\"text-align:right\"| -2.23\n",
      "| foo\n",
      "| False\n",
      "| \n",
      "| 2017-12-23 12:34:51+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| 3\n",
      "| style=\"text-align:right\"| 0.00\n",
      "| bar\n",
      "| True\n",
      "| Infinity\n",
      "| 2017-03-03 22:44:55+0900\n",
      "|-\n",
      "| style=\"text-align:right\"| -10\n",
      "| style=\"text-align:right\"| -9.90\n",
      "| \n",
      "| False\n",
      "| NaN\n",
      "| 2017-01-01 00:00:00+0900\n",
      "|}\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MediaWikiTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = np.array([\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.NumpyTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = pd.DataFrame([\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "], columns=[\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PandasDataFrameWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = pd.DataFrame([\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, np.inf, \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, np.nan, \"2017-01-01 00:00:00+0900\"],\n",
      "], columns=[\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"])\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PandasDataFrameWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "writer.is_datetime_instance_formatting = False\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, float(\"inf\"), \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, float(\"nan\"), \"2017-01-01 00:00:00+0900\"],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PythonCodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_table = [\n",
      "    [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"],\n",
      "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
      "    [2, -2.23, \"foo\", False, None, \"2017-12-23 12:34:51+0900\"],\n",
      "    [3, 0, \"bar\", True, float(\"inf\"), \"2017-03-03 22:44:55+0900\"],\n",
      "    [-10, -9.9, \"\", False, float(\"nan\"), \"2017-01-01 00:00:00+0900\"],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.PythonCodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "writer.is_datetime_instance_formatting = False\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. table:: example_table\n",
      "\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |int|float|str |bool |  mix   |          time          |\n",
      "    +===+=====+====+=====+========+========================+\n",
      "    |  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |  2|-2.23|foo |False|        |2017-12-23 12:34:51+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |  3| 0.00|bar |True |Infinity|2017-03-03 22:44:55+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n",
      "    |-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n",
      "    +---+-----+----+-----+--------+------------------------+\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstGridTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. table:: example_table\n",
      "\n",
      "    ===  =====  ====  =====  ========  ========================\n",
      "    int  float  str   bool     mix               time          \n",
      "    ===  =====  ====  =====  ========  ========================\n",
      "      0   0.10  hoge  True          0  2017-01-01 03:04:05+0900\n",
      "      2  -2.23  foo   False            2017-12-23 12:34:51+0900\n",
      "      3   0.00  bar   True   Infinity  2017-03-03 22:44:55+0900\n",
      "    -10  -9.90        False       NaN  2017-01-01 00:00:00+0900\n",
      "    ===  =====  ====  =====  ========  ========================\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstSimpleTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. csv-table:: example_table\n",
      "    :header: \"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"\n",
      "    :widths: 5, 7, 6, 6, 8, 26\n",
      "\n",
      "    0, 0.10, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"\n",
      "    2, -2.23, \"foo\", False, , \"2017-12-23 12:34:51+0900\"\n",
      "    3, 0.00, \"bar\", True, Infinity, \"2017-03-03 22:44:55+0900\"\n",
      "    -10, -9.90, , False, NaN, \"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.RstCsvTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int:0\tfloat:0.1\tstr:\"hoge\"\tbool:True\tmix:0\ttime:\"2017-01-01 03:04:05+0900\"\n",
      "int:2\tfloat:-2.23\tstr:\"foo\"\tbool:False\ttime:\"2017-12-23 12:34:51+0900\"\n",
      "int:3\tfloat:0\tstr:\"bar\"\tbool:True\tmix:Infinity\ttime:\"2017-03-03 22:44:55+0900\"\n",
      "int:-10\tfloat:-9.9\tbool:False\tmix:NaN\ttime:\"2017-01-01 00:00:00+0900\"\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.LtsvTableWriter()\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[example_table]]\n",
      "int = 0\n",
      "float = 0.1\n",
      "str = \"hoge\"\n",
      "bool = true\n",
      "mix = 0\n",
      "time = \"2017-01-01 03:04:05+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = 2\n",
      "float = -2.23\n",
      "str = \"foo\"\n",
      "bool = false\n",
      "time = \"2017-12-23 12:34:51+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = 3\n",
      "float = 0\n",
      "str = \"bar\"\n",
      "bool = true\n",
      "mix = inf\n",
      "time = \"2017-03-03 22:44:55+0900\"\n",
      "\n",
      "[[example_table]]\n",
      "int = -10\n",
      "float = -9.9\n",
      "str = \"\"\n",
      "bool = false\n",
      "mix = nan\n",
      "time = \"2017-01-01 00:00:00+0900\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.TomlTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "// without type hints: column data types detected automatically by default\n",
      "const without_type_hint = [\n",
      "    [\"header_a\", \"header_b\", \"header_c\"],\n",
      "    [-1.1, \"2017-01-02 03:04:05\", new Date(\"2017-01-02T03:04:05\")],\n",
      "    [0.12, \"2017-02-03 04:05:06\", new Date(\"2017-02-03T04:05:06\")]\n",
      "];\n",
      "\n",
      "// with type hints\n",
      "const with_type_hint = [\n",
      "    [\"header_a\", \"header_b\", \"header_c\"],\n",
      "    [-1, new Date(\"2017-01-02T03:04:05\"), \"2017-01-02 03:04:05\"],\n",
      "    [0, new Date(\"2017-02-03T04:05:06\"), \"2017-02-03 04:05:06\"]\n",
      "];\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "from pytablewriter import JavaScriptTableWriter\n",
    "\n",
    "\n",
    "def main():\n",
    "    writer = JavaScriptTableWriter()\n",
    "    writer.headers = [\"header_a\", \"header_b\", \"header_c\"]\n",
    "    writer.value_matrix = [\n",
    "        [-1.1, \"2017-01-02 03:04:05\", datetime(2017, 1, 2, 3, 4, 5)],\n",
    "        [0.12, \"2017-02-03 04:05:06\", datetime(2017, 2, 3, 4, 5, 6)],\n",
    "    ]\n",
    "\n",
    "    print(\"// without type hints: column data types detected automatically by default\")\n",
    "    writer.table_name = \"without type hint\"\n",
    "    writer.write_table()\n",
    "\n",
    "    print(\"\\n// with type hints\")\n",
    "    writer.table_name = \"with type hint\"\n",
    "    writer.type_hints = [\"int\", \"datetime\", \"str\"]\n",
    "    writer.write_table()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python_variable_without_type_hints = [\n",
      "    [\"float\", \"infnan\", \"string\", \"datetime\"],\n",
      "    [-1.1, float(\"inf\"), \"2017-01-02 03:04:05\", dateutil.parser.parse(\"2017-01-02T03:04:05\")],\n",
      "    [0.12, float(\"nan\"), \"2017-02-03 04:05:06\", dateutil.parser.parse(\"2017-02-03T04:05:06\")],\n",
      "]\n",
      "python_variable_with_type_hints = [\n",
      "    [\"hint_int\", \"hint_str\", \"hint_datetime\", \"hint_str\"],\n",
      "    [-1, float(\"inf\"), \"2017-01-02 03:04:05\", dateutil.parser.parse(\"2017-01-02T03:04:05\")],\n",
      "    [0, float(\"nan\"), \"2017-02-03 04:05:06\", dateutil.parser.parse(\"2017-02-03T04:05:06\")],\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "from pytablewriter import PythonCodeTableWriter\n",
    "\n",
    "\n",
    "def main():\n",
    "    writer = PythonCodeTableWriter()\n",
    "    writer.value_matrix = [\n",
    "        [-1.1, float(\"inf\"), \"2017-01-02 03:04:05\", datetime(2017, 1, 2, 3, 4, 5)],\n",
    "        [0.12, float(\"nan\"), \"2017-02-03 04:05:06\", datetime(2017, 2, 3, 4, 5, 6)],\n",
    "    ]\n",
    "\n",
    "    # column data types detected automatically by default\n",
    "    writer.table_name = \"python variable without type hints\"\n",
    "    writer.headers = [\"float\", \"infnan\", \"string\", \"datetime\"]\n",
    "    writer.write_table()\n",
    "\n",
    "    # set type hints\n",
    "    writer.table_name = \"python variable with type hints\"\n",
    "    writer.headers = [\"hint_int\", \"hint_str\", \"hint_datetime\", \"hint_str\"]\n",
    "    writer.type_hints = [\"int\", \"datetime\", \"str\"]\n",
    "    writer.write_table()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| i | f  | c  | if |ifc|bool |  inf   |nan|mix_num |          time           |\n",
      "|--:|---:|----|---:|---|-----|--------|---|-------:|-------------------------|\n",
      "|  1|1.10|aa  | 1.0|  1|True |Infinity|NaN|       1|2017-01-01 00:00:00+09:00|\n",
      "|  2|2.20|bbb | 2.2|2.2|False|Infinity|NaN|Infinity|2017-01-02 03:04:05+09:00|\n",
      "|  3|3.33|cccc|-3.0|ccc|True |Infinity|NaN|     NaN|2017-01-01 00:00:00+09:00|\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.from_csv(\n",
    "    dedent(\n",
    "        \"\"\"\\\n",
    "    \"i\",\"f\",\"c\",\"if\",\"ifc\",\"bool\",\"inf\",\"nan\",\"mix_num\",\"time\"\n",
    "    1,1.10,\"aa\",1.0,\"1\",True,Infinity,NaN,1,\"2017-01-01 00:00:00+09:00\"\n",
    "    2,2.20,\"bbb\",2.2,\"2.2\",False,Infinity,NaN,Infinity,\"2017-01-02 03:04:05+09:00\"\n",
    "    3,3.33,\"cccc\",-3.0,\"ccc\",True,Infinity,NaN,NaN,\"2017-01-01 00:00:00+09:00\"\n",
    "    \"\"\"\n",
    "    )\n",
    ")\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# ps\n",
      "|USER|PID|%CPU|%MEM| VSZ |RSS |TTY|STAT|START|TIME|   COMMAND    |\n",
      "|----|--:|---:|---:|----:|---:|---|----|-----|----|--------------|\n",
      "|root|  1|   0| 0.4|77664|8784|?  |Ss  |May11|0:02|/sbin/init    |\n",
      "|root|  2|   0| 0.0|    0|   0|?  |S   |May11|0:00|[kthreadd]    |\n",
      "|root|  4|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[kworker/0:0H]|\n",
      "|root|  6|   0| 0.0|    0|   0|?  |I<  |May11|0:00|[mm_percpu_wq]|\n",
      "|root|  7|   0| 0.0|    0|   0|?  |S   |May11|0:01|[ksoftirqd/0] |\n"
     ]
    }
   ],
   "source": [
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.table_name = \"ps\"\n",
    "writer.from_csv(\n",
    "    dedent(\n",
    "        \"\"\"\\\n",
    "        USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND\n",
    "        root         1  0.0  0.4  77664  8784 ?        Ss   May11   0:02 /sbin/init\n",
    "        root         2  0.0  0.0      0     0 ?        S    May11   0:00 [kthreadd]\n",
    "        root         4  0.0  0.0      0     0 ?        I<   May11   0:00 [kworker/0:0H]\n",
    "        root         6  0.0  0.0      0     0 ?        I<   May11   0:00 [mm_percpu_wq]\n",
    "        root         7  0.0  0.0      0     0 ?        S    May11   0:01 [ksoftirqd/0]\n",
    "    \"\"\"\n",
    "    ),\n",
    "    delimiter=\" \",\n",
    ")\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# specify alignment for each column manually\n",
      "|left|   right   |   center   |auto (int)|auto (str)|None (same as AUTO)|\n",
      "|----|----------:|:----------:|---------:|----------|-------------------|\n",
      "|0   |          r|center align|         0|a         |n                  |\n",
      "|11  |right align|     c      |        11|auto      |none               |\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Align, Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"specify alignment for each column manually\"\n",
    "writer.headers = [\"left\", \"right\", \"center\", \"auto (int)\", \"auto (str)\", \"None (same as AUTO)\"]\n",
    "writer.value_matrix = [\n",
    "    [0, \"r\", \"center align\", 0, \"a\", \"n\"],\n",
    "    [11, \"right align\", \"c\", 11, \"auto\", \"none\"],\n",
    "]\n",
    "\n",
    "# set alignments for each column\n",
    "writer.column_styles = [\n",
    "    Style(align=Align.LEFT),\n",
    "    Style(align=Align.RIGHT),\n",
    "    Style(align=Align.CENTER),\n",
    "    Style(align=Align.AUTO),\n",
    "    Style(align=Align.AUTO),\n",
    "    None,\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# set style by styles\n",
      "|auto align|left align|center align|\u001b[1m  bold  \u001b[0m|italic|\u001b[1mbold italic ts\u001b[0m|\n",
      "|---------:|----------|:----------:|-------:|-----:|-------------:|\n",
      "|        11|11        |     11     |\u001b[1m  **11**\u001b[0m|  _11_|\u001b[1m      _**11**_\u001b[0m|\n",
      "|      1234|1234      |    1234    |\u001b[1m**1234**\u001b[0m|_1234_|\u001b[1m   _**1,234**_\u001b[0m|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.table_name = \"set style by styles\"\n",
    "writer.headers = [\n",
    "    \"auto align\",\n",
    "    \"left align\",\n",
    "    \"center align\",\n",
    "    \"bold\",\n",
    "    \"italic\",\n",
    "    \"bold italic ts\",\n",
    "]\n",
    "writer.value_matrix = [\n",
    "    [11, 11, 11, 11, 11, 11],\n",
    "    [1234, 1234, 1234, 1234, 1234, 1234],\n",
    "]\n",
    "\n",
    "# specify styles for each column\n",
    "writer.column_styles = [\n",
    "    Style(),\n",
    "    Style(align=\"left\"),\n",
    "    Style(align=\"center\"),\n",
    "    Style(font_weight=\"bold\"),\n",
    "    Style(font_style=\"italic\"),\n",
    "    Style(font_weight=\"bold\", font_style=\"italic\", thousand_separator=\",\"),\n",
    "]\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# set style by column index\n",
      "| A  |\u001b[1m   B    \u001b[0m|  C  |\n",
      "|---:|:------:|----:|\n",
      "|  11|\u001b[1m **11** \u001b[0m|   11|\n",
      "|1234|\u001b[1m**1234**\u001b[0m|1 234|\n",
      "\n",
      "# set style by header\n",
      "| A  |  B   |  C  |\n",
      "|---:|-----:|----:|\n",
      "|  11|  _11_|   11|\n",
      "|1234|_1234_|1 234|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import Style\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.headers = [\n",
    "    \"A\",\n",
    "    \"B\",\n",
    "    \"C\",\n",
    "]\n",
    "writer.value_matrix = [[11, 11, 11], [1234, 1234, 1234]]\n",
    "\n",
    "writer.table_name = \"set style by column index\"\n",
    "writer.set_style(1, Style(align=\"center\", font_weight=\"bold\"))\n",
    "writer.set_style(2, Style(thousand_separator=\" \"))\n",
    "writer.write_table()\n",
    "writer.write_null_line()\n",
    "\n",
    "writer.table_name = \"set style by header\"\n",
    "writer.set_style(\"B\", Style(font_style=\"italic\"))\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|int|float|str |bool |  mix   |          time          |\n",
      "|--:|----:|----|-----|-------:|------------------------|\n",
      "|  0| 0.10|hoge|True |       0|2017-01-01 03:04:05+0900|\n",
      "|  2|-2.23|foo |False|        |2017-12-23 45:01:23+0900|\n",
      "|  3| 0.00|bar |True |Infinity|2017-03-03 33:44:55+0900|\n",
      "|-10|-9.90|    |False|     NaN|2017-01-01 00:00:00+0900|\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pytablewriter\n",
    "\n",
    "writer = pytablewriter.MarkdownTableWriter()\n",
    "writer.headers = [\"int\", \"float\", \"str\", \"bool\", \"mix\", \"time\"]\n",
    "writer.value_matrix = [\n",
    "    [0, 0.1, \"hoge\", True, 0, \"2017-01-01 03:04:05+0900\"],\n",
    "    [2, \"-2.23\", \"foo\", False, None, \"2017-12-23 45:01:23+0900\"],\n",
    "    [3, 0, \"bar\", \"true\", \"inf\", \"2017-03-03 33:44:55+0900\"],\n",
    "    [-10, -9.9, \"\", \"FALSE\", \"nan\", \"2017-01-01 00:00:00+0900\"],\n",
    "]\n",
    "\n",
    "print(writer.dumps())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|wo_format| comma_i |  space_f  |\n",
      "|--------:|--------:|----------:|\n",
      "|     1000|1,234,567|1 234 567.8|\n",
      "|     1000|1,234,567|1 234 567.8|\n",
      "|     1000|1,234,567|1 234 567.8|\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import MarkdownTableWriter\n",
    "from pytablewriter.style import ThousandSeparator\n",
    "\n",
    "writer = MarkdownTableWriter()\n",
    "writer.headers = [\"wo_format\", \"comma_i\", \"space_f\"]\n",
    "writer.value_matrix = [\n",
    "    [1000, 1234567, 1234567.8],\n",
    "    [1000, 1234567, 1234567.8],\n",
    "    [1000, 1234567, 1234567.8],\n",
    "]\n",
    "writer.column_styles = [\n",
    "    Style(thousand_separator=ThousandSeparator.NONE),\n",
    "    Style(thousand_separator=ThousandSeparator.COMMA),\n",
    "    Style(thousand_separator=ThousandSeparator.SPACE),\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{array}{r | r | r | r | r | r} \\hline\n",
      "    \\verb|none| & \\verb|empty_style| & \\verb|   tiny    | & \\verb|   small    | & \\verb|     medium      | & \\verb|   large    | \\\\ \\hline\n",
      "    \\hline\n",
      "     111 &         111 &  \\tiny{111} &  \\small{111} &  \\normalsize{111} &  \\large{111} \\\\ \\hline\n",
      "    1234 &        1234 & \\tiny{1234} & \\small{1234} & \\normalsize{1234} & \\large{1234} \\\\ \\hline\n",
      "\\end{array}\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import LatexTableWriter\n",
    "from pytablewriter.style import Style, FontSize\n",
    "\n",
    "writer = LatexTableWriter()\n",
    "writer.table_name = \"style test: font size\"\n",
    "writer.headers = [\"none\", \"empty_style\", \"tiny\", \"small\", \"medium\", \"large\"]\n",
    "writer.value_matrix = [[111, 111, 111, 111, 111, 111], [1234, 1234, 1234, 1234, 1234, 1234]]\n",
    "writer.column_styles = [\n",
    "    None,\n",
    "    Style(),\n",
    "    Style(font_size=FontSize.TINY),\n",
    "    Style(font_size=FontSize.SMALL),\n",
    "    Style(font_size=FontSize.MEDIUM),\n",
    "    Style(font_size=FontSize.LARGE),\n",
    "]\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\begin{array}{r | r | r | r | r | r} \\hline\n",
    "    \\verb|none| & \\verb|empty_style| & \\verb|tiny| & \\verb|small| & \\verb|medium| & \\verb|large| \\\\ \\hline\n",
    "    \\hline\n",
    "     111 &         111 & \\tiny 111 & \\small 111 & \\normalsize 111 & \\large 111 \\\\ \\hline\n",
    "    1234 &        1234 & \\tiny 1234 & \\small 1234 & \\normalsize 1234 & \\large 1234 \\\\ \\hline\n",
    "\\end{array}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌───┬─────┬────┬─────┬────────┬────────────────────────┐\n",
      "│int│float│str │bool │  mix   │          time          │\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  0│ 0.10│hoge│True │       0│2017-01-01 03:04:05+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  2│-2.23│foo │False│        │2017-12-23 12:34:51+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│  3│ 0.00│bar │True │Infinity│2017-03-03 22:44:55+0900│\n",
      "├───┼─────┼────┼─────┼────────┼────────────────────────┤\n",
      "│-10│-9.90│    │False│     NaN│2017-01-01 00:00:00+0900│\n",
      "└───┴─────┴────┴─────┴────────┴────────────────────────┘\n"
     ]
    }
   ],
   "source": [
    "from pytablewriter import UnicodeTableWriter\n",
    "\n",
    "writer = UnicodeTableWriter()\n",
    "writer.table_name = table_name\n",
    "writer.headers = headers\n",
    "writer.value_matrix = data\n",
    "\n",
    "writer.write_table()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| i | f  | c  | if |ifc|bool |  inf   |nan|mix_num |          time           |\n",
      "|--:|---:|----|---:|---|-----|--------|---|-------:|-------------------------|\n",
      "|  1|1.10|aa  | 1.0|  1|True |Infinity|NaN|       1|2017-01-01 00:00:00+09:00|\n",
      "|  2|2.20|bbb | 2.2|2.2|False|Infinity|NaN|Infinity|2017-01-02 03:04:05+09:00|\n",
      "|  3|3.33|cccc|-3.0|ccc|True |Infinity|NaN|     NaN|2017-01-01 00:00:00+09:00|\n"
     ]
    }
   ],
   "source": [
    "from textwrap import dedent\n",
    "import pandas as pd\n",
    "import io\n",
    "from pytablewriter import MarkdownTableWriter\n",
    "\n",
    "\n",
    "def main():\n",
    "    csv_data = io.StringIO(\n",
    "        dedent(\n",
    "            \"\"\"\\\n",
    "        \"i\",\"f\",\"c\",\"if\",\"ifc\",\"bool\",\"inf\",\"nan\",\"mix_num\",\"time\"\n",
    "        1,1.10,\"aa\",1.0,\"1\",True,Infinity,NaN,1,\"2017-01-01 00:00:00+09:00\"\n",
    "        2,2.20,\"bbb\",2.2,\"2.2\",False,Infinity,NaN,Infinity,\"2017-01-02 03:04:05+09:00\"\n",
    "        3,3.33,\"cccc\",-3.0,\"ccc\",True,Infinity,NaN,NaN,\"2017-01-01 00:00:00+09:00\"\n",
    "        \"\"\"\n",
    "        )\n",
    "    )\n",
    "    df = pd.read_csv(csv_data, sep=\",\")\n",
    "\n",
    "    writer = MarkdownTableWriter(dataframe=df)\n",
    "    writer.write_table()\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e1c230d0d7838db35080269a6918dd30585979c6f8544df43693174aeb261eb3"
  },
  "kernelspec": {
   "display_name": "Python 3.8.11 64-bit ('3.8.11': pyenv)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}