df2tables 0.0.1__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(instr, tag):
+    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,192 @@
+<!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>
+      <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;
+      }
+    </style>
+  </head>
+  <body>
+    <!--[min_content-->
+    <div class="pure-g">
+      <div class="pure-u-23-24">
+      <div id="tabcnt" style="width: fit-content; margin-left: 1em">
+
+<!--  <div id="tabcnt" style="width: 800px; margin-left: 1em"> -->
+          <p>
+            <!--[title-->
+            Example datatable
+            <!--title]-->
+          </p>
+
+          <table
+            id="pd_datatab"
+            class="display compact hover"
+            style="font-size: 10pt"
+          ></table>
+        </div>
+      </div>
+      <script type="text/javascript">
+        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>`;
+        };
+        $(document).ready(function () {
+          const table = $("#pd_datatab").DataTable({
+            data: data,
+            autoWidth: true,
+            columns: columns,
+            pageLength: 100,
+            responsive: true,
+            scrollX: true,
+            layout: {
+              topStart: {
+                search: {
+                  placeholder: "Search",
+                },
+              },
+              topEnd: "info",
+            },
+            order: [],
+            language: {
+              search: "Filter:",
+            },
+            initComplete: function () {
+              // Add a note about searchable columns
+              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 data =
+          /*[tab_data*/
+          [
+            ["2025-06-22T10:26:53.635125", 0.09, 2.11, -0.33, -1000, "a"],
+            [
+              "Lorem ipsum dolor sit amet, consectetur adipiscing",
+              -0.59,
+              1,
+              1.0,
+              1,
+              "B",
+            ],
+            ["<b>Integer</b> laoreet odio et.", 0.2, 9, -9.0, 2, "c"],
+            [NaN, -0.49, 8, 4.0, 3, "D"],
+            [" class 'datetime.datetime' ", -0.18, 7, 2.0, 4, "e"],
+            [
+              " function simple. locals . lambda  at 0x7847f6b207c0 ",
+              -0.8,
+              4,
+              3.0,
+              5,
+              "F",
+            ],
+            ["C", -0.52, true, 1111.11, 70000, "X   "],
+          ];
+        /*tab_data]*/
+
+        const columns =
+          /*[tab_columns*/
+          [
+            { title: "col1", searchable: true },
+            {
+              title: "col2",
+              searchable: false,
+              render: render_num,
+              type: "num-html",
+            },
+            { title: "col3", searchable: true },
+            {
+              title: "col4",
+              searchable: false,
+              render: render_num,
+              type: "num-html",
+            },
+            {
+              title: "col5",
+              searchable: false,
+              render: render_num,
+              type: "num-html",
+            },
+            { title: "col6", searchable: true },
+          ];
+        /*tab_columns]*/
+
+        const search_columns = /*[search_columns*/ ["col1"];
+        /*search_columns]*/
+      </script>
+    </div>
+    <!--min_content]-->
+  </body>
+</html>

df2tables/df2tables.py

@@ -0,0 +1,161 @@
+#!/usr/bin/python
+# coding=utf8
+import json
+import os
+import subprocess
+import sys
+
+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 render as c_render
+except ImportError:
+    from comnt import render as c_render
+
+__all__ = ["TEMPLATE_PATH", "sample_df", "render"]
+
+
+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:
+                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 render(df,
+           title="Title",
+           precision=2,
+           num_html=[],
+           to_file=None,
+           startfile=True,
+           templ_path=TEMPLATE_PATH):
+    
+    if "MultiIndex" in repr(df.columns):  # experimental
+        df.columns = ["_".join(x) for x in df.columns]
+
+    assert isinstance(df, pd.DataFrame)
+
+    missing_cols = set(num_html).difference(df.columns)
+    if missing_cols:
+        raise AssertionError(f"column(s): {missing_cols} not found in dataframe")
+
+    for col in df.columns:
+        try:
+            test_val = df[col].dropna().iloc[0] 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)
+
+    float_cols = df.select_dtypes(include=[np.float16, np.float32, np.float64])
+
+    df.loc[:, float_cols.columns] = np.round(float_cols, precision)
+    data_arrays = df.values.tolist()
+    data_json = json.dumps(data_arrays, cls=DataJSONEncoder)
+
+    # Get string column indices
+    str_cols = df.select_dtypes(include=["object", "string"]).columns
+    str_col_indices = [list(df.columns).index(col) for col in str_cols]
+
+    # Get column names and create column definitions for DataTable
+    columns = []
+    for i, col in enumerate(df.columns):
+        is_text = i in str_col_indices
+        col_def = {"title": col, "searchable": is_text}
+        if col in num_html:
+            col_def["render"] = "#render_num"
+            col_def["type"] = "num-html"
+        columns.append(col_def)
+
+    columns_json = json.dumps(columns)
+    if num_html:
+        #  we need properly refer to javascript function - json can have string so get rid of the quotes
+        columns_json = columns_json.replace('"#render_num"', "render_num")
+
+    search_cols_json = json.dumps(list(str_cols))
+
+    template_vars = {
+        "title": title,
+        "tab_data": data_json,
+        "tab_columns": columns_json,
+        "search_columns": search_cols_json,
+    }
+    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
+    else:
+        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
+
+
+def sample_df():
+    import datetime
+
+    df = pd.DataFrame({
+        "col1": [
+            datetime.datetime.now(),
+            "Lorem ipsum dolor sit amet, consectetur adipiscing",
+            "<b>Integer</b> laoreet odio et.",
+            np.nan,
+            datetime.datetime,
+            lambda x: 1 / x,
+            "C",
+        ],
+        "col2": [0.09, -0.591, 0.201, -0.487, -0.175, -0.797, -0.519],
+        "col3": [2.11, 1, 9, 8, 7, 4, True],
+        "col4": [-0.333, 1, -9, 4, 2, 3, 1111.111],
+        "col5": [-1000, 1, 2, 3, 4, 5, 70_000],
+        "col6": ["a", "B", "c", "D", "e", "F", "X   "],
+    })
+
+    outfile = "df_table.html"
+    result = render(df,
+                    to_file=None,
+                    title="Example dataframe",
+                    num_html=["col5", "col4", "col2"])
+    return result
+
+
+if __name__ == "__main__":
+    sample_df()

df2tables/examples.py

@@ -0,0 +1,112 @@
+
+
+
+
+import random
+import string
+from datetime import datetime, timedelta
+
+import matplotlib
+import matplotlib.colors as mcolors
+import numpy as np
+import pandas as pd
+
+import df2tables as df2dtb
+
+
+def random_data(num_rows=100):
+
+    def get_rdylgn_colors(num_colors=100):
+        cmap = matplotlib.colormaps["YlGnBu"]
+        color_indices = np.linspace(0, 1, num_colors)
+        colors = []
+        for i in color_indices:
+            rgba_color = cmap(i)
+            hex_color = mcolors.rgb2hex(rgba_color[:3])
+            colors.append(
+                f"<div style='font-family: monospace;background-color:{hex_color}'>{hex_color}</div>"
+            )
+        return colors
+
+    unicode_ranges = [
+        (0x0020, 0x007E),  # Basic Latin (printable ASCII)
+        (0x00A0, 0x00FF),  # Latin-1 Supplement (e.g., accented characters)
+        (0x0100, 0x017F),  # Latin Extended-A (more European characters)
+    ]
+
+    def gen_datetime(min_year=1990, max_year=datetime.now().year):
+        # generate a datetime in format yyyy-mm-dd hh:mm:ss.000000
+        start = datetime(min_year, 1, 1, 00, 00, 00)
+        years = max_year - min_year + 1
+        end = start + timedelta(days=365 * years)
+        return start + (end - start) * random.random()
+
+    def get_random_unicode_char():
+        """Get a random Unicode character from various language ranges."""
+        range_start, range_end = random.choice(unicode_ranges)
+        code_point = random.randint(range_start, range_end)
+        try:
+            return chr(code_point)
+        except ValueError:
+            return chr(random.randint(0x00C0, 0x00FF))
+
+    result = []
+    # colors = list(reversed(get_rdylgn_colors(num_rows)))
+    colors = get_rdylgn_colors(num_rows)
+    for i in range(num_rows):
+        row = [
+            random.choice(string.ascii_letters),
+            random.randint(100, 100000),
+            random.uniform(-1, 1),
+            get_random_unicode_char(),
+            random.choice([True, False]),
+            str(gen_datetime()),
+            colors[i],
+        ]
+        result.append(row)
+    columns= [f'col{i}' for i in range(len(result[0]))]
+    df = pd.DataFrame(result,  columns=columns)
+   
+    outfile = "rnd_table2.html"
+    df2dtb.to_html(df, outfile=outfile, title="Example Diverse Random Data", html_cols=["col1", "col2"])
+    return result
+
+def pkg_test():
+
+    def get_packages():
+        try:
+            import pkg_resources
+
+            dists = [repr(d).split(" ") for d in sorted(pkg_resources.working_set)]
+            dists = sorted(dists, key=lambda x: x[0].lower())
+        except ModuleNotFoundError:
+            print("Error loading module pkg_resources - using random data")
+            dists = generate_random_data(num_rows=100)
+            # dists.insert(0, ["name1", "name2", "name3", "name4", "name5", "name6"])
+        return dists
+
+    header_list = ["name        ", "ver  ", "full package path"]
+    df = pd.DataFrame(get_packages(), columns=header_list)
+    
+    outfile = "pkg_table.html"
+    df2dtb.to_html(df, outfile=outfile)
+
+def test_yfinance(ticker='AAPL'):
+    import yfinance as yf
+    per = "2y"
+    df = yf.download(ticker, period=per)
+    df['Date'] = df.index.map(lambda x: pd.to_datetime(x).date()) 
+    
+    outfile = "yfinance.html"
+    df2dtb.to_html(
+        df,
+        outfile=outfile,
+        title=f"{ticker}, last {per}",
+    )
+
+
+
+if __name__ == "__main__":
+    # random_data()
+    test_yfinance()
+    # pkg_test()

df2tables-0.0.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: df2tables
+Version: 0.0.1
+Summary: dftables creation
+Author-email: Tomasz Sługocki <ts.kontakt@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ts-kontakt/df2tables
+Project-URL: Issues, https://github.com/ts-kontakt/df2tables/issues
+License-File: LICENCE.txt
+Requires-Dist: pandas
+Requires-Dist: numpy
+Dynamic: license-file

df2tables-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+df2tables/__init__.py,sha256=Ry5LO4692ZzOnP1mf7Z8VU4FWXx_h2e6vKwue1jEFGg,74
+df2tables/comnt.py,sha256=MgDN-M3alTBpBPSJcFpcqI514_qr4C5z1Bpmfdz3Nm8,6931
+df2tables/datatable_templ.html,sha256=gu86AYHyg92Y3A84QJlWlEgy8U_0KxfeYONrCghCdPQ,5517
+df2tables/df2tables.py,sha256=QknFOlmDITczJ8K1GeCCmrLenOo_k4YAxEWnENnCgao,5079
+df2tables/examples.py,sha256=JI6QB8Wd98ZOIWOr5Tv050NXR7AErhxPSwX8p7tX4Lg,3456
+df2tables-0.0.1.dist-info/licenses/LICENCE.txt,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
+df2tables-0.0.1.dist-info/METADATA,sha256=gmV4D39857DiidYp_TicAXXKwC09rhDHZq7kABUfja8,380
+df2tables-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+df2tables-0.0.1.dist-info/top_level.txt,sha256=fxT795rSYjPhcxjUIq6Fy7DpEbsMIJDSp7vJuQ0NVMk,10
+df2tables-0.0.1.dist-info/RECORD,,

df2tables-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

df2tables-0.0.1.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.

df2tables-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+df2tables