df2tables 0.0.8__py2.py3-none-any.whl

df2tables/__init__.py

@@ -0,0 +1,2 @@
+from .df2tables import *
+# from .comnt import render, write_from_template

df2tables/comnt.py

@@ -0,0 +1,227 @@
+#!/usr/bin/python
+# coding=utf8
+from sys import exc_info
+"""
+Comnt - template content using block-annotated comments
+
+A dead-simple, human-friendly way to manage template regions using
+**standard comment syntax** — no weird symbols, no broken files, no preprocessing
+to view your code in a browser.
+
+One huge practical benefit: you can inject actual JavaScript-ready values from Python—
+not just strings or you can refer to javascript functions defined elsewhere.
+That means you don’t need to wrap your data in quotes and then call
+`JSON.parse(...)` on the frontend, like you often do with Jinja2.
+
+Supported tag/comment Formats:
+    HTML/XML style:
+        <!--[tag_name-->
+        Content to be replaced
+        <!--tag_name]-->
+
+    JavaScript/CSS style:
+        /*[tag_name*/
+       const arr_to_change = [0,1]
+        /*tag_name]*/
+
+Tag Format Rules:
+    - Opening tag: Comment start + '[' + tag_name + Comment continuation
+    - Closing tag: Comment start + tag_name + ']' + Comment end
+    - Tag names must match exactly between opening and closing tags
+
+Author: [Tomasz Sługocki]
+Version: 0.0.1
+"""
+
+__all__ = ['render', 'write_from_template', 'simple_example', 'example']
+
+
+class NotFoundError(Exception):
+    pass
+
+
+def _render_block(text, tag_id, val=None):
+    assert isinstance(text, str) and isinstance(tag_id, str)
+    assert len(text) > len(tag_id)
+
+    assert val is None or isinstance(val, str)
+
+    def get_tags(text, tag_id, ext):
+        assert ext in ("html", "js")
+        start, end = ("/*", "*/") if ext == "js" else ("<!--", "-->")
+        start_tag_js, start_tag_html = f"/*[{tag_id}*/", f"<!--[{tag_id}-->"
+        if start_tag_js in text and start_tag_html in text:
+            raise AssertionError(f"same tag id in javascript and html is not allowed")
+        start_tag = "".join((start, "[", tag_id, end))
+        end_tag = "".join((start, tag_id, "]", end))
+        start_cnt = len(text.split(start_tag)) - 1
+        end_cnt = len(text.split(end_tag)) - 1
+        if not start_cnt and not end_cnt:
+            raise ValueError(f"not found tags {start_tag} {end_tag}, ext:{ext}")
+        if not start_cnt:
+            raise NotFoundError(f"start tag not found in form: '{start_tag}'")
+        if not end_cnt:
+            raise NotFoundError(f"end tag not found in form: '{end_tag}'")
+        if start_cnt > 1:
+            raise AssertionError(f"more than one start tag: '{start_tag}'")
+        if end_cnt > 1:
+            raise AssertionError(f"more than one end tag: '{end_tag}'")
+        return start_tag, end_tag
+
+    start_tag, end_tag = None, None
+    errs = []
+    for ext in ["js", "html"]:
+        try:
+            start_tag, end_tag = get_tags(text, tag_id, ext)
+        except ValueError:
+            errs.append(repr(exc_info()[1]))
+    if not start_tag:
+        raise ValueError(f"Errors happened: {''.join(errs)}")
+
+    start_idx = text.find(start_tag)
+    end_idx = text.find(end_tag)
+    prefix = text[:start_idx + len(start_tag)]
+    suffix = text[end_idx:]
+
+    if val is None:  # empty strings are ok
+        old_val = text[start_idx + len(start_tag):end_idx]
+        return old_val
+    return "\n".join((prefix, val, suffix))
+
+
+def get_tag_content(tag, instr):
+    assert len(instr) > len(tag) and tag + instr
+    return _render_block(instr, tag, None)
+
+
+def render(instr, repldict):
+    for key, val in repldict.items():
+        try:
+            instr = _render_block(instr, key, val)
+        except ValueError:
+            print(exc_info()[1])
+
+    return instr
+
+
+def write_from_template(template, newfile, repldict):
+    assert isinstance(repldict, dict)
+    assert template != newfile
+    with open(template, encoding="utf-8") as op_file:
+        instr = op_file.read()
+    replaced = render(instr, repldict)
+    with open(newfile, "w", encoding="utf8") as outfile:
+        outfile.write(replaced)
+    return True
+
+
+def example():
+    import os
+    import subprocess
+    import sys
+
+    def open_file(filename):
+        if sys.platform.startswith("win"):
+            os.startfile(filename)
+        else:
+            opener = "open" if sys.platform == "darwin" else "xdg-open"
+            subprocess.call([opener, filename])
+
+    content = """
+    <!DOCTYPE html>
+    <html>
+       <head>
+          <title>
+             Example  comnt rendered page
+            </title>
+
+       </head>
+       <body> <h3>
+           <!--[title-->
+             Welcome to our site!
+
+          <!--title]--></h3>
+          <!--[content-->
+
+          <p>
+             This is placeholder content that shows in the browser.
+          </p>
+          <!--content]-->
+          <code id="data-display" style=
+             "background-color: rgb(245, 245, 245); padding: 10px; border: 1px solid rgb(221, 221, 221);">
+             </code>
+          <script>
+             // Example data array for
+             const data = /*[data_arr*/ [0, 1]
+             /*data_arr]*/;
+
+             document.addEventListener('DOMContentLoaded', function() {
+                 // Display data array in paragraph (like Python's repr)
+                 const dataDisplay = document.getElementById('data-display');
+                 dataDisplay.textContent = JSON.stringify(data, null, 2);
+             });
+          </script>
+       </body>
+    </html>
+    """
+
+    outstr = render(
+        content,
+        {
+            "title": "Example rendered python object",
+            "content": "<p>Below python range rendered as javascript variable</p>",
+            "data_arr": repr(list(range(10))),  # dont even need json here
+            # , 'none_existing' : '0'
+        },
+    )
+    file_name = os.path.join(os.getcwd(), "comnt_test.html")
+    with open(file_name, "w", encoding="utf8") as outfile:
+        outfile.write(outstr)
+    open_file(file_name)
+
+
+def simple_example():
+    import json
+    import os
+    import subprocess
+    import sys
+
+    def open_file(filename):
+        if sys.platform.startswith("win"):
+            os.startfile(filename)
+        else:
+            opener = "open" if sys.platform == "darwin" else "xdg-open"
+            subprocess.call([opener, filename])
+
+    content = """
+    <!DOCTYPE html>
+    <p id="title"> </p>
+    <div id="data_arr"></div>
+    <script>
+    const title = /*[title*/
+        "Example title"
+    /*title]*/;
+    const data = /*[data_arr*/
+        [0, 1]
+    /*data_arr]*/;
+
+      document.getElementById("data_arr").textContent = JSON.stringify(data);
+      document.getElementById("title").textContent = title;
+    </script>
+    """
+    outstr = render(
+        content,
+        {
+            "title": json.dumps("Example rendered python object"),
+            "data_arr": json.dumps(list(range(10))),
+        },
+    )
+    file_name = os.path.join(os.getcwd(), "comnt_simple.html")
+    with open(file_name, "w", encoding="utf8") as outfile:
+        outfile.write(outstr)
+    open_file(file_name)
+
+
+if __name__ == "__main__":
+    # simple_example()
+    example()

