md-table-writer 0.1.0__tar.gz

md_table_writer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Screven
+
+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.

md_table_writer-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: md-table-writer
+Version: 0.1.0
+Summary: Generate Markdown formatted tables from data files.
+Author-email: Thomas Screven <tscreven@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tscreven/MarkdownTableGenerator
+Project-URL: Issues, https://github.com/tscreven/MarkdownTableGenerator/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Dynamic: license-file
+
+# markdown-table
+
+`markdown-table` programatically generates Markdown formatted table(s) from a given data file and writes it to a Markdown file. Supported data file formats: CSV (.csv), NumPy (.npy), and Excel (.xlsx) files. 
+
+## Overview
+
+Program processes text from data files and processes them into row-ordered table(s) with column headers. The table is written to a Markdown file either at a specific line number or appendeded to the end of the file.
+
+**CSV and Excel:** Users have the option to specify which column headers from the file to process. If left unspecified, the package will process all columns. The package assumes the first row in the file is column headers. 
+
+**Excel**: For Excel files, a new table is generated for every sheet. There is an additional option to specify what sheet names to generate tables for. If left unspecified, every sheet will be processed.
+
+**NumPy**: Unlike the other two file types, it is required to specify column headers. The first row in the matrix should not be the intended column headers. The number of column headers must match the number of columns in the matrix. 
+
+
+## Usage
+```bash
+markdown-table f md -cols -sheets -align -line -append
+```
+
+| Argument |                       Description                      |               Required?              |   Default   |        Example        |
+| :------: | :----------------------------------------------------: | :----------------------------------: | :---------: | :-------------------: |
+|     f    |                        Data file                       |                 Yes                  |             |       data.xlsx       |
+|    md    |                      Markdown file                     |                 Yes                  |             |       report.md       |
+|   -cols  |    List of column headers to include from data file    | No, unless data file is a NumPy file |             | -cols Time Population |
+|  -sheets |   List of sheets from Excel file to write tables for   |                  No                  |             | -sheets Sheet1 Sheet2 |
+|  -align  | Table column alignment options: left, center, or right |                  No                  |    center   |      -align right     |
+|   -line  |     Line number in Markdown file to write table to     |                  No                  | end of file |        -line 50       |
+|  -append |       Flag to write table at end of Markdown file      |                  No                  |    False    |        -append        |
+
+
+### Examples
+
+```bash
+markdown-table data.xlsx report.md -cols Time Population -sheets Sheet1 Sheet2 -align right -line 50
+```
+Generates two tables for Sheet1 and Sheet2 with columns Time and Population from data.xlsx. The table's columns are right aligned. The table is written on line 50 in report.md.
+
+```bash
+markdown-table data.csv report.md -align left -append
+```
+Generates one table with columns Time and Population from data.csv. The table's columns are left aligned. The table is written to the end of report.md.
+
+```bash
+markdown-table data.npy report.md -cols Time Population -line 50
+```
+Generates one table from the 2D matrix in data.npy with column headers Time and Population. The table's columns are center aligned. The table is written onen line 50 in report.md.

md_table_writer-0.1.0/README.md

@@ -0,0 +1,47 @@
+# markdown-table
+
+`markdown-table` programatically generates Markdown formatted table(s) from a given data file and writes it to a Markdown file. Supported data file formats: CSV (.csv), NumPy (.npy), and Excel (.xlsx) files. 
+
+## Overview
+
+Program processes text from data files and processes them into row-ordered table(s) with column headers. The table is written to a Markdown file either at a specific line number or appendeded to the end of the file.
+
+**CSV and Excel:** Users have the option to specify which column headers from the file to process. If left unspecified, the package will process all columns. The package assumes the first row in the file is column headers. 
+
+**Excel**: For Excel files, a new table is generated for every sheet. There is an additional option to specify what sheet names to generate tables for. If left unspecified, every sheet will be processed.
+
+**NumPy**: Unlike the other two file types, it is required to specify column headers. The first row in the matrix should not be the intended column headers. The number of column headers must match the number of columns in the matrix. 
+
+
+## Usage
+```bash
+markdown-table f md -cols -sheets -align -line -append
+```
+
+| Argument |                       Description                      |               Required?              |   Default   |        Example        |
+| :------: | :----------------------------------------------------: | :----------------------------------: | :---------: | :-------------------: |
+|     f    |                        Data file                       |                 Yes                  |             |       data.xlsx       |
+|    md    |                      Markdown file                     |                 Yes                  |             |       report.md       |
+|   -cols  |    List of column headers to include from data file    | No, unless data file is a NumPy file |             | -cols Time Population |
+|  -sheets |   List of sheets from Excel file to write tables for   |                  No                  |             | -sheets Sheet1 Sheet2 |
+|  -align  | Table column alignment options: left, center, or right |                  No                  |    center   |      -align right     |
+|   -line  |     Line number in Markdown file to write table to     |                  No                  | end of file |        -line 50       |
+|  -append |       Flag to write table at end of Markdown file      |                  No                  |    False    |        -append        |
+
+
+### Examples
+
+```bash
+markdown-table data.xlsx report.md -cols Time Population -sheets Sheet1 Sheet2 -align right -line 50
+```
+Generates two tables for Sheet1 and Sheet2 with columns Time and Population from data.xlsx. The table's columns are right aligned. The table is written on line 50 in report.md.
+
+```bash
+markdown-table data.csv report.md -align left -append
+```
+Generates one table with columns Time and Population from data.csv. The table's columns are left aligned. The table is written to the end of report.md.
+
+```bash
+markdown-table data.npy report.md -cols Time Population -line 50
+```
+Generates one table from the 2D matrix in data.npy with column headers Time and Population. The table's columns are center aligned. The table is written onen line 50 in report.md.

