span-table 0.1.0__py3-none-any.whl

span_table/__init__.py

@@ -0,0 +1,3 @@
+from table import span_table
+
+__all__ = ["span_table"]

span_table/cell.py

@@ -0,0 +1,265 @@
+from src.span_table.span import (
+    get_span_column_count,
+    get_span_row_count, 
+    get_span_char_height, 
+    get_span_char_width
+)
+from typing import Literal
+from dataclasses import dataclass
+from rich.box import Box
+from src.span_table.types import SpanType, TableType
+
+@dataclass
+class Cell:
+    text: str
+    row: int
+    column: int
+    row_count: int
+    column_count: int
+
+    def __lt__(self, other):
+        return [self.row, self.column] < [other.row, other.column]
+    
+    @property
+    def left_sections(self):
+        lines = self.text.split('\n')
+        sections = 0
+
+        for i in range(len(lines)):
+            if lines[i].startswith('+'):
+                sections += 1
+        sections -= 1
+
+        return sections
+
+    @property
+    def right_sections(self):
+        lines = self.text.split('\n')
+        sections = 0
+        for i in range(len(lines)):
+            if lines[i].endswith('+'):
+                sections += 1
+        return sections - 1
+
+    @property
+    def top_sections(self):
+        top_line = self.text.split('\n')[0]
+        sections = len(top_line.split('+')) - 2
+
+        return sections
+
+    @property
+    def bottom_sections(self):
+        bottom_line = self.text.split('\n')[-1]
+        sections = len(bottom_line.split('+')) - 2
+
+        return sections
+
+def resolve_border(
+        box: Box, 
+        row: int, 
+        col: int, 
+        total_row: int, 
+        total_col: int, 
+        span: SpanType, 
+        corner: Literal['top_left', 'top_right', 'bottom_left', 'bottom_right']
+):
+    if corner == "top_left":
+        if row == 0 and col == 0:
+            return box.top_left
+        elif 0 < row and col == 0:
+            return box.row_left
+        elif  row == 0 and 0 < col:
+            return box.top_divider
+        else:
+            return box.row_cross
+    elif corner == "top_right":
+        if len(span) > 1:
+            row, col = span[0][0], span[-1][1]
+        if row == 0 and col == (total_col - 1):
+            return box.top_right
+        elif row > 0 and col == (total_col - 1):
+            return box.row_right
+        elif row == 0 and col < (total_col - 1):
+            return box.top_divider
+        else:
+            return box.row_cross
+    elif corner == "bottom_left":
+        if len(span) > 1:
+            row, col = span[-1][0], span[0][1]
+        if row == (total_row - 1) and col == 0:
+            return box.bottom_left
+        elif row == (total_row - 1) and col > 0:
+            return box.bottom_divider
+        elif row < (total_row - 1) and col == 0:
+            return box.row_left
+        else:
+            return box.row_cross
+    elif corner == "bottom_right":
+        if len(span) > 1:
+            row, col = span[-1]
+        if row == (total_row - 1) and col == (total_col - 1):
+            return box.bottom_right
+        elif row == (total_row - 1) and col < (total_col - 1):
+            return box.bottom_divider
+        elif row < (total_row - 1) and col == (total_col - 1):
+            return box.row_right
+        else:
+            return box.row_cross
+      
+
+def make_cell(table: TableType, span: SpanType, widths: list[int], heights: list[int], box: Box) -> Cell:
+    width = get_span_char_width(span, widths)
+    height = get_span_char_height(span, heights)
+    text_row = span[0][0]
+    text_column = span[0][1]
+    text = table[text_row][text_column]
+    total_cols = len(widths)
+    total_rows = len(heights)
+
+    lines = text.plain.split("\n")
+    text.pad_width(width)
+
+    height_difference = height - len(lines)
+    text.append_empty_lines(height_difference, width)
+    output = [
+        ''.join([
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'top_left'), 
+            (width * box.row_horizontal),
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'top_right')
+        ])
+    ]
+
+    for line in text.markup.split('\n'):
+        output.append(box.mid_vertical + line + box.mid_vertical)
+
+    symbol = box.row_horizontal
+
+    output.append(
+        ''.join([
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'bottom_left'), 
+            width * symbol, 
+            resolve_border(box, text_row, text_column, total_rows, total_cols, span, 'bottom_right')
+        ])
+    )
+
+    text = "\n".join(output)
+    row_count = get_span_row_count(span)
+    column_count = get_span_column_count(span)
+    return Cell(text=text, row=text_row, column=text_column, row_count=row_count, column_count=column_count)
+
+
+def merge_cells(cell1: Cell, cell2: Cell, direction: Literal["RIGHT", "TOP", "BOTTOM", "LEFT"], box: Box):
+    cell1_lines = cell1.text.split("\n")
+    cell2_lines = cell2.text.split("\n")
+    if direction == "RIGHT":
+        for i in range(len(cell1_lines)):
+            sub = cell1_lines[i][-1]
+            if cell1_lines[i][-1] == box.mid_vertical and cell2_lines[i][0] == box.row_cross:
+                sub = box.row_left
+            elif cell1_lines[i][-1] == box.row_cross and cell2_lines[i][0] == box.mid_vertical:
+                sub = box.row_right
+            elif cell1_lines[i][-1] == box.row_cross and (cell2_lines[i][0] == box.top_left or cell2_lines[i][0] == box.top_divider):
+                sub = box.top_divider
+            
+            cell1_lines[i] = cell1_lines[i][:-1] + sub + cell2_lines[i][1:]
+        cell1.text = "\n".join(cell1_lines)
+        cell1.column_count += cell2.column_count
+
+    elif direction == "TOP":
+        if cell1_lines[0].count('+') > cell2_lines[-1].count('+'):
+            cell2_lines.pop(-1)
+        else:
+            cell1_lines.pop(0)
+        cell2_lines.extend(cell1_lines)
+        cell1.text = "\n".join(cell2_lines)
+        cell1.row_count += cell2.row_count
+        cell1.row = cell2.row
+        cell1.column = cell2.column
+
+    elif direction == "BOTTOM":
+        merged_cells = ""
+        for top_char, bottom_char in zip(cell1_lines[-1], cell2_lines[0]):
+            if top_char == box.row_cross and bottom_char == box.row_horizontal:
+                merged_cells += box.bottom_divider
+            elif top_char == box.row_horizontal and bottom_char == box.row_cross:
+                merged_cells += box.top_divider
+            else:
+                merged_cells += top_char
+        cell1_lines[-1] = merged_cells
+        cell1_lines.extend(cell2_lines[1:])
+        cell1.text = "\n".join(cell1_lines)
+        cell1.row_count += cell2.row_count
+
+    elif direction == "LEFT":
+        for i in range(len(cell1_lines)):
+            sub = cell1_lines[i]
+            if cell1_lines[i][0] == box.mid_vertical and cell2_lines[i][-1] == box.row_cross:
+                sub = box.row_right + sub[1:]
+            elif cell1_lines[i][0] == box.row_cross and cell2_lines[i][-1] == box.mid_vertical:
+                sub = box.row_left + sub[1:]
+
+            cell1_lines[i] = cell2_lines[i][0:-1] + sub
+        cell1.text = "\n".join(cell1_lines)
+        cell1.column_count += cell2.column_count
+        cell1.row = cell2.row
+        cell1.column = cell2.column
+    
+def merge_all_cells(cells: list[Cell], box: Box) -> str:
+    current = 0
+    while len(cells) > 1:
+        count = 0
+        while count < len(cells):
+            cell1 = cells[current]
+            cell2 = cells[count]
+            merge_direction = get_merge_direction(cell1, cell2)
+            if not merge_direction == "NONE":
+                merge_cells(cell1, cell2, merge_direction, box)
+                if current > count:
+                    current -= 1
+
+                cells.pop(count)
+            else:
+                count += 1
+
+        current += 1
+        if current >= len(cells):
+            current = 0
+
+    return cells[0].text
+
+def get_merge_direction(cell1: Cell, cell2: Cell) -> Literal["RIGHT", "TOP", "BOTTOM", "LEFT", "NONE"]:
+    cell1_left = cell1.column
+    cell1_right = cell1.column + cell1.column_count
+    cell1_top = cell1.row
+    cell1_bottom = cell1.row + cell1.row_count
+    cell2_left = cell2.column
+    cell2_right = cell2.column + cell2.column_count
+    cell2_top = cell2.row
+    cell2_bottom = cell2.row + cell2.row_count
+
+    if (cell1_right == cell2_left and cell1_top == cell2_top and
+            cell1_bottom == cell2_bottom and
+            cell1.right_sections >= cell2.left_sections):
+        return "RIGHT"
+
+    elif (cell1_left == cell2_left and cell1_right == cell2_right and
+            cell1_top == cell2_bottom and
+            cell1.top_sections >= cell2.bottom_sections):
+        return "TOP"
+
+    elif (cell1_left == cell2_left and
+          cell1_right == cell2_right and
+          cell1_bottom == cell2_top and
+          cell1.bottom_sections >= cell2.top_sections):
+        return "BOTTOM"
+
+    elif (cell1_left == cell2_right and
+          cell1_top == cell2_top and
+          cell1_bottom == cell2_bottom and
+          cell1.left_sections >= cell2.right_sections):
+        return "LEFT"
+
+    else:
+        return "NONE"
+