df2tables/datatable_templ.html

@@ -0,0 +1,374 @@
+<!doctype html>
+<html>
+
+<head>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/purecss@3.0.0/build/pure-min.css"
+    integrity="sha384-X38yfunGUhNzHpBaEBsWLO+A0HDYOQi8ufWDkZ0k9e0eXz/tH3II7uKZ9msv++Ls" crossorigin="anonymous" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>DataFrame</title>
+  <script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
+  <link href="https://cdn.datatables.net/2.3.2/css/dataTables.dataTables.min.css" rel="stylesheet" />
+  <script src="https://cdn.datatables.net/2.3.2/js/dataTables.min.js"></script>
+  <style>
+    .dataTables_wrapper {
+      margin-top: 20px;
+    }
+
+    td.dt-nowrap {
+      white-space: nowrap;
+    }
+
+    table.dataTable.display tbody td {
+      white-space: nowrap;
+    }
+
+    table.dataTable.display tbody td span {
+      float: right;
+    }
+
+    .dt-info {
+      padding: 1em;
+      font-size: 10pt;
+      color: gray;
+    }
+
+    custom.select {
+      color: black;
+      max-width: 15.5em;
+      margin: 1px;
+    }
+
+    table.dataTable span.dtcc span.dtcc-button-icon {
+      color: #000ee7;
+      line-height: var(--dtcc-button-icon_size);
+    }
+
+    :root {
+      --dtcc-button_opacity: 0.3;
+    }
+
+    .dtlogo {
+      opacity: 0.5;
+      width: auto;
+      display: block;
+      z-index: 2;
+      position: absolute;
+      top: 0px;
+      right: 0px;
+      margin: 1em;
+    }
+
+    .dt-info {
+      padding: 0;
+      font-size: 9pt;
+      color: gray;
+    }
+
+    span.dt-column-title {
+      white-space: wrap;
+    }
+  </style>
+</head>
+
+<body>
+  <!--[min_content-->
+
+  <div class="pure-g">
+    <div class="pure-u-1 pure-u-md-1-1">
+      <div id="tabcnt" style="width: fit-content; margin-left: 1em">
+        <p>
+          <!--[title-->
+          Example dataframe
+          <!--title]-->
+        </p>
+
+        <p id="testp"></p>
+
+        <table id="pd_datatab" class="display compact hover order-column" style="font-size: 10pt"></table>
+      </div>
+    </div>
+    <script type="text/javascript">
+      (function () {
+        function _anyNumber(a) {
+          var reg = /[+-]?((\d+(\.\d*)?)|\.\d+)([eE][+-]?[0-9]+)?/;
+          if (typeof a === "string") {
+            a = a.replace(",", ".").replace(" ", "").match(reg);
+            a = a !== null ? parseFloat(a[0]) : Number.POSITIVE_INFINITY;
+          }
+          return a;
+        }
+
+        jQuery.extend(jQuery.fn.dataTableExt.oSort, {
+          "num-html-pre": function (a) {
+            var x = String(a).replace(/<[\s\S]*?>/g, "");
+            return parseFloat(_anyNumber(x));
+          },
+
+          "num-html-asc": function (a, b) {
+            return a < b ? -1 : a > b ? 1 : 0;
+          },
+
+          "num-html-desc": function (a, b) {
+            return a < b ? 1 : a > b ? -1 : 0;
+          },
+        });
+        const render_num = (data, type) => {
+          const number = DataTable.render.number(" ", ",", 2).display(data);
+
+          if (type !== "display") return number;
+
+          const color = data < 0 ? "red" : "black";
+          return '<span style="color:' + color + '">' + number + "</span>";
+        };
+
+        const select_cols = /*[select_cols*/[2, 6];
+        /*select_cols]*/
+        const tab_data =
+          /*[tab_data*/
+          [
+            [
+              "2025-07-01T08:52:56.760930",
+              0.09,
+              "ZZ",
+              -0.33,
+              -1000,
+              "a",
+              "1",
+              -1,
+              "AA",
+            ],
+            [
+              "Lorem ipsum dolor sit amet, consectetur adipiscing",
+              -0.59,
+              "BB",
+              1.0,
+              1,
+              "BB",
+              "0",
+              1,
+              "QQQ",
+            ],
+            [
+              "<b>Integer</b> laoreet odio et.",
+              0.2,
+              "BB",
+              -9.0,
+              2,
+              "BB",
+              "1",
+              2,
+              "CC",
+            ],
+            [NaN, -0.49, "CC", 4.0, 3, "CC", "0", 1, "0"],
+            [
+              " class 'datetime.datetime' ",
+              -0.18,
+              "CC",
+              2.0,
+              4,
+              "CC",
+              "1",
+              1,
+              "1",
+            ],
+            [
+              " function sample_df. locals . lambda  at 0x7a5c64431d00 ",
+              -0.8,
+              "ZZ",
+              3.0,
+              5,
+              "F",
+              "0",
+              0,
+              "0",
+            ],
+            ["C", -0.52, "ZZ", 1111.11, 70000, "X ", "0", 0, "0"],
+          ];
+        /*tab_data]*/
+
+        const columns =
+          /*[tab_columns*/
+          [
+            { title: "col1", searchable: true },
+            {
+              title: "col2",
+              searchable: true,
+              render: render_num,
+              type: "num-html",
+            },
+            { title: "Long column title  ", orderable: false },
+            {
+              title: "col4",
+              searchable: true,
+              render: render_num,
+              type: "num-html",
+            },
+            {
+              title: "col5",
+              searchable: true,
+              render: render_num,
+              type: "num-html",
+            },
+            { title: "col6", searchable: true },
+            { title: "col7", orderable: false },
+            { title: "col8", searchable: true },
+            { title: "col9", searchable: true },
+          ];
+        /*tab_columns]*/
+
+        const search_columns =
+          /*[search_columns*/
+          ["col1", "col3", "col6", "col7", "col9"];
+        /*search_columns]*/
+
+        var cc_defs =
+          /*[column_control*/
+          [
+            { targets: [2, 6], columnControl: [["searchList"]] },
+            {
+              targets: [0, 1, 3, 4, 5, 7, 8],
+              columnControl: ["order", "searchDropdown"],
+            },
+          ];
+        /*column_control]*/
+
+        DataTable.defaults.layout = {
+          topStart: "info",
+          top1Start: "search",
+          topEnd: null,
+          bottomStart: null,
+          bottomEnd: null,
+          bottom: "paging",
+        };
+
+        const build_table = function (cc_defs) {
+          const table = $("#pd_datatab").DataTable({
+            data: tab_data,
+            autoWidth: /*[auto_width*/ true /*auto_width]*/,
+            columns: columns,
+            pageLength: 100,
+            responsive: true,
+            scrollX: false,
+            order: [],
+            columnDefs: cc_defs,
+            initComplete: function () {
+              const searchableColumns = search_columns;
+              const searchNote = $("<p>")
+                .css({
+                  "margin-bottom": "10px",
+                  "font-size": "0.7em",
+                  color: "#666",
+                })
+                .text(
+                  "Search is enabled for text columns: " +
+                  searchableColumns.join(", "),
+                );
+              $("#pd_datatab_wrapper").prepend(searchNote);
+            },
+          });
+        };
+
+        const loadScript = function (src) {
+          return new Promise(function (resolve, reject) {
+            var s;
+            s = document.createElement("script");
+            s.src = src;
+            s.onload = resolve;
+            s.onerror = reject;
+            document.head.appendChild(s);
+          });
+        };
+
+        const loadStyle = function (url) {
+          return new Promise((resolve, reject) => {
+            let link = document.createElement("link");
+            link.type = "text/css";
+            link.rel = "stylesheet";
+            link.onload = () => {
+              resolve();
+              //~               console.log("style has loaded");
+            };
+            link.onerror = reject;
+            link.href = url;
+
+            let headScript = document.querySelector("script");
+            headScript.parentNode.insertBefore(link, headScript);
+          });
+        };
+
+        const load_many = function (scripts_arr, callback) {
+          function load_next(idx) {
+            if (idx >= scripts_arr.length) {
+              if (callback) {
+                callback();
+              }
+              return;
+            }
+            var c_url = scripts_arr[idx];
+
+            loadScript(c_url)
+              .then(
+                function () {
+                  console.log(c_url);
+                  load_next(++idx);
+                },
+                function () {
+                  build_table();
+                  $("#error_info").append(
+                    "<em>!error column control not loaded </em>",
+                  );
+                },
+              )
+              .catch(console.log("catch", c_url));
+          }
+          load_next(0);
+        };
+
+        const render_inline = /*[render_inline*/ true; /*render_inline]*/
+
+        const load_column_control = /*[load_column_control*/ true;
+        /*load_column_control]*/
+
+        const columncontrol_js = [
+          "https://cdn.datatables.net/columncontrol/1.0.6/js/dataTables.columnControl.js",
+          "https://cdn.datatables.net/columncontrol/1.0.6/js/columnControl.dataTables.js",
+        ];
+
+        const columncontrol_css =
+          "https://cdn.datatables.net/columncontrol/1.0.6/css/columnControl.dataTables.css";
+
+
+
+        $(document).ready(function () {
+          if (load_column_control) {
+            // Load CSS first
+            loadStyle(columncontrol_css).then(() => {
+              // Then load JavaScript files
+              load_many(columncontrol_js, function () {
+                // Finally build table wrapped in setTimeout
+                setTimeout(() => {
+                  build_table(cc_defs);
+                }, 0);
+              });
+            }, () => {
+              $("#error_info").append("<em> style not loaded </em>");
+            });
+          } else {
+            build_table();
+          }
+        });
+      })();
+    </script>
+    <!--min_content]-->
+
+    <figure class="dtlogo">
+      <img src="https://upload.wikimedia.org/wikipedia/commons/a/a4/Datatables_logo_square.png" width="20"
+        style="display: block; margin-left: auto; margin-right: auto" />
+      <figcaption style="text-align: center">
+        <small style="font-size: 9px"><a target="blank" href="https://datatables.net">DataTables.net</a></small>
+      </figcaption>
+    </figure>
+  </div>
+</body>
+
+</html>