md_table_writer-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "md-table-writer"
+version = "0.1.0"
+
+authors = [
+    { name="Thomas Screven", email="tscreven@gmail.com"}
+]
+description = "Generate Markdown formatted tables from data files."
+readme = "README.md"
+
+dependencies = [
+    "pandas", 
+    "numpy", 
+    "openpyxl"
+]
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.urls]
+Homepage = "https://github.com/tscreven/MarkdownTableGenerator"
+Issues = "https://github.com/tscreven/MarkdownTableGenerator/issues"
+
+[project.scripts]
+markdown-table = "main:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+py-modules = ["main", "table_generator"]

md_table_writer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

md_table_writer-0.1.0/src/main.py

@@ -0,0 +1,36 @@
+import argparse
+from table_generator import MarkdownTable
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate Markdown tables from CSV, Excel, or NumPy files."
+    )
+    parser.add_argument("f", help="Path to data file.")
+    parser.add_argument("md", help="Path to target Markdown file.")
+    parser.add_argument("-cols", nargs='+', 
+                        help="Column headers to include from the data file.")
+    parser.add_argument("-sheets", nargs='+', 
+                        help="Excel sheet names to generate tables from.")
+    parser.add_argument("-align", choices=["left", "center", "right"], 
+                        default="center", help="Table column alignment.")
+    parser.add_argument("-line", type=int, default=0,
+                        help="Line number where table(s) are inserted in the Markdown file.")
+    parser.add_argument("-append", action='store_true', 
+                        help="Append table(s) to the end of the Markdown file.")
+
+    args = parser.parse_args()
+
+    col_headers = [] if args.cols is None else args.cols
+    excel_sheets = [] if args.sheets is None else args.sheets
+
+    MarkdownTable(args.f, 
+                  args.md, 
+                  args.align, 
+                  args.line, 
+                  args.append,
+                  col_headers, 
+                  excel_sheets
+                )
+
+if __name__ == "__main__":
+    main()