span_table/markup_text.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+from rich.markup import Tag, _parse
+
+
+@dataclass
+class StyleToken:
+    tag: Tag
+
+@dataclass
+class TextToken:
+    text: str
+
+    def pad_width(self, width: int):
+        pad = max(0, width - len(self.text))
+        if pad:
+            self.text += ' ' * pad
+
+class MarkupText:
+    def __init__(self, markup: str):
+        self._tokens: list[StyleToken | TextToken] = []
+        self._parse(markup)
+
+    def _parse(self, markup: str):
+        for _, text, tag in _parse(markup):
+            if text is not None:
+                for line in text.split('\n'):
+                    if line == '':
+                        continue
+                    self._tokens.append(TextToken(f" {line} "))
+            else:
+                self._tokens.append(StyleToken(tag))
+
+    @property
+    def plain(self) -> str:
+        return "\n".join(l.text for l in self.text_tokens)
+
+    @property
+    def markup(self) -> str:
+        markup_text = ""
+        for idx in range(len(self._tokens)):
+            if idx > 0:
+                if isinstance(self._tokens[idx - 1], TextToken) and isinstance(self._tokens[idx], TextToken):
+                    markup_text += "\n"
+
+            if isinstance(self._tokens[idx], TextToken):
+                markup_text += self._tokens[idx].text
+            else:
+                markup_text += f"[{self._tokens[idx].tag.name}]"
+
+        return markup_text
+
+    @property
+    def text_tokens(self) -> list[TextToken]:
+        return [token for token in self._tokens if isinstance(token, TextToken)]
+    
+    def pad_width(self, width: int):
+        for token in self.text_tokens:
+            token.pad_width(width)
+
+    def append_empty_lines(self, count: int, width: int):
+        for _ in range(count):
+            self._tokens.append(TextToken(" " * width))

