{"id":45942752,"url":"https://github.com/hvalev/py-markdown-table","last_synced_at":"2026-02-28T10:52:24.259Z","repository":{"id":37702050,"uuid":"320022049","full_name":"hvalev/py-markdown-table","owner":"hvalev","description":"Tiny python library with zero dependencies which generates formatted multiline tables in markdown","archived":false,"fork":false,"pushed_at":"2025-11-22T09:40:50.000Z","size":180,"stargazers_count":52,"open_issues_count":2,"forks_count":9,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-11-22T11:27:12.526Z","etag":null,"topics":["markdown","python3","table"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hvalev.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2020-12-09T16:55:54.000Z","updated_at":"2025-11-22T09:40:47.000Z","dependencies_parsed_at":"2024-04-25T20:28:36.161Z","dependency_job_id":"89b28e9c-6153-411d-81e4-aa0e2bbb3a31","html_url":"https://github.com/hvalev/py-markdown-table","commit_stats":null,"previous_names":["hvalev/markdowntable"],"tags_count":16,"template":false,"template_full_name":null,"purl":"pkg:github/hvalev/py-markdown-table","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hvalev%2Fpy-markdown-table","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hvalev%2Fpy-markdown-table/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hvalev%2Fpy-markdown-table/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hvalev%2Fpy-markdown-table/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hvalev","download_url":"https://codeload.github.com/hvalev/py-markdown-table/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hvalev%2Fpy-markdown-table/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29930694,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-28T09:58:13.507Z","status":"ssl_error","status_checked_at":"2026-02-28T09:57:57.047Z","response_time":90,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["markdown","python3","table"],"created_at":"2026-02-28T10:52:23.779Z","updated_at":"2026-02-28T10:52:24.242Z","avatar_url":"https://github.com/hvalev.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# py-markdown-table\n[![build](https://github.com/hvalev/py-markdown-table/actions/workflows/build.yml/badge.svg)](https://github.com/hvalev/py-markdown-table/actions/workflows/build.yml)\n[![codecov](https://codecov.io/gh/hvalev/py-markdown-table/branch/main/graph/badge.svg?token=ZZ8WXO4H6P)](https://codecov.io/gh/hvalev/py-markdown-table)\n[![Downloads](https://static.pepy.tech/badge/py-markdown-table)](https://pepy.tech/project/py-markdown-table)\n[![Downloads](https://static.pepy.tech/badge/py-markdown-table/month)](https://pepy.tech/project/py-markdown-table)\n[![Downloads](https://static.pepy.tech/badge/py-markdown-table/week)](https://pepy.tech/project/py-markdown-table)\n\nTiny python library with zero dependencies which generates formatted multiline tables in `markdown`. \n\n## Basic Use\nInstall via pip as follows: \n```bash\npip install py-markdown-table\n```\n\nPass a `list` of `dict`s where the `dict`s must have uniform keys which serve as column headers and the values are expanded to be rows. Simple example with no special formatting:\n```python\nfrom py_markdown_table.markdown_table import markdown_table\ndata = [\n    {\n        \"Product\": \"Smartphone\",\n        \"Brand\": \"Apple\",\n        \"Price\": 999.99\n    },\n    {\n        \"Product\": \"Laptop\",\n        \"Brand\": \"Dell\",\n        \"Price\": 1299.99\n    }\n]\nmarkdown = markdown_table(data).get_markdown()\nprint(markdown)\n```\n\n```\n+------------------------+\n|  Product |Brand| Price |\n+----------+-----+-------+\n|Smartphone|Apple| 999.99|\n+----------+-----+-------+\n|  Laptop  | Dell|1299.99|\n+------------------------+\n```\n\nA more comprehensive example showcasing some of the formatting options:\n```python\nfrom py_markdown_table.markdown_table import markdown_table\njokes_list = [\n    {\n        \"joke1\": \"Why don't scientists trust atoms? Because they make up everything!\",\n        \"joke2\": \"Did you hear about the mathematician who's afraid of negative numbers? He will stop at nothing to avoid them!\",\n        \"joke3\": \"Why don't skeletons fight each other? They don't have the guts!\"\n    },\n    {\n        \"joke1\": \"What do you call a snowman with a six-pack? An abdominal snowman!\",\n        \"joke2\": \"Why don't eggs tell jokes? Because they might crack up!\",\n        \"joke3\": \"How does a penguin build its house? Igloos it together!\"\n    }\n]\nmarkdown = markdown_table(jokes_list).set_params(padding_width = 3, \n                                                 padding_weight = 'centerleft', \n                                                 multiline = {'joke1': 30, 'joke2': 30, 'joke3': 30}\n                                                 ).get_markdown()\n```\n```\n+--------------------------------------------------------------------------------------------------------------+\n|                joke1               |                joke2               |                joke3               |\n+------------------------------------+------------------------------------+------------------------------------+\n|  Why don't scientists trust atoms? |       Did you hear about the       |   Why don't skeletons fight each   |\n|  Because they make up everything!  |    mathematician who's afraid of   |  other? They don't have the guts!  |\n|                                    |  negative numbers? He will stop at |                                    |\n|                                    |       nothing to avoid them!       |                                    |\n+------------------------------------+------------------------------------+------------------------------------+\n|  What do you call a snowman with a |     Why don't eggs tell jokes?     |    How does a penguin build its    |\n|   six-pack? An abdominal snowman!  |    Because they might crack up!    |     house? Igloos it together!     |\n+--------------------------------------------------------------------------------------------------------------+\n```\n\nYou can also use pandas dataframes by formatting them as follows:\n```python\nfrom py_markdown_table.markdown_table import markdown_table\ndata = df.to_dict(orient='records')\nmarkdown_table(data).get_markdown()\n```\n\n## Advanced Use\nTo add parameters to how the markdown table is formatted, you can use the `set_params()` function on a `markdown_table` object, i.e. `markdown_table(data).set_params(...).get_markdown()`, which allows you to pass the following keyword arguments:\n\n```\n+--------------------------------------------------------------------------------------------------+\n|         param         |         type        |       values      |           description          |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|        row_sep        |         str         |                   |  Row separation strategy using |\n|                       |                     |                   |        `----` as pattern       |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |       always      |        Separate each row       |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |     topbottom     |  Separate the top (header) and |\n|                       |                     |                   | bottom (last row) of the table |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |      markdown     | Separate only header from body |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |        None       |    No row separators will be   |\n|                       |                     |                   |            inserted            |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|     padding_width     |        int or       |                   |  Allocate padding to all table |\n|                       |    dict\u003cstr,int\u003e    |                   |  cells when passing an int or  |\n|                       |                     |                   | per-column when passing a dict |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|     padding_weight    |        str or       |                   |     Strategy for allocating    |\n|                       |    dict\u003cstr,str\u003e    |                   |   padding within table cells.  |\n|                       |                     |                   | Per-column when passing a dict |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |        left       |  Aligns the cell's contents to |\n|                       |                     |                   |       the end of the cell      |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |       right       |  Aligns the cell's contents to |\n|                       |                     |                   |    the beginning of the cell   |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |     centerleft    |  Centers cell's contents with  |\n|                       |                     |                   | extra padding allocated to the |\n|                       |                     |                   |      beginning of the cell     |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |    centerright    |  Centers cell's contents with  |\n|                       |                     |                   | extra padding allocated to the |\n|                       |                     |                   |         end of the cell        |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|      padding_char     |         str         |                   |  Single character used to fill |\n|                       |                     |                   |   padding with. Default is a   |\n|                       |                     |                   |        blank space ` `.        |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|      newline_char     |         str         |                   | Character appended to each row |\n|                       |                     |                   | to force a newline. Default is |\n|                       |                     |                   |              `\\n`              |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|     float_rounding    |         int         |                   | Integer denoting the precision |\n|                       |                     |                   | of cells of `floats` after the |\n|                       |                     |                   |    decimal point. Default is   |\n|                       |                     |                   |             `None`.            |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|     emoji_spacing     |         str         |                   |  Strategy for rendering emojis |\n|                       |                     |                   |    in tables. Currently only   |\n|                       |                     |                   |     `mono` is supported for    |\n|                       |                     |                   |  monospaced fonts. Default is  |\n|                       |                     |                   |  `None` which disables special |\n|                       |                     |                   |       handling of emojis.      |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|       multiline       |    dict\u003cAny,int\u003e    |                   |     Renders the table with     |\n|                       |                     |                   | predefined widths by passing a |\n|                       |                     |                   |  `dict` with `keys` being the  |\n|                       |                     |                   |  column names (e.g. equivalent |\n|                       |                     |                   |  to those in the passed `data` |\n|                       |                     |                   |  variable) and `values` -- the |\n|                       |                     |                   |  `width` of each column as an  |\n|                       |                     |                   |  integer. Note that the width  |\n|                       |                     |                   |  of a column cannot be smaller |\n|                       |                     |                   |   than the longest contiguous  |\n|                       |                     |                   |   string present in the data.  |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|   multiline_strategy  |         str         |                   |  Strategy applied to rendering |\n|                       |                     |                   |   contents in multiple lines.  |\n|                       |                     |                   |   Possible values are `rows`,  |\n|                       |                     |                   | `header` or `rows_and_header`. |\n|                       |                     |                   |  The default value is `rows`.  |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |        rows       |  Splits only rows overfilling  |\n|                       |                     |                   | by the predefined column width |\n|                       |                     |                   | as provided in the `multiline` |\n|                       |                     |                   |            variable            |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |       header      |     Splits only the header     |\n|                       |                     |                   |  overfilling by the predefined |\n|                       |                     |                   |   column width as provided in  |\n|                       |                     |                   |    the `multiline` variable    |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|                       |                     |  rows_and_header  |     Splits rows and header     |\n|                       |                     |                   |  overfilling by the predefined |\n|                       |                     |                   |   column width as provided in  |\n|                       |                     |                   |    the `multiline` variable    |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|  multiline_delimiter  |         str         |                   | Character that will be used to |\n|                       |                     |                   |  split a cell's contents into  |\n|                       |                     |                   |   multiple rows. The default   |\n|                       |                     |                   |   value is a blank space ` `.  |\n+-----------------------+---------------------+-------------------+--------------------------------+\n|         quote         |         bool        |                   |  Wraps the generated markdown  |\n|                       |                     |                   |      table in block quotes     |\n|                       |                     |                   |     ```table```. Default is    |\n|                       |                     |                   |             `True`.            |\n+--------------------------------------------------------------------------------------------------+\n```\n## Utils\nThe namespace `py_markdown_table.utils` provides the functions `count_emojis()` and `find_longest_contiguous_strings()`. `count_emojis()` detects emojis and their position in a given string, and `find_longest_contiguous_strings()` finds the longest continuous strings present in the rows and/or columns of your input data. `find_longest_contiguous_strings()` can be useful to figure out the minimal width of each column given a particular data.\n\n## Further Examples\n### Row separatation\n```python\nmarkdown_table(data).set_params(row_sep = 'always').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+----------------------------------------+\n|    title   |    time   |   date  |seats|\n+------------+-----------+---------+-----+\n|Vrij Zwemmen|21:30-23:00|Wed 09.12|24/24|\n+------------+-----------+---------+-----+\n|Vrij Zwemmen|12:00-13:00|Thu 10.12|18/18|\n+------------+-----------+---------+-----+\n|Vrij zwemmen| 7:30-8:30 |Fri 11.12|18/18|\n+------------+-----------+---------+-----+\n|Vrij Zwemmen|13:15-14:15|Sat 12.12|18/18|\n+----------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n```python\nmarkdown_table(data).set_params(row_sep = 'topbottom').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+----------------------------------------+\n|    title   |    time   |   date  |seats|\n|Vrij Zwemmen|21:30-23:00|Wed 09.12|24/24|\n|Vrij Zwemmen|12:00-13:00|Thu 10.12|18/18|\n|Vrij zwemmen| 7:30-8:30 |Fri 11.12|18/18|\n|Vrij Zwemmen|13:15-14:15|Sat 12.12|18/18|\n+----------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n```python\nmarkdown_table(data).set_params(row_sep = 'markdown').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n|    title   |    time   |   date  |seats|\n|------------|-----------|---------|-----|\n|Vrij Zwemmen|21:30-23:00|Wed 09.12|24/24|\n|Vrij Zwemmen|12:00-13:00|Thu 10.12|18/18|\n|Vrij zwemmen| 7:30-8:30 |Fri 11.12|18/18|\n|Vrij Zwemmen|13:15-14:15|Sat 12.12|18/18|\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = 'markdown', quote = False).get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n|    title   |    time   |   date  |seats|\n|------------|-----------|---------|-----|\n|Vrij Zwemmen|21:30-23:00|Wed 09.12|24/24|\n|Vrij Zwemmen|12:00-13:00|Thu 10.12|18/18|\n|Vrij zwemmen| 7:30-8:30 |Fri 11.12|18/18|\n|Vrij Zwemmen|13:15-14:15|Sat 12.12|18/18|\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n### Padding, padding weight and padding char\n```python\nmarkdown_table(data).set_params(row_sep = 'topbottom', padding_width = 5, padding_weight = 'left').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------------------+\n|            title|            time|          date|     seats|\n|     Vrij Zwemmen|     21:30-23:00|     Wed 09.12|     24/24|\n|     Vrij Zwemmen|     12:00-13:00|     Thu 10.12|     18/18|\n|     Vrij zwemmen|       7:30-8:30|     Fri 11.12|     18/18|\n|     Vrij Zwemmen|     13:15-14:15|     Sat 12.12|     18/18|\n+------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = 'topbottom', padding_width = 5, padding_weight = 'centerright').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------------------+\n|      title      |      time      |     date     |  seats   |\n|  Vrij Zwemmen   |  21:30-23:00   |  Wed 09.12   |  24/24   |\n|  Vrij Zwemmen   |  12:00-13:00   |  Thu 10.12   |  18/18   |\n|  Vrij zwemmen   |   7:30-8:30    |  Fri 11.12   |  18/18   |\n|  Vrij Zwemmen   |  13:15-14:15   |  Sat 12.12   |  18/18   |\n+------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = 'always', padding_width = 5, padding_weight = 'centerright', padding_char = '.').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------------------+\n|......title......|......time......|.....date.....|..seats...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..21:30-23:00...|..Wed 09.12...|..24/24...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..12:00-13:00...|..Thu 10.12...|..18/18...|\n+-----------------+----------------+--------------+----------+\n|..Vrij zwemmen...|...7:30-8:30....|..Fri 11.12...|..18/18...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..13:15-14:15...|..Sat 12.12...|..18/18...|\n+------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n```python\nmarkdown_table(data).set_params(row_sep = 'always', padding_width = 5, padding_weight = 'centerright', padding_char = '.').get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------------------+\n|......title......|......time......|.....date.....|..seats...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..21:30-23:00...|..Wed 09.12...|..24/24...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..12:00-13:00...|..Thu 10.12...|..18/18...|\n+-----------------+----------------+--------------+----------+\n|..Vrij zwemmen...|...7:30-8:30....|..Fri 11.12...|..18/18...|\n+-----------------+----------------+--------------+----------+\n|..Vrij Zwemmen...|..13:15-14:15...|..Sat 12.12...|..18/18...|\n+------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n### Per-column padding and padding weight\n```python\nmarkdown_table(data).set_params(row_sep = 'always', padding_width = {\"title\": 2, \"time\": 4, \"date\": 3, \"seats\": 1}, padding_weight = {\"title\": \"left\", \"time\": \"right\", \"date\": \"centerleft\", \"seats\": \"centerright\"}).get_markdown()\n\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+--------------------------------------------------+\n|         title|time           |    date    |seats |\n+--------------+---------------+------------+------+\n|  Vrij Zwemmen|21:30-23:00    |  Wed 09.12 |24/24 |\n+--------------+---------------+------------+------+\n|  Vrij Zwemmen|12:00-13:00    |  Thu 10.12 |18/18 |\n+--------------+---------------+------------+------+\n|  Vrij Zwemmen|7:30-8:30      |  Fri 11.12 |18/18 |\n+--------------+---------------+------------+------+\n|  Vrij Zwemmen|13:15-14:15    |  Sat 12.12 |18/18 |\n+--------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = 'always', padding_width = {\"A\": 2, \"B\": 4, \"C\": 3}, padding_weight = {\"A\": \"left\", \"B\": \"right\", \"C\": \"centerleft\"}).get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+-----------------------------------------------------------------------+\n|                            A|B                              |    C    |\n+-----------------------------+-------------------------------+---------+\n|  row1_A and additional stuff|row1_B                         |  row1_C |\n+-----------------------------+-------------------------------+---------+\n|                       row2_A|row2_B and additional stuff    |  row2_C |\n+-----------------------------+-------------------------------+---------+\n|                       row3_A|row3_B                         |  row3_C |\n+-----------------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n### Multiline and emoji\n```python\nmarkdown_table(data).set_params(padding_width = 0, padding_weight = \"centerleft\", multiline = {\"A\": 25, \"B\": 12, \"C\": 9}).get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------+\n|            A            |      B     |    C    |\n+-------------------------+------------+---------+\n|  row1_A and additional  |   row1_B   |  row1_C |\n|          stuff          |            |         |\n+-------------------------+------------+---------+\n|          row2_A         | row2_B and |  row2_C |\n|                         | additional |         |\n|                         |    stuff   |         |\n+-------------------------+------------+---------+\n|          row3_A         |   row3_B   |  row3_C |\n+------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(padding_width = 2, padding_weight = \"centerleft\", multiline = {\"A\": 25, \"B\": 12, \"C\": 9}).get_markdown())\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+------------------------------------------------------------+\n|              A              |        B       |      C      |\n+-----------------------------+----------------+-------------+\n| row1_A and additional stuff |     row1_B     |    row1_C   |\n+-----------------------------+----------------+-------------+\n|            row2_A           |   row2_B and   |    row2_C   |\n|                             |   additional   |             |\n|                             |      stuff     |             |\n+-----------------------------+----------------+-------------+\n|            row3_A           |     row3_B     |    row3_C   |\n+------------------------------------------------------------+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = \"always\", multiline = {\"those are multi rows\": 5}, multiline_strategy = \"rows_and_header\").get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n\n```\n+-----+\n|those|\n| are |\n|multi|\n| rows|\n+-----+\n| yes |\n| they|\n| are |\n+-----+\n|  no |\n| they|\n| are |\n| not |\n+-----+\n```\n\u003c/details\u003e\n\u003cbr/\u003e\n\n\n```python\nmarkdown_table(data).set_params(row_sep = \"topbottom\", emoji_spacing = \"mono\", multiline = {\"title that is maybe too long\": 7, \"time\": 11, \"date\": 5, \"seats\": 5,}, multiline_strategy = \"rows_and_header\").get_markdown()\n```\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see example\n    \u003c/summary\u003e\n*Note:* Github's markdown preview does not render emojis as two whole characters, hence the slight offsets in cells containing emojis. \n\n```\n+-------------------------------+\n| title |    time   | date|seats|\n|that is|           |     |     |\n| maybe |           |     |     |\n|  too  |           |     |     |\n|  long |           |     |     |\n|  Vrij |21:30-23:00|  😊 |24/24|\n|Zwemmen|           |     |     |\n|  Vrij |12:00-13:00| Thu |18/18|\n|Zwemmen|           |10.12|     |\n|  Vrij | 7:30-8:30 | Fri |  😊 |\n|Zwemmen|           |11.12|🌍 🎉|\n|  Vrij |13:15-14:15| Sat |20/20|\n|Zwemmen|           |12.12|     |\n|  Vrij | 7:30-8:30 | Fri | asd |\n|Zwemmen|           |11.12|  😊-|\n|       |           |     | 🌍: |\n|       |           |     |  🎉 |\n|Zwemmen|13:15-14:15| Sat |20/20|\n|       |           |12.12|     |\n+-------------------------------+\n```\n\nBelow is an example from a monospaced terminal, where the table is rendered correctly.\n\n![Table with emoji in terminal](res/table_w_emoji.jpg)\n\u003c/details\u003e\n\n\n## Benchmarks\nThe table below provide some benchmark results, evaluating the performance on data containing incrementally larger number of `columns`, `rows`, and characters in each table cell (i.e. `cell_size`). You can benchmark it on your own system using the script contained within `py_markdown_table/utils/benchmark.py`. Generally, reasonably-sized tables intended to be read by a human can be generated within a millisecond. \n\n\u003cdetails\u003e\n    \u003csummary \u003e\n    see benchmark\n    \u003c/summary\u003e\n\n```\n+-----------------------------------------------+\n|    parameters    |Multiline|       speed      |\n+------------------+---------+------------------+\n|    columns: 2    |  False  |    0.000000 ms   |\n|     rows: 10     |         |                  |\n|   cell_size: 5   |         |                  |\n+------------------+---------+------------------+\n|    columns: 4    |  False  |    0.000000 ms   |\n|     rows: 40     |         |                  |\n|   cell_size: 20  |         |                  |\n+------------------+---------+------------------+\n|    columns: 8    |  False  |    6.999756 ms   |\n|     rows: 160    |         |                  |\n|   cell_size: 80  |         |                  |\n+------------------+---------+------------------+\n|    columns: 16   |  False  |  1173.794678 ms  |\n|     rows: 640    |         |                  |\n|  cell_size: 320  |         |                  |\n+------------------+---------+------------------+\n|    columns: 2    |   True  |    0.000000 ms   |\n|     rows: 10     |         |                  |\n|   cell_size: 5   |         |                  |\n+------------------+---------+------------------+\n|    columns: 4    |   True  |    0.996338 ms   |\n|     rows: 40     |         |                  |\n|   cell_size: 20  |         |                  |\n+------------------+---------+------------------+\n|    columns: 8    |   True  |   16.038330 ms   |\n|     rows: 160    |         |                  |\n|   cell_size: 80  |         |                  |\n+------------------+---------+------------------+\n|    columns: 16   |   True  |  1448.473633 ms  |\n|     rows: 640    |         |                  |\n|  cell_size: 320  |         |                  |\n+-----------------------------------------------+\n```\n\u003c/details\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhvalev%2Fpy-markdown-table","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhvalev%2Fpy-markdown-table","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhvalev%2Fpy-markdown-table/lists"}