md_table_writer-0.1.0/src/md_table_writer.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: md-table-writer
+Version: 0.1.0
+Summary: Generate Markdown formatted tables from data files.
+Author-email: Thomas Screven <tscreven@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tscreven/MarkdownTableGenerator
+Project-URL: Issues, https://github.com/tscreven/MarkdownTableGenerator/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Dynamic: license-file
+
+# markdown-table
+
+`markdown-table` programatically generates Markdown formatted table(s) from a given data file and writes it to a Markdown file. Supported data file formats: CSV (.csv), NumPy (.npy), and Excel (.xlsx) files. 
+
+## Overview
+
+Program processes text from data files and processes them into row-ordered table(s) with column headers. The table is written to a Markdown file either at a specific line number or appendeded to the end of the file.
+
+**CSV and Excel:** Users have the option to specify which column headers from the file to process. If left unspecified, the package will process all columns. The package assumes the first row in the file is column headers. 
+
+**Excel**: For Excel files, a new table is generated for every sheet. There is an additional option to specify what sheet names to generate tables for. If left unspecified, every sheet will be processed.
+
+**NumPy**: Unlike the other two file types, it is required to specify column headers. The first row in the matrix should not be the intended column headers. The number of column headers must match the number of columns in the matrix. 
+
+
+## Usage
+```bash
+markdown-table f md -cols -sheets -align -line -append
+```
+
+| Argument |                       Description                      |               Required?              |   Default   |        Example        |
+| :------: | :----------------------------------------------------: | :----------------------------------: | :---------: | :-------------------: |
+|     f    |                        Data file                       |                 Yes                  |             |       data.xlsx       |
+|    md    |                      Markdown file                     |                 Yes                  |             |       report.md       |
+|   -cols  |    List of column headers to include from data file    | No, unless data file is a NumPy file |             | -cols Time Population |
+|  -sheets |   List of sheets from Excel file to write tables for   |                  No                  |             | -sheets Sheet1 Sheet2 |
+|  -align  | Table column alignment options: left, center, or right |                  No                  |    center   |      -align right     |
+|   -line  |     Line number in Markdown file to write table to     |                  No                  | end of file |        -line 50       |
+|  -append |       Flag to write table at end of Markdown file      |                  No                  |    False    |        -append        |
+
+
+### Examples
+
+```bash
+markdown-table data.xlsx report.md -cols Time Population -sheets Sheet1 Sheet2 -align right -line 50
+```
+Generates two tables for Sheet1 and Sheet2 with columns Time and Population from data.xlsx. The table's columns are right aligned. The table is written on line 50 in report.md.
+
+```bash
+markdown-table data.csv report.md -align left -append
+```
+Generates one table with columns Time and Population from data.csv. The table's columns are left aligned. The table is written to the end of report.md.
+
+```bash
+markdown-table data.npy report.md -cols Time Population -line 50
+```
+Generates one table from the 2D matrix in data.npy with column headers Time and Population. The table's columns are center aligned. The table is written onen line 50 in report.md.

md_table_writer-0.1.0/src/md_table_writer.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/main.py
+src/table_generator.py
+src/md_table_writer.egg-info/PKG-INFO
+src/md_table_writer.egg-info/SOURCES.txt
+src/md_table_writer.egg-info/dependency_links.txt
+src/md_table_writer.egg-info/entry_points.txt
+src/md_table_writer.egg-info/requires.txt
+src/md_table_writer.egg-info/top_level.txt
+tests/test_table_generator.py

md_table_writer-0.1.0/src/md_table_writer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

md_table_writer-0.1.0/src/md_table_writer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+markdown-table = main:main

md_table_writer-0.1.0/src/md_table_writer.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pandas
+numpy
+openpyxl

md_table_writer-0.1.0/src/md_table_writer.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+main
+table_generator

md_table_writer-0.1.0/src/table_generator.py