span_table/span.py

@@ -0,0 +1,128 @@
+from rich.text import Text
+from src.span_table.types import TableType, SpanType
+from src.span_table.markup_text import MarkupText
+
+def check_span(data: TableType, span: SpanType):
+    if not len(span) == 2 or not len(span[0]) == 2 or not len(span[1]) == 2:
+        raise Exception("Span must be tuple of tuples in format ((start row index, start column index), (end row index, end column index))")
+    
+    start_span, end_span = span
+    if not (start_span[0] <= end_span[0] and start_span[1] <= end_span[1]):
+        raise Exception('Spans must be rectangular in shape.')
+
+    if not (0 <= start_span[0] <= end_span[0] < len(data)) or not (0 <= start_span[1] <= end_span[1] < len(data[0])):
+        raise Exception(f"{span} is out of bounds.")
+
+def extend_span(start: tuple[int, int], end: tuple[int, int]) -> SpanType:
+    extended_span = []
+    for row_idx in range(start[0], end[0] + 1):
+        for col_idx in range(start[1], end[1] + 1):
+            extended_span.append((row_idx, col_idx))
+
+    return extended_span
+
+def get_span(spans: list[SpanType], row: int, column: int) -> SpanType | None:
+    for i in range(len(spans)):
+        if (row, column) in spans[i]:
+            return spans[i]
+
+    return None
+
+def convert_cells_to_spans(data: TableType, spans: list[SpanType]) -> list[SpanType]:
+    new_spans = []
+    for row in range(len(data)):
+        for column in range(len(data[0])):
+            span = get_span(spans, row, column)
+            if not span:
+                new_spans.append([(row, column)])
+    
+    new_spans.extend(spans)
+    new_spans = list(sorted(new_spans))
+    return new_spans
+
+def get_span_column_count(span: SpanType) -> int:
+    return max((span[-1][1] - span[0][1]) + 1, 1)
+
+def get_span_row_count(span: SpanType) -> int:
+    return max((span[-1][0] - span[0][0]) + 1, 1)
+
+def get_longest_line_length(text: MarkupText) -> int:
+    return len(max(text.plain.split("\n"), key=lambda line: len(line)))
+
+def get_output_column_widths(table: TableType, spans: list[SpanType]) -> list[int]:
+    widths = [3 for _ in range(len(table[0]))]
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            span = get_span(spans, row, column)
+            column_count = get_span_column_count(span)
+            text_row = span[0][0]
+            text_column = span[0][1]
+            text = table[text_row][text_column]
+            length = get_longest_line_length(text)
+            if column_count == 1:
+                widths[column] = max(length, widths[column])
+            else:
+                end_column = text_column + column_count
+                available_space = sum(widths[text_column:end_column]) + column_count - 1
+                while length > available_space:
+                    for i in range(text_column, end_column):
+                        widths[i] += 1
+                        available_space = sum(widths[text_column:end_column]) + column_count - 1
+                        if length <= available_space:
+                            break
+    return widths
+
+def get_output_row_heights(table: TableType, spans: list[SpanType]) -> list[int]:
+    heights = [-1 for _ in table]
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            text = table[row][column]
+            span = get_span(spans, row, column)
+            row_count = get_span_row_count(span)
+            height = len(text.plain.split('\n'))
+            if row_count == 1:
+                heights[row] = max(height, heights[row])
+    
+    for row in range(len(table)):
+        for column in range(len(table[row])):
+            text = table[row][column]
+            span = get_span(spans, row, column)
+            row_count = get_span_row_count(span)
+            height = len(text.plain.split('\n'))
+            if row_count > 1:
+                text_row = span[0][0]
+                text_column = span[0][1]
+                end_row = text_row + row_count
+                text = table[text_row][text_column]
+                height = len(text.plain.split('\n')) - (row_count - 1)
+                add_row = 0
+                while height > sum(heights[text_row:end_row]):
+                    heights[text_row + add_row] += 1
+                    if add_row + 1 < row_count:
+                        add_row += 1
+                    else:
+                        add_row = 0
+    return heights
+
+def get_span_char_width(span: SpanType, column_widths: list[int]) -> int:
+    start_column = span[0][1]
+    column_count = get_span_column_count(span)
+    total_width = 0
+
+    for i in range(start_column, start_column + column_count):
+        total_width += column_widths[i]
+
+    total_width += column_count - 1
+
+    return total_width
+
+def get_span_char_height(span: SpanType, row_heights: list[int]) -> int:
+    start_row = span[0][0]
+    row_count = get_span_row_count(span)
+    total_height = 0
+
+    for i in range(start_row, start_row + row_count):
+        total_height += row_heights[i]
+    
+    total_height += row_count - 1
+    return total_height