df2tables/df2tables.py

@@ -0,0 +1,275 @@
+#!/usr/bin/python
+# coding=utf8
+import json
+import os
+import subprocess
+import sys
+from functools import partial
+
+import numpy as np
+import pandas as pd
+
+TEMPLATE_FILE = "datatable_templ.html"
+try:
+    # python 3.9+
+    from importlib import resources
+
+    TEMPLATE_PATH = str(resources.files("df2tables").joinpath(TEMPLATE_FILE))
+except ImportError:
+    TEMPLATE_PATH = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), TEMPLATE_FILE
+    )
+
+try:
+    from .comnt import get_tag_content
+    from .comnt import render as c_render
+except ImportError:
+    from comnt import get_tag_content
+    from comnt import render as c_render
+
+__all__ = [
+    "TEMPLATE_PATH",
+    "render",
+    "render_inline",
+    "render_sample_df",
+    "get_sample_df",
+]
+
+
+def open_file(filename):
+    if sys.platform.startswith("win"):
+        os.startfile(filename)
+    else:
+        opener = "open" if sys.platform == "darwin" else "xdg-open"
+        subprocess.call([opener, filename])
+
+
+class DataJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder with fallback to string representation"""
+
+    def default(self, obj):
+        try:
+            obj_type = str(type(obj))
+            if "str" in obj_type:
+                return obj.strip()
+            elif "date" in obj_type or "Timestamp" in obj_type:
+                return obj.isoformat()
+            elif "int" in obj_type:
+                return int(obj)
+            elif "float" in obj_type:
+                return round(float(obj), 2)
+            elif "bool" in obj_type:
+                return bool(obj)
+            elif isinstance(obj, (np.void)):
+                return 0
+            return super().default(obj)
+        except BaseException:
+            print("json error: ", repr(obj), sys.exc_info()[1])
+            # Fallback to string representation for any problematic objects
+            return repr(obj).replace("<", " ").replace(">", " ")
+
+
+def fix_df_columns(df):
+    for col in df.columns:
+        try:
+            test_val = (
+                df[col].dropna().values.tolist() if not df[col].isna().all() else None
+            )
+            json.dumps(test_val, cls=DataJSONEncoder)
+        except BaseException:
+            print(f"! column error: {col}", sys.exc_info())
+            df[col] = df[col].apply(lambda x: repr(x) if not pd.isna(x) else None)
+    return df
+
+
+def render(
+    df,
+    title="Title",
+    precision=2,
+    num_html=[],
+    to_file=None,
+    startfile=True,
+    templ_path=TEMPLATE_PATH,
+    load_column_control=True,
+    # the maximum number of unique values in a column that qualifies it as categorical
+    # (and therefore eligible for a dropdown filter).
+    dropdown_select_threshold=5,
+):
+    assert isinstance(df, pd.DataFrame)
+    assert isinstance(title, str)
+    assert isinstance(load_column_control, bool)
+
+    if "MultiIndex" in repr(df.columns):  # experimental
+        df.columns = ["_".join(x) for x in df.columns]
+
+    missing_cols = set(num_html).difference(df.columns)
+    if missing_cols:
+        raise AssertionError(f"column(s): {missing_cols} not found in dataframe")
+
+    float_cols = df.select_dtypes(include=[np.float16, np.float32, np.float64])
+    str_cols = df.select_dtypes(include=["object", "string"]).columns
+    df.loc[:, float_cols.columns] = np.round(float_cols, precision)
+
+    try:
+        data_arrays = df.values.tolist()
+        data_json = json.dumps(data_arrays, cls=DataJSONEncoder)
+    except:
+        print(" json error", sys.exc_info())
+        df = fix_df_columns(df)
+        data_arrays = df.values.tolist()
+        data_json = json.dumps(data_arrays, cls=DataJSONEncoder)
+
+    columns, select_cols = [], []
+    for i, col in enumerate(df.columns):
+        try:
+            nunique = df[col].nunique()
+        except TypeError:
+            # for nested rows unhashable type ex: 'list'
+            df[col] = df[col].apply(lambda x: repr(x))
+            nunique = df[col].nunique()
+        
+        if len(col) > 20 and '_' in col:
+            col = col.replace('_', ' ')
+            
+        if nunique < dropdown_select_threshold:
+            select_cols.append(i)  # columns when  dropdown select makes  sense
+            col_def = {"title": col, "orderable": True}
+        else:
+            col_def = {"title": col, "searchable": True, "orderable": True}
+        if col in num_html:
+            col_def["render"] = "#render_num"
+            col_def["type"] = "num-html"
+        columns.append(col_def)
+    column_control = [
+        {
+            "targets": select_cols,
+            "columnControl": [["order", "searchList"]],
+        },
+        {
+            "targets": list(set(range(len(df.columns))).difference(select_cols)),
+            "columnControl": ["order", "searchDropdown"],
+        },
+    ]
+    columns_json = json.dumps(columns)
+    if num_html:
+        #  we need properly refer to javascript function defined in template
+        # json must have string so get rid of the quotes
+        columns_json = columns_json.replace('"#render_num"', "render_num")
+
+    auto_width = True if len(df.index) < 100 else False
+
+    template_vars = {
+        "title": str(title),
+        "auto_width": json.dumps(auto_width),
+        "tab_data": data_json,
+        "tab_columns": columns_json,
+        "search_columns": json.dumps(list(str_cols)),
+        "select_cols": json.dumps(select_cols),
+        "column_control": json.dumps(column_control),
+        "load_column_control": json.dumps(load_column_control),
+    }
+    with open(templ_path, encoding="utf-8") as op_file:
+        instr = op_file.read()
+    html = c_render(instr, template_vars)
+    if not to_file:
+        return html
+    assert templ_path != to_file and templ_path not in to_file
+    with open(to_file, "w", encoding="utf8") as outfile:
+        outfile.write(html)
+    if startfile:
+        open_file(to_file)
+    return outfile
+
+
+_render_str = partial(render, to_file=None)
+
+
+def render_inline(df, **kwargs):
+    if "to_file" in kwargs:
+        print(
+            f"wrong argument:[to_file] {kwargs.pop('to_file')} is not allowed in render_inline"
+        )
+        # del kwargs['to_file']
+    html = _render_str(df, **kwargs)
+    min_content = c_render(
+        get_tag_content("min_content", html), {"render_inline": "true"}
+    )
+    return min_content
+
+
+def get_sample_df():
+    import datetime
+    import random
+
+    healthcare = ["Low priority", "Medium priority", "High priority", "Emergency"]
+    product = ["Premium", "Standard", "Budget"]
+    grades = ["A", "B", "C", "D", "F"]
+    return pd.DataFrame(
+        {
+            "col1": [
+                datetime.datetime.now(),
+                "Lorem ipsum dolor sit amet, consectetur adipiscing",
+                "<b>Integer</b> laoreet odio et.",
+                np.nan,
+                datetime.datetime,
+                0,  # lambda x: 1 / x,
+                "C",
+            ],
+            "col2": [0.09, -0.591, 0.201, -0.487, -0.175, -0.797, -0.519],
+            "Column 3": [random.choice(grades) for x in range(7)],
+            # "col3": [["ZZ","AA"], {'BB' : 1, 'BB' : 2}, "CC", "CC","CC", "ZZ", "ZZ"], #error rows
+            "col4": [-0.333, 1, -9, 4, 2, 3, 1111.111],
+            "col5": [-1000, 1, 2, 3, 4, 5, 70_000],
+            "col6": [random.choice(product) for x in range(7)],
+            "col7": ["1", "0", "1", "0", "1", "0", "0"],
+            "col8": [-1, 1, 2, 1, 1, 0, 0],
+            "col9": [random.choice(healthcare) for x in range(7)],
+        }
+    )
+
+
+def render_sample_df(to_file="df_table.html"):
+    df = get_sample_df()
+    result = render(
+        df,
+        to_file=to_file,
+        title="Example dataframe",
+        num_html=["col5", "col4", "col2"],
+        load_column_control=True,
+        dropdown_select_threshold=5,
+    )
+    return result
+
+def main():
+    print(render_sample_df(to_file="1test.html"))
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

df2tables-0.0.8.dist-info/METADATA

@@ -0,0 +1,397 @@
+Metadata-Version: 2.4
+Name: df2tables
+Version: 0.0.8
+Summary: df2tables: Pandas DataFrames to Interactive DataTables
+Project-URL: Homepage, https://github.com/ts-kontakt/df2tables
+Project-URL: Issues, https://github.com/ts-kontakt/df2tables/issues
+Author-email: Tomasz Sługocki <ts.kontakt@gmail.com>
+License-Expression: MIT
+License-File: LICENCE.txt
+Requires-Dist: numpy
+Requires-Dist: pandas
+Description-Content-Type: text/markdown
+
+# df2tables: Pandas DataFrames to Interactive DataTables
+
+`df2tables` is a Python utility for exporting `pandas.DataFrame` objects to interactive HTML tables using [DataTables](https://datatables.net/)—an excellent JavaScript library for table functionality. It generates standalone `.html` files viewable in any browser without Jupyter notebooks, servers, or frameworks.
+
+Useful for data inspection, feature engineering workflows, especially with large datasets that need interactive exploration.
+
+## Installation
+
+```bash
+pip install df2tables
+```
+
+## Screenshots
+A standalone html file containing a js array as data source for datatables has several advantages, e.g. you can browse quite large datasets locally (something you don't usually do on a server). 
+The column control feature provides dropdown filters for categorical data and search functionality for text columns, enhancing data exploration capabilities through the excellent [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/).
+(By default, filtering is enabled for all non-numeric columns)
+
+Below is an example of 1 million rows with additional html rendering.
+
+![df2tables demo with 1 000 000 rows](https://github.com/ts-kontakt/df2tables/blob/main/df2tables-big.gif?raw=true)
+
+## Features
+
+- Converts `pandas.DataFrame` to interactive standalone HTML tables
+- You can browse **quite large data sets** using filters and sorting
+- **DataTables Column Control integration**: Smartly leverages the powerful [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) for automatic dropdown filters and advanced search functionality, loaded programmatically via JavaScript
+- Self-contained HTML files with embedded data—no external dependencies at runtime
+- Works independently of Jupyter or web servers—viewable offline in any browser, portable and easy to share
+- Color-coded formatting for numeric columns
+- **Useful for some training dataset inspection and feature engineering**: Quickly browse through large datasets, identify outliers, and data quality issues interactively
+- **Minimal HTML snippet generation**: Generate embeddable HTML content for Flask or other web frameworks
+- Easy customizable HTML 
+- **Smart column detection**: Automatically identifies categorical columns (≤5 unique values by default) for dropdown filtering
+
+## Quick Start
+
+```python
+import pandas as pd
+import df2tables as df2t
+
+df = pd.DataFrame({
+    "Name": ["Alice", "Bob", "Carol"],
+    "Score": [92.5, -78.3, 85.0],
+    "Joined": pd.to_datetime(["2021-01-05", "2021-02-10", "2021-03-15"])
+})
+
+# Basic usage with color-coded numeric columns
+df2t.render(
+    df,
+    title="User Scores",
+    precision=1,
+    num_html=["Score"],
+    to_file="output.html",
+    startfile=True
+)
+```
+
+## Main Functions
+
+### render
+
+```python
+df2t.render(
+    df: pd.DataFrame,
+    title: str = "Title",
+    precision: int = 2,
+    num_html: List[str] = [],
+    to_file: Optional[str] = None,
+    startfile: bool = True,
+    templ_path: str = TEMPLATE_PATH,
+    load_column_control: bool = True,
+    dropdown_select_threshold: int = 5
+) -> Union[str, file_object]
+```
+
+**Parameters:**
+- `df`: Input pandas DataFrame
+- `title`: Title for the HTML table
+- `precision`: Number of decimal places for floating-point numbers
+- `num_html`: List of numeric column names to render with color-coded HTML formatting (negative values in red)
+- `to_file`: Output HTML file path. If None, returns HTML string instead of writing file
+- `startfile`: If True, automatically opens the generated HTML file in default browser
+- `templ_path`: Path to custom HTML template (uses default if not specified)
+- `load_column_control`: If True, smartly integrates the exceptional [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) programmatically for enhanced filtering and search capabilities (default: True)
+- `dropdown_select_threshold`: Maximum number of unique values in a column to qualify for dropdown filtering (default: 5)
+
+**Returns:**
+- HTML string if `to_file=None`
+- File object if `to_file` is specified
+
+### render_inline
+
+```python
+df2t.render_inline(
+    df: pd.DataFrame,
+    **kwargs
+) -> str
+```
+
+Generates minimal HTML content suitable for embedding in Flask or other web framework templates. This function:
+- Returns only the table markup and JavaScript data bindings
+- Excludes full HTML document structure (no `<html>`, `<head>`, `<body>` tags)
+- **Important**: Does NOT automatically load jQuery or DataTables libraries - you must include these dependencies in your host page
+- Perfect for embedding interactive data previews in existing web applications
+
+**Parameters:**
+- Same as `render()` except `to_file` is not allowed (always returns string)
+
+### Column Name Formatting
+
+For better readability in table headers, `df2tables` automatically converts underscores to spaces in column names when the column name is longer than 20 characters and contains underscores. This improves word wrapping and prevents excessively wide columns.
+To disable this automatic word wrapping behavior, add the following CSS to your custom template:
+```css
+span.dt-column-title { 
+    white-space: nowrap; 
+}
+```
+
+## Web Framework Integration
+
+The `render_inline()` function makes it easy to embed interactive DataTables in web applications. **Important**: You must include the required JavaScript libraries (jQuery, DataTables) in your host page as `render_inline()` does not automatically include them.
+
+### Complete Flask Example
+
+Here's a complete, **working** Flask application that demonstrates how to properly embed a DataTable with all required dependencies:
+
+```python
+import df2tables as df2t
+from flask import Flask, render_template_string
+
+app = Flask(__name__)
+
+@app.route("/")
+def home():
+    # Generate sample data (or use your own DataFrame)
+    df = df2t.get_sample_df()
+    # For larger datasets, you might use:
+    # df = generate_large_dataframe(10000)  # Your data source
+    
+    df_title = "DataFrame Rendered as DataTable inline in <strong>Flask</strong>"
+    
+    # Generate the embeddable DataTable HTML
+    string_datatable = df2t.render_inline(
+        df,
+        title=df_title,
+        dropdown_select_threshold=5,
+        load_column_control=True,
+    )
+    
+    # Embed in a complete HTML template with all required dependencies
+    return render_template_string(
+        """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Flask Data Dashboard</title>
+            <meta name="viewport" content="width=device-width, initial-scale=1">
+            
+            <!-- Required: jQuery must be loaded first -->
+            <script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
+            
+            <!-- Required: DataTables CSS and JS -->
+            <link href="https://cdn.datatables.net/2.3.2/css/dataTables.dataTables.min.css" rel="stylesheet">
+            <script src="https://cdn.datatables.net/2.3.2/js/dataTables.min.js"></script>
+            
+            <!-- Optional: PureCSS for styling -->
+            <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/purecss@3.0.0/build/pure-min.css">
+        </head>
+        <body style="background-color: #f4f4f4;">
+            <div style="background-color: #fff; padding: 20px; margin: 20px;">
+                <h1>My Flask Data Dashboard</h1>
+                {{ inline_datatable | safe }}
+            </div>
+        </body>
+        </html>
+        """,
+        inline_datatable=string_datatable,
+    )
+
+if __name__ == "__main__":
+    app.run(debug=True)
+```
+
+**Key points for web framework integration:**
+
+- **Required dependencies**: Always include jQuery and DataTables CSS/JS in your host page
+- **Column Control**: When `load_column_control=True`, the extension is loaded automatically by the generated JavaScript
+- **Self-contained data**: The `render_inline()` function includes all table data and initialization code
+- **Smart filtering**: Automatic dropdown filters for categorical columns
+
+
+### DataTables Column Control Extension Integration
+
+The `load_column_control` parameter enables smart integration with the remarkable [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/), bringing professional-grade filtering capabilities to your data tables:
+
+- **Categorical columns** (≤`dropdown_select_threshold` unique values): Get elegant dropdown select filters (`searchList`) for intuitive data filtering
+- **Text/numeric columns**: Benefit from sophisticated search functionality (`searchDropdown`) and ordering controls
+- **Intelligent detection**: The module automatically identifies column types and applies the most appropriate Column Control features
+- **Seamless loading**: The outstanding [Column Control extension](https://datatables.net/extensions/columncontrol/) is loaded dynamically via JavaScript, ensuring optimal performance and compatibility
+
+```python
+# Enable smart integration with DataTables Column Control extension (default)
+df2t.render(df, load_column_control=True, to_file="enhanced_table.html")
+
+# Disable Column Control for simpler tables
+df2t.render(df, load_column_control=False, to_file="simple_table.html")
+
+# Customize dropdown threshold
+df2t.render(df, dropdown_select_threshold=10, to_file="custom_table.html")
+```
+
+### get_sample_df / render_sample_df
+
+```python
+# Get sample DataFrame for testing
+sample_df = df2t.get_sample_df()
+
+# Generate and render sample DataFrame
+html_string = df2t.render_sample_df(to_file="sample_table.html")
+```
+
+## Fast Dataset Browsing
+
+One of the key strengths of `df2tables` is its ability to quickly generate interactive HTML tables for rapid dataset exploration. The combination of standalone HTML files and the [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) makes it exceptionally fast to browse through multiple datasets.
+
+### Bulk Dataset Processing
+
+For exploratory data analysis across multiple datasets, you can generate tables programmatically. The example below uses the [vega_datasets](https://github.com/altair-viz/vega_datasets) package, which provides easy access to a variety of sample datasets commonly used in data visualization and analysis.
+
+
+
+**Note**: Install vega_datasets with `pip install vega_datasets` to run this example.
+### Quick browse first 10 vega datasets
+```python
+import df2tables as df2t
+from vega_datasets import data
+
+# WARNING: This will open many browser tabs! Use with caution.
+# Consider setting startfile=False for bulk processing.
+
+for dataset_name in (sorted(dir(data))[:10]):
+    dataset_func = getattr(data, dataset_name)
+    try:
+        df = dataset_func()
+        print(f"{dataset_name}: {len(df.index)} rows")
+        
+        # df2tables can handle datasets above 100k rows, but we limit to smaller datasets 
+        # for this demo to avoid generating too many large files
+        if len(df.index) < 100_000:
+            df2t.render(
+                df, 
+                title=f'Dataset: {dataset_name}',
+                to_file=f'{dataset_name}.html',
+                startfile=True  
+            )
+    except Exception as e:
+        print(f'Error processing {dataset_name}: {e}')
+
+print("Generated HTML files. Open them manually to browse datasets.")
+```
+
+**⚠️ Important Note**: When `startfile=True` (default), each generated HTML file opens automatically in your default browser. For bulk processing, set `startfile=False` to avoid opening dozens of browser tabs simultaneously.
+
+### Benefits for Fast Browsing
+
+- **Instant loading**: HTML files with embedded data load immediately without server dependencies
+- **Interactive filtering**: The [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) enables quick data exploration
+- **Offline browsing**: Generated files work completely offline
+- **Portable**: Share HTML files easily with colleagues for collaborative data exploration
+
+
+## Requirements
+
+- Python 3.7+
+- pandas
+- numpy
+
+## Technical Details
+
+### DataTables Column Control Extension Integration
+
+The module smartly integrates with the exceptional [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) for optimal user experience:
+
+- **Select columns**: Columns with ≤`dropdown_select_threshold` unique values get sophisticated dropdown filters (`searchList`) via Column Control
+- **Search columns**: Other columns benefit from Column Control's advanced search functionality (`searchDropdown`) and ordering controls
+- **Dynamic loading**: The [Column Control extension](https://datatables.net/extensions/columncontrol/) JavaScript libraries are loaded programmatically to maintain clean templates
+- **Robust fallback**: If the Column Control extension cannot be loaded, tables gracefully fall back to standard DataTables functionality
+
+### Error Handling
+
+The module includes  error handling for:
+- **JSON serialization**: Custom encoder handles complex pandas data types
+- **Column compatibility**: Automatically converts problematic column types to string representation
+- **Missing columns**: Validates `num_html` column names against DataFrame columns
+- **Script loading**: Graceful fallback if the [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) cannot be loaded
+
+## TODO / Future Enhancements
+
+### DataTables Configuration Expansion
+
+Currently, `df2tables` uses a predefined set of DataTables configuration options. Future versions could expose more DataTables initialization parameters directly from Python:
+
+
+## License
+
+MIT License  
+© Tomasz Sługocki
+
+## Appendix: Template Customization
+
+### Offline Usage
+*Note: "Offline" viewing assumes internet connectivity for CDN resources (DataTables, jQuery, PureCSS, [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/)). For truly offline usage, modify the template to reference local copies of these libraries instead of CDN links.*
+
+Templates use [comnt](https://github.com/ts-kontakt/comnt), a minimal markup system based on HTML/JS comments.
+
+```html
+<!--[title-->
+My Table Title
+<!--title]-->
+
+const data = /*[tab_data*/ [...] /*tab_data]*/;
+```
+The default HTML template includes:
+- **PureCSS** (CDN) for responsive styling
+- **DataTables 2.3.2** (CDN) for table interactivity
+- **jQuery 3.7.1** (CDN)
+- **[DataTables Column Control Extension](https://datatables.net/extensions/columncontrol/)** (CDN) - the outstanding Column Control extension loaded programmatically when enabled
+- JavaScript enhancements for sorting HTML-formatted numbers and coloring negative values
+
+### DataTables Column Control Extension CDN Resources
+
+When `load_column_control=True`, the following resources from the excellent [DataTables Column Control extension](https://datatables.net/extensions/columncontrol/) are loaded dynamically:
+
+```javascript
+// JavaScript libraries loaded programmatically
+const columncontrol_js = [
+    "https://cdn.datatables.net/columncontrol/1.0.6/js/dataTables.columnControl.js",
+    "https://cdn.datatables.net/columncontrol/1.0.6/js/columnControl.dataTables.js"
+];
+
+// CSS loaded after JavaScript initialization
+const columncontrol_css = 
+    "https://cdn.datatables.net/columncontrol/1.0.6/css/columnControl.dataTables.css";
+```
+
+While [comnt](https://github.com/ts-kontakt/comnt) is used to ensure that the HTML template just works independently (and avoid Json.parse), you can also use other templating systems like Jinja2 by rendering the final content after.
+
+### Custom Templates
+
+Copy and modify `datatable_templ.html` to apply custom styling or libraries, then pass the new template path to `templ_path`.
+
+### Customization
+
+```python
+# Return HTML string for further processing
+html_content = df2t.render(df, to_file=None)
+
+# Generate minimal HTML for embedding (requires jQuery/DataTables in host page)
+html_snippet = df2t.render_inline(df, title="Embedded Table")
+
+# Use custom template
+df2t.render(
+    df,
+    to_file="custom_output.html",
+    templ_path="my_custom_template.html"
+)
+
+# Disable DataTables Column Control extension for custom implementations
+df2t.render(
+    df,
+    to_file="basic_table.html",
+    load_column_control=False
+)
+
+# Adjust dropdown threshold for categorical columns
+df2t.render(
+    df,
+    dropdown_select_threshold=10,  # Columns with ≤10 unique values get dropdowns
+    to_file="custom_filtering.html"
+)
+
+# Handle MultiIndex columns (experimental)
+# MultiIndex columns are automatically flattened with underscore separation
+```

df2tables-0.0.8.dist-info/RECORD

@@ -0,0 +1,8 @@
+df2tables/__init__.py,sha256=Ry5LO4692ZzOnP1mf7Z8VU4FWXx_h2e6vKwue1jEFGg,74
+df2tables/comnt.py,sha256=BeVQLMnCVhX39nP3cfMPrIe85bQV8zRTg0pNFw2TFJ0,6931
+df2tables/datatable_templ.html,sha256=ERpNwSS9RRRltTcPhtJFIC1Z-6aPALg4FPs-SlSuCbk,10384
+df2tables/df2tables.py,sha256=kxlvHmh1E5YcuEd-52ZEmZKv-G5fdIYwqRdJHjGnt-w,7891
+df2tables-0.0.8.dist-info/METADATA,sha256=S-hT_dIU_2z0WgaPPFU8I2r1Oq3V1v_dHHLaMOKEDVc,17008
+df2tables-0.0.8.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+df2tables-0.0.8.dist-info/licenses/LICENCE.txt,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
+df2tables-0.0.8.dist-info/RECORD,,

df2tables-0.0.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

df2tables-0.0.8.dist-info/licenses/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.