@@ -0,0 +1,200 @@
+import pandas as pd
+import sys
+import os
+from typing import Literal
+import numpy as np
+
+def error(message:str):
+    print(message)
+    sys.exit(1)
+
+class MarkdownTable:
+
+    def __init__(self, 
+                 data_file, md_file, 
+                 table_alignment: Literal["left", "center", "right"], 
+                 line_num:int, append:bool, col_headers:list, excel_sheets:list
+                ) -> None:
+
+        if not os.path.exists(data_file):
+            error(f"{data_file} does not exist.")
+
+        if md_file[-3:] != ".md":
+            error(f"Target {md_file} is not a Markdown file.")
+
+        if not os.path.exists(md_file):
+            error(f"{md_file} does not exist.")
+
+        if not append and line_num <= 0:
+            print(f"Appending table to end of {md_file} because either no line number was given or the line number is not positive.")
+            append = True
+
+        self.data_file = data_file
+        self.md_file = md_file
+        self.align = table_alignment
+        self.line_num = line_num 
+        self.append = append
+        self.col_headers = col_headers
+        self.num_cols = len(col_headers)
+
+        self.delegate(excel_sheets)
+
+
+    def delegate(self, excel_sheets):
+        '''Direct table value processing based on file type.'''
+        if self.data_file[-4:] == ".csv":
+            self.process_csv()
+        elif self.data_file[-4:] == ".npy":
+            if self.num_cols == 0:
+                error("Column headers must be given for NumPy file.")
+            self.process_npy()
+        elif self.data_file[-5:] == ".xlsx":
+            self.process_excel(excel_sheets)
+        else:
+            error("Invalid file type. Data file must be either a CSV (.csv), NumPy (.npy), or Excel (.xlsx) file.")
+
+
+    def col_header_update(self, headers):
+        '''Update instance for tracking new column headers.'''
+        if len(headers) == 0:
+            error(f"No column headers given and column headers could not be located in {self.data_file}.")
+        self.col_headers = headers
+        self.num_cols = len(headers)
+
+
+    def process_dataframe(self, df:pd.DataFrame):
+        '''Helper function for file processing functions using Dataframes.'''
+
+        def check_header(header):
+            if header not in df:
+                error(f'Category "{header}" is not a column header in {self.data_file}. Note that column headers are case sensitive.')
+
+        check_header(self.col_headers[0])
+
+        num_rows = len(df[self.col_headers[0]])
+        rows = [[] for _ in range(num_rows)]
+
+        for header in self.col_headers:
+
+            check_header(header)
+
+            if len(df[header]) != num_rows:
+                error(f"Unequal column length between columns {self.col_headers[0]} and {header}.")
+
+            col_values = df[header]
+            for i in range(num_rows):
+                rows[i].append(col_values[i])
+
+        self.gen_table(rows)
+
+
+    def process_csv(self):
+        '''Process given CSV file: find column headers if none given and store
+        values for all tracked column headers in row order.'''
+        # If no columns given, assume the entire first row is column headers.
+        if self.num_cols == 0:
+            with open(self.data_file, 'r') as f:
+                line = next(f)
+            headers = line.strip().split(',')
+            self.col_header_update(headers)
+
+        df = pd.read_csv(self.data_file)
+        self.process_dataframe(df)
+
+
+    def process_excel(self, sheet_names:list):
+        '''Process given Excel file: find column headers in sheet_names if none
+        are given and store values for all tracked column headers in row order.
+        If there are multiple sheets, generate a table for each sheet.'''
+
+        dfs = pd.read_excel(self.data_file, sheet_name=None)
+        all_file_sheets = dfs.keys()
+        if sheet_names == []:
+            # Load all sheets in Excel file if sheet_names are not specified.
+            sheet_names = list(all_file_sheets)
+        else:
+            for sheet in sheet_names:
+                if sheet not in all_file_sheets:
+                    error(f"Sheet name {sheet} is not in {self.data_file}.")
+        
+        # If no columns given, assume the entire first row is column headers.
+        no_headers = self.num_cols == 0
+
+        for i, sheet in enumerate(sheet_names):
+            if no_headers:
+                headers = dfs[sheet_names[i]].columns
+                self.col_header_update(headers)
+
+            df = dfs[sheet]
+            self.process_dataframe(df)
+
+
+    def process_npy(self):
+        '''Process given NumPy file: Column headers must be given. Table values
+        are stored in 2D NumPy matrix in row order; transpose the matrix if it
+        is required to match the number of expected columns.'''
+
+        data = np.load(self.data_file)
+        assert type(data) == np.ndarray
+
+        if data.ndim != 2:
+            error(f"Invalid number of dimensions in {self.data_file} with {data.ndim} dimension(s). NumPy files must be a 2D matrix.")
+
+        data_cols = data.shape[1]
+        if data_cols != self.num_cols:
+            print(f"Mismatch in number of columns in NumPy matrix and given column headers.") 
+
+            if data.shape[0] == self.num_cols:
+                print("The number of rows match the number of given column headers. Generated table from transposed matrix.")
+                data = data.T
+            else:
+                error(f"{self.data_file} contains {data_cols} columns, given {self.num_cols} column headers.")
+
+        self.gen_table(data.tolist())
+
+
+    def gen_table(self, rows:list):
+        '''Write Markdown formatted table in md_file at line_num or at end of file.'''
+
+        next_line = "\n|"
+        table_str = next_line
+
+        # Column headers
+        for h in self.col_headers:
+            table_str += f" {h} |"
+        table_str += next_line
+
+        if self.align == "left":
+            sep = ":-"
+        elif self.align == "center":
+            sep = ":-:" 
+        else: # right alignment
+            sep = "-:" 
+
+        # Horizontal line separator
+        for _ in range(self.num_cols):
+            table_str += f" {sep} |"
+
+        # Add each row
+        for row in rows:
+            table_str += next_line
+            for item in row:
+                table_str += f" {item} |"
+
+        new_lines = len(rows) + 4
+
+        # Need extra new line for formatting. 
+        table_str += "\n"*2
+
+        with open(self.md_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        if self.append or self.line_num + 1 > len(lines):
+            with open(self.md_file, "a", encoding="utf-8") as f:
+                f.write('\n')
+                f.write(table_str[:-1])
+                new_lines += 1
+        else:
+            lines.insert(self.line_num - 1, table_str)
+            with open(self.md_file, "w", encoding="utf-8") as f:
+                f.writelines(lines)

md_table_writer-0.1.0/tests/test_table_generator.py

@@ -0,0 +1,122 @@
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from tempfile import TemporaryDirectory
+import numpy as np
+import pandas as pd
+from typing import Literal
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from table_generator import MarkdownTable
+
+
+class MarkdownTableTests(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = TemporaryDirectory()
+        self.base_path = Path(self.temp_dir.name)
+        self.md_file = self.base_path / "report.md"
+        self.md_file.write_text("# Report\n", encoding="utf-8")
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def generate_table(self, data_file:str, align:Literal["left", "center", "right"]="center", 
+                       line_num=0, append=True, col_headers=[], excel_sheets=[]):
+        
+        MarkdownTable(str(data_file), str(self.md_file), align, line_num, 
+                      append, col_headers, excel_sheets,)
+        return self.md_file.read_text(encoding="utf-8")
+
+
+    def test_csv_no_given_headers(self):
+        data_file = self.base_path / "data.csv"
+        data_file.write_text("Name,Score\nAda,10\nGrace,12\n", encoding="utf-8")
+
+        content = self.generate_table(str(data_file))
+
+        self.assertIn(
+            "| Name | Score |\n| :-: | :-: |\n| Ada | 10 |\n| Grace | 12 |",
+            content,
+        )
+
+
+    def test_csv_with_given_headers(self):
+        data_file = self.base_path / "data.csv"
+        data_file.write_text("Name,Score,Rank\nAda,10,2\nGrace,12,1\n", encoding="utf-8")
+
+        content = self.generate_table(str(data_file), align="right", col_headers=["Rank", "Name"])
+
+        self.assertIn( "| Rank | Name |\n| -: | -: |\n| 2 | Ada |\n| 1 | Grace |", content)
+
+
+    def test_line_insertion(self):
+        self.md_file.write_text("First\nSecond\nThird\n", encoding="utf-8")
+        data_file = self.base_path / "data.csv"
+        data_file.write_text("Name,Score\nAda,10\n", encoding="utf-8")
+
+        content = self.generate_table( str(data_file), align="left", line_num=2, 
+                                      append=False, col_headers=["Name", "Score"])
+
+        self.assertTrue(content.startswith("First\n\n| Name | Score |"))
+        self.assertIn("| :- | :- |\n| Ada | 10 |", content)
+        self.assertTrue(content.endswith("\nSecond\nThird\n"))
+
+    def test_np_array(self):
+        data_file = self.base_path / "data.npy"
+        np.save(data_file, np.array([[1, 2], [3, 4]]))
+
+        content = self.generate_table(str(data_file), col_headers=["A", "B"])
+
+        self.assertIn("| A | B |\n| :-: | :-: |\n| 1 | 2 |\n| 3 | 4 |", content)
+
+    def test_np_array_transposed(self):
+        data_file = self.base_path / "data.npy"
+        np.save(data_file, np.array([[1, 2, 3], [4, 5, 6]]))
+
+        with redirect_stdout(io.StringIO()):
+            content = self.generate_table(str(data_file), col_headers=["A", "B"])
+
+        self.assertIn("| A | B |\n| :-: | :-: |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |", content)
+
+    def test_excel_given_sheets_headers(self):
+        data_file = self.base_path / "data.xlsx"
+        with pd.ExcelWriter(data_file) as writer:
+            pd.DataFrame({"Name": ["Ada"], "Score": [10]}).to_excel(
+                writer, sheet_name="Scores", index=False
+            )
+            pd.DataFrame({"Name": ["Ignored"], "Score": [0]}).to_excel(
+                writer, sheet_name="Other", index=False
+            )
+
+        content = self.generate_table(str(data_file), col_headers=["Name", "Score"], excel_sheets=["Scores"])
+
+        self.assertIn("| Name | Score |\n| :-: | :-: |\n| Ada | 10 |", content)
+        self.assertNotIn("Ignored", content)
+
+    def test_np_array_no_headers_assert_error(self):
+        data_file = self.base_path / "data.npy"
+        np.save(data_file, np.array([[1]]))
+
+        with self.assertRaises(SystemExit) as raised, redirect_stdout(io.StringIO()) as output:
+            MarkdownTable(str(data_file), str(self.md_file), "center", 0, True, [], [])
+
+        self.assertEqual(raised.exception.code, 1)
+        self.assertIn("Column headers must be given for NumPy file.", output.getvalue())
+
+
+    def test_given_wrong_header_assert_error(self):
+        data_file = self.base_path / "data.csv"
+        data_file.write_text("Name,Score\nAda,10\n", encoding="utf-8")
+
+        with self.assertRaises(SystemExit) as raised, redirect_stdout(io.StringIO()) as output:
+            MarkdownTable(str(data_file), str(self.md_file), "center", 0, True, ["Missing"], [])
+
+        self.assertEqual(raised.exception.code, 1)
+        self.assertIn( 'Category "Missing" is not a column header in', output.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()