span_table/table.py

@@ -0,0 +1,54 @@
+from rich import box as rich_box
+from rich.text import Text
+
+from src.span_table.span import (
+    extend_span, 
+    check_span, 
+    convert_cells_to_spans, 
+    get_output_column_widths,
+    get_output_row_heights,
+)
+from src.span_table.cell import make_cell, merge_all_cells
+from src.span_table.markup_text import MarkupText
+from src.span_table.types import SpanType, TableType
+from typing import Annotated
+
+TableMarkupType = Annotated[list[list[MarkupText]], 'Lists of list of markup type objects']
+
+def check_table(data: TableType):
+    if not type(data) is list:
+        raise Exception("Table data must be a list of lists")
+
+    if len(data) == 0:
+        raise Exception("Table data must contain at least one row and one column")
+
+    for i in range(len(data)):
+        if not type(data[i]) is list:
+            raise Exception("Table data must be a list of lists")
+        
+        if not len(data[i]) == len(data[0]):
+            raise Exception("Each row must have the same number of columns")
+
+def span_table(
+    data: TableType,
+    spans: list[SpanType],
+    box: rich_box.Box = rich_box.SQUARE
+) -> str:
+    check_table(data=data)
+    extended_spans = []
+    for span in spans:
+        check_span(data, span)
+        extended_spans.append(extend_span(*span))
+
+    text_data = [[MarkupText(cell) for cell in row] for row in data]
+    spans = convert_cells_to_spans(text_data, extended_spans)
+    widths = get_output_column_widths(text_data, spans)
+    heights = get_output_row_heights(text_data, spans)
+    cells = [
+        make_cell(text_data, span, widths, heights, box)
+        for span in spans
+    ]
+    cells = list(sorted(cells))
+    grid_table = merge_all_cells(cells, box)
+
+    return grid_table

span_table/types.py

@@ -0,0 +1,5 @@
+from typing import Annotated
+
+SpanType =  Annotated[list[tuple[int, int]], "List of tuples"]
+TableType = Annotated[list[list[str]], "List of list of strings with rich markup"]
+

span_table-0.1.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: span-table
+Version: 0.1.0
+Summary: span-table is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup.
+Project-URL: Repository, https://github.com/soamicharan/span-table
+Project-URL: Homepage, https://github.com/soamicharan/span-table
+Project-URL: Issues, https://github.com/soamicharan/span-table/issues
+Author-email: Soami Charan <charansoami@gmail.com>
+Maintainer-email: Soami Charan <charansoami@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ascii,merged cells,rich,span,table
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Requires-Dist: rich>=15.0.0
+Description-Content-Type: text/markdown
+
+# span-table
+
+`span-table` is a lightweight Python helper for rendering ASCII tables with merged cells using Rich-style markup.
+
+## Features
+
+- Render table layouts with custom merged spans
+- Support multi-line cell content
+- Uses `rich` box styles for flexible borders
+- Compatible with Python `>=3.14`
+
+## Installation
+
+```bash
+pip install span-table
+```
+
+## Quick Start
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Header 1", "Header 2", "Header3", "Header 4"],
+    ["row 1", "column 2", "column 3", "column 4"],
+    ["row 2", "Cells span columns.", "", ""],
+    ["row 3", "Cells\nspan rows.", "- Cells\n- contain\n- blocks", ""],
+    ["row 4", "", "", ""]
+]
+
+# Spans are defined as ((start_row, start_col), (end_row, end_col)) with zero-based indexes
+my_spans = [
+    ((2, 1), (2, 3)),
+    ((3, 1), (4, 1)),
+    ((3, 2), (4, 3)),
+]
+
+print(span_table(table, my_spans))
+```
+
+This renders:
+
+```text
+┌──────────┬────────────┬──────────┬──────────┐
+│ Header 1 │ Header 2   │ Header3  │ Header 4 │
+├──────────┼────────────┼──────────┼──────────┤
+│ row 1    │ column 2   │ column 3 │ column 4 │
+├──────────┼────────────┴──────────┴──────────┤
+│ row 2    │ Cells span columns.              │
+├──────────┼────────────┬─────────────────────┤
+│ row 3    │ Cells      │ - Cells             │
+├──────────┤ span rows. │ - contain           │
+│ row 4    │            │ - blocks            │
+└──────────┴────────────┴─────────────────────┘
+```
+
+## Advanced Usage
+
+```python
+from span_table import span_table
+from rich import print
+
+table = [
+    ["Time", "[on red]Height[/]", "", "[on green]Weight[/]", ""],
+    ["", "Total", "Change", "Total", "Change"],
+    ["15:30", "1", "2", "3", "4"]
+]
+
+spans = [
+    ((0, 0), (1, 0)),
+    ((0, 1), (0, 2)),
+    ((0, 3), (0, 4))
+]
+
+print(span_table(table, spans))
+```
+
+This renders:
+
+```text
+┌───────┬────────────────┬────────────────┐
+│ Time  │<red bg> Height │<Green BG>Weight│
+│       ├───────┬────────┼───────┬────────┤
+│       │ Total │ Change │ Total │ Change │
+├───────┼───────┼────────┼───────┼────────┤
+│ 15:30 │ 1     │ 2      │ 3     │ 4      │
+└───────┴───────┴────────┴───────┴────────┘
+```
+
+## API
+
+### `span_table(data, spans, box=rich_box.SQUARE) -> str`
+
+Render a text table with optional merged cells.
+
+- `data`: `list[list[str]]` — table rows and columns
+- `spans`: `list[tuple[tuple[int, int], tuple[int, int]]]` — list of merge regions
+- `box`: `rich.box.Box` — optional Rich box style such as `box.SQUARE`
+
+### Span rules
+
+- Each span is a rectangular region defined by a start and end coordinate
+- Coordinates are zero-based: `(row_index, column_index)`
+- Spans can cover a single cell or multiple cells
+- Spans must be within the table bounds
+
+## Rich markup support
+
+Cell values may include Rich markup tags such as `[bold]`, `[italic]`, or color tags but does not support emoji yet. The library preserves markup while measuring text layout.
+
+## Notes
+
+- Ensure each row has the same number of columns
+- Non-merged cells may be omitted from `spans`
+- The library automatically fills any cells not included in spans as standard individual cells

span_table-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+span_table/__init__.py,sha256=mDKjm-AX0BmcHOESBgYga29r7SNP5UgLZ64XO-ZN16A,54
+span_table/cell.py,sha256=HvQGf_mCf4vVccw2eCs59EAjwrurVDrZxl-LYaQYR44,8928
+span_table/markup_text.py,sha256=wMMA2itinGryiDn1t59BFW8ZPZqEFJoHHAX-SLEViBk,1809
+span_table/span.py,sha256=UKD45lw5sx7sUS12peQrdSq11XCKmD1jGcXkChImxoM,5021
+span_table/table.py,sha256=2TSIad3prC_qtq648QEzkYwQlX1zLv6lfhDBRHWNuFQ,1720
+span_table/types.py,sha256=c9PeMHS4Wmu71CH7OPG5uEzadFEPy08QpfizZafdt8U,177
+span_table-0.1.0.dist-info/METADATA,sha256=-moRHltS5Xn4Ym66fJGSOOG9Uki4GJXDIxyWbc24HCs,4951
+span_table-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+span_table-0.1.0.dist-info/licenses/LICENSE,sha256=-M09X0kv3P2rDVz4NY85k8ufAoc6ED4n5nyNJF0JvLQ,1069
+span_table-0.1.0.dist-info/RECORD,,

span_table-0.1.0.dist-info/WHEEL

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

span_table-0.1.0.dist-info/licenses/LICENSE

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