task2md 1.0.0__py3-none-any.whl

task2md/task/file.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+
+import yaml
+from pydantic import BaseModel
+
+from task2md.task.header import Header
+from task2md.task.task import Task
+from task2md.task.variable import Variable
+from task2md.util.dir import Dir
+
+
+class File(BaseModel):
+    """File Task content class"""
+
+    path: str = ""
+    content: str = ""
+    yaml: Dict[str, Any] = {}
+    header: Header = Header()
+    global_variables: List[Variable] = []
+    tasks: List[Task] = []
+    parsed: bool = False
+
+    def get_filename(self) -> str:
+        """Get filename without extension
+
+        Returns:
+            str: The filename
+        """
+        return Path(self.path).stem
+
+    def generate(self, dir: Dir) -> None:
+        """Generate markdown file in output directory
+
+        Args:
+            dir (Dir): The dir object
+        """
+        self.load()
+        self.parse()
+        output = self.to_md()
+
+        output_filename = dir.path + "/" + self.get_filename() + ".md"
+
+        with open(output_filename, "w") as f:
+            f.write(output)
+
+    def load(self) -> None:
+        """Load file content from path"""
+        with open(self.path) as f:
+            self.content = f.read()
+
+    def parse(self) -> None:
+        """Parse yaml content"""
+
+        yaml_content = yaml.safe_load(self.content)
+
+        if (yaml_content is not None) and isinstance(yaml_content, dict):
+            self.yaml = yaml_content
+
+        # 1 - Parse header:
+        header_lines = re.findall(r"# @.*", self.content, flags=re.MULTILINE)
+        self.header.parse(header_lines)
+
+        # 2 - Parse vars:
+        if ("vars" in self.yaml) and (self.yaml["vars"] is not None):
+            sorted_keys = sorted(self.yaml["vars"].keys())
+            for name in sorted_keys:
+                v = Variable(name=name)
+                if (self.yaml["vars"][name] is not None) and isinstance(
+                    self.yaml["vars"][name], str
+                ):
+                    v.value = self.yaml["vars"][name]
+
+                # Get comment if any
+                line_var = re.findall(
+                    r"^  " + v.name + ": .*$", self.content, flags=re.MULTILINE
+                )
+                if len(line_var) > 0:
+                    # Remove name and value of line
+                    desc = line_var[0].replace("  " + v.name + ": " + v.value, "")
+                    # if # remove -> description
+                    if "#" in desc:
+                        value_desc = desc.split("#", 1)
+                        v.description = value_desc[1].strip()
+
+                self.global_variables.append(v)
+
+        # 3 - Parse tasks:
+        if ("tasks" in self.yaml) and (self.yaml["tasks"] is not None):
+            sorted_keys = sorted(self.yaml["tasks"].keys())
+            for name in sorted_keys:
+                # Get task only if desc is defined
+                if (
+                    ("desc" in self.yaml["tasks"][name])
+                    and (self.yaml["tasks"][name]["desc"] is not None)
+                    and isinstance(self.yaml["tasks"][name]["desc"], str)
+                    and (len(self.yaml["tasks"][name]["desc"]) > 0)
+                ):
+                    t = Task(name=name, desc=self.yaml["tasks"][name]["desc"])
+                    if (
+                        ("summary" in self.yaml["tasks"][name])
+                        and (self.yaml["tasks"][name]["summary"] is not None)
+                        and isinstance(self.yaml["tasks"][name]["summary"], str)
+                        and (len(self.yaml["tasks"][name]["summary"]) > 0)
+                    ):
+                        t.summary = self.yaml["tasks"][name]["summary"]
+
+                    self.tasks.append(t)
+
+        self.parsed = True
+
+    def to_md(self) -> str:
+        """Return the content of the file in markdown
+
+        Returns:
+            str: Markdown content
+        """
+        output = ""
+        # Tag
+        output += self.tags_to_md()
+
+        # Top
+        output += "---\n\n# " + self.get_filename() + "\n\n"
+        output += self.header.description + "\n\n"
+        output += '!!! info "' + self.get_filename() + ' template details"\n\n'
+        output += self.header_to_md()
+
+        # Tasks list
+        output += "## :material-list-box: List of tasks\n"
+        output += self.tasks_list_to_md() + "\n"
+
+        # Global variables
+        output += "## :material-variable: global variables\n"
+        output += self.global_variables_to_md() + "\n"
+
+        # Tasks details
+        output += self.tasks_details_to_md()
+
+        return output
+
+    def tags_to_md(self) -> str:
+        """Return the tags list
+
+        Returns:
+            str: markdown content
+        """
+        output = ""
+        if len(self.header.tags) > 0:
+            output += "---\ntags:\n"
+            for tag in self.header.tags:
+                output += f"  - {tag}\n"
+
+        return output
+
+    def header_to_md(self) -> str:
+        """Return the header data
+
+        Returns:
+            str: markdown content
+        """
+        match self.header.status:
+            case "stable":
+                status_icon = "material-check-circle"
+                status_label = "stable"
+            case "deprecated":
+                status_icon = "material-delete"
+                status_label = "deprecated"
+            case "beta":
+                status_icon = "material-beta"
+                status_label = "beta"
+            case _:
+                status_icon = "material-draw"
+                status_label = "draft"
+
+        output = ""
+        output += f"    * :{status_icon}: Status: {status_label}\n"
+        output += (
+            "    * :material-bookmark-check: File: ["
+            + self.header.file_raw
+            + "]("
+            + self.header.file_ui
+            + ")\n"
+        )
+        output += (
+            "    * :material-home: Home: ["
+            + self.header.home
+            + "]("
+            + self.header.home
+            + ")\n"
+        )
+        output += f"    * :material-license: License: {self.header.license}\n\n"
+
+        return output
+
+    def tasks_list_to_md(self) -> str:
+        """Return the Tasks list to a markdown table
+
+        Returns:
+            str: markdown table
+        """
+        output = """
+| Tasks | Description |
+| ----- | ----------- |
+"""
+        for task in self.tasks:
+            file_name = self.get_filename()
+            output += (
+                f"| [`{file_name}:{task.name}`](#:simple-task:-{file_name}:{task.name})"
+                f" | {task.desc} |\n"
+            )
+
+        return output
+
+    def global_variables_to_md(self) -> str:
+        """Return the global variables to a markdown table
+
+        Returns:
+            str: markdown table
+        """
+        output = """
+| Variables | Description | Default value |
+| --------- | ----------- | ------------- |
+"""
+
+        if len(self.global_variables) == 0:
+            # Empty variable to generate a line with no value
+            v = Variable()
+            output += v.to_md() + "\n"
+        else:
+            for var in self.global_variables:
+                output += var.to_md() + "\n"
+
+        return output
+
+    def tasks_details_to_md(self) -> str:
+        """Return the Tasks details
+
+        Returns:
+            str: List of tasks details
+        """
+        output = ""
+
+        for task in self.tasks:
+            output += task.to_md(self.get_filename())
+
+        return output

task2md/task/header.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import re
+from typing import ClassVar, List
+
+from pydantic import BaseModel
+
+
+class Header(BaseModel):
+    """Header Task file class"""
+
+    PATTERN: ClassVar[str] = r"@([\w-]+): (.*)"
+
+    description: str = "-"
+    tags: List[str] = []
+    authors: List[str] = []
+    file_raw: str = ""
+    file_ui: str = ""
+    home: str = ""
+    links: List[str] = []
+    license: str = ""
+    status: str = ""
+    deprecated_tasks: List[str] = []
+
+    def parse(self, header_lines: List[str]) -> None:
+        """Parse the header comment of a Task file
+
+        Args:
+            header_lines (List[str]): List of header lines
+        """
+        for line in header_lines:
+            match = re.search(Header.PATTERN, line)
+            if match:
+                label, value = match.groups()
+                match label.strip():
+                    case "description":
+                        self.description = value.strip()
+                    case "tags":
+                        self.tags = Header.string2list(value)
+                    case "authors":
+                        self.authors = Header.string2list(value)
+                    case "file-raw":
+                        self.file_raw = value.strip()
+                    case "file-ui":
+                        self.file_ui = value.strip()
+                    case "home":
+                        self.home = value.strip()
+                    case "links":
+                        self.links = Header.string2list(value)
+                    case "license":
+                        self.license = value.strip()
+                    case "status":
+                        self.status = value.strip()
+                    case "deprecated-tasks":
+                        self.deprecated_tasks = Header.string2list(value)
+
+    @classmethod
+    def string2list(cls, input: str) -> List[str]:
+        """Split a string with comma separator
+
+        Args:
+            input (str): string to split
+
+        Returns:
+            List[str]: A list of string
+        """
+        list = input.split(",")
+        output = []
+        for element in list:
+            output.append(element.strip())
+
+        return output

task2md/task/task.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+
+import re
+from typing import ClassVar, List
+
+from pydantic import BaseModel
+
+
+class Argument(BaseModel):
+    label: str = ""
+    value: str = ""
+
+
+class Task(BaseModel):
+    """Task class"""
+
+    LINE_ARG: ClassVar[str] = "Arguments:"
+    PATTERN_ARG: ClassVar[str] = r"([\w-]+\s*[|]\s*[\w-]*): (.*)"
+    LINE_REQ: ClassVar[str] = "Requirements:"
+    PATTERN_REQ: ClassVar[str] = r"(-\s.*)"
+
+    name: str = ""
+    desc: str = ""
+    summary: str = ""
+    summary_head: str = ""
+    summary_args: List[Argument] = []
+    summary_req: List[str] = []
+    summary_comments: str = ""
+    parsed: bool = False
+
+    def parse(self) -> None:
+        """Parse the Task summary"""
+        # Head - get beginning until blank line
+        lines = self.summary.splitlines()
+        head: List[str] = []
+        for line in lines:
+            if line.strip():
+                head.append(line)
+            else:
+                break
+
+        self.summary_head = "\n".join(head) + "\n"
+        # Get partial summary without head lines
+        count_line_head = len(head)
+        index_partial_summary = max(0, count_line_head)
+        partial_summary_lines = lines[index_partial_summary:]
+        partial_summary_lines_count = len(partial_summary_lines)
+
+        # Arguments
+        found_arguments = False
+        for i, line in enumerate(partial_summary_lines):
+            if (line.strip() == Task.LINE_ARG) and (
+                (i + 1) < partial_summary_lines_count
+            ):
+                found_arguments = True
+                # Parse arguments
+                args_summary_lines = partial_summary_lines[(i + 1) :]
+                for j, line_arg in enumerate(args_summary_lines):
+                    match = re.search(Task.PATTERN_ARG, line_arg.strip())
+                    if match:
+                        label, value = match.groups()
+                        arg = Argument(label=label.strip(), value=value.strip())
+                        self.summary_args.append(arg)
+                    else:
+                        break
+            if found_arguments:
+                del partial_summary_lines[i : (i + j + 2)]
+                break
+
+        # Requirements
+        partial_summary_lines_count = len(partial_summary_lines)
+        found_req = False
+        for i, line in enumerate(partial_summary_lines):
+            if (line.strip() == Task.LINE_REQ) and (
+                (i + 1) < partial_summary_lines_count
+            ):
+                found_req = True
+                # Parse req
+                req_summary_lines = partial_summary_lines[(i + 1) :]
+                for j, line_req in enumerate(req_summary_lines):
+                    match = re.search(Task.PATTERN_REQ, line_req.strip())
+                    if match:
+                        req = match.groups()
+                        self.summary_req.append(req[0])
+                    else:
+                        break
+            if found_req:
+                del partial_summary_lines[i : (i + j + 2)]
+                break
+
+        # Comments
+        self.summary_comments = "\n".join(partial_summary_lines).strip("\n")
+
+        self.parsed = True
+
+    def to_md(self, file_name: str) -> str:
+        """Return the details of the task
+
+        Args:
+            file_name (str): File_name of the task file.
+
+        Returns:
+            str: Markdown of the task details
+        """
+        self.parse()
+        output = f"\n## :simple-task: {file_name}:{self.name}\n\n"
+
+        output += f"{self.desc} \n\n"
+        output += "```shell\n"
+        output += self.summary_head
+        output += "```\n"
+
+        # Arguments
+        output += """
+| Arguments | Description |
+| --------- | ----------- |
+"""
+        if len(self.summary_args) == 0:
+            output += "| - | - |\n"
+        else:
+            for arg in self.summary_args:
+                label = arg.label.replace("|", "\\|")
+                output += f"| `{label}` | {arg.value} |\n"
+        output += "\n"
+
+        # Comments
+        output += f"{self.summary_comments}\n\n"
+
+        # Requirements
+        output += '!!! info "Requirements:"\n\n'
+        if len(self.summary_req) == 0:
+            output += "    - None\n"
+        else:
+            for req in self.summary_req:
+                output += f"    {req}\n"
+
+        return output

task2md/task/variable.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from pydantic import BaseModel
+
+
+class Variable(BaseModel):
+    name: str = ""
+    value: str = ""
+    description: str = ""
+
+    def to_md(self) -> str:
+        """Return the details of the variable
+
+        Returns:
+            str: Markdown columns of the variable details
+        """
+        if self.name == "":
+            name = " - "
+        else:
+            name = "`" + self.name + "`"
+        if self.description == "":
+            description = " - "
+        else:
+            description = self.description
+        if self.value == "":
+            value = " - "
+        else:
+            value = "`" + self.value + "`"
+
+        return f"| {name} | {description} | {value} |"

task2md/task2md.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+
+import os
+from typing import List
+
+import click
+
+from task2md.task.file import File
+from task2md.util.dir import Dir
+
+
+@click.group()
+@click.version_option("1.0.0", prog_name="task2md")
+def cli() -> None:
+    """A CLI tool to generate markdown documentation files from Task files."""
+    pass
+
+
+@cli.command()
+@click.option(
+    "-i",
+    "--input",
+    "input_dir",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    required=True,
+    help="Input directory",
+)
+@click.option(
+    "-d",
+    "--dir",
+    "output_dir",
+    type=click.Path(exists=False, file_okay=False, dir_okay=True, writable=True),
+    required=False,
+    help="Output markdown documentation files directory. Default current directory.",
+)
+def dir(
+    input_dir: click.Path,
+    output_dir: click.Path,
+) -> None:
+    """Command to generate a markdown documentation file from a directory.
+
+    Raises:
+        click.ClickException: Error when reading input file or writing output file
+    """
+    task_files: List[str] = []
+    in_dir = click.format_filename(str(input_dir))
+    for filename in os.listdir(in_dir):
+        if filename.endswith(".yml") or filename.endswith(".yaml"):
+            task_files.append(filename)
+
+    if len(task_files) == 0:
+        click.echo(f"No yaml file found in: {in_dir}")
+    else:
+        try:
+            out_dir = Dir(output_dir, True)
+
+        except OSError as error:
+            raise click.ClickException(
+                "Output directory can not be created!\n" + str(error)
+            )
+
+        try:
+            for filename in task_files:
+                task_file = File(path=f"{in_dir}/{filename}")
+                task_file.generate(out_dir)
+
+                click.echo(
+                    f"Task documentation generated: {task_file.get_filename()}.md"
+                )
+
+        except ValueError as ve:
+            raise click.ClickException(
+                "Error on reading file {} :\n {}".format(filename, str(ve))
+            )
+
+
+@cli.command()
+@click.option(
+    "-i",
+    "--input",
+    "input_file",
+    type=click.Path(exists=True, file_okay=True, dir_okay=False),
+    required=True,
+    help="Input Task yaml file.",
+)
+@click.option(
+    "-d",
+    "--dir",
+    "output_dir",
+    type=click.Path(exists=False, file_okay=False, dir_okay=True, writable=True),
+    required=False,
+    help="Output markdown documentation files directory. Default current directory.",
+)
+def file(
+    input_file: click.Path,
+    output_dir: click.Path,
+) -> None:
+    """Command to generate a markdown documentation file from a Task file.
+
+    Raises:
+        click.ClickException: Error when reading input file or writing output file
+    """
+    input_filename = click.format_filename(str(input_file))
+    task_file = File(path=input_filename)
+
+    try:
+        dir = Dir(output_dir, True)
+
+    except OSError as error:
+        raise click.ClickException(
+            "Output directory can not be created!\n" + str(error)
+        )
+
+    try:
+        task_file.generate(dir)
+
+        click.echo(f"Task documentation generated: {task_file.get_filename()}.md")
+
+    except ValueError as ve:
+        raise click.ClickException(
+            "Error on reading file {} :\n {}".format(input_filename, str(ve))
+        )
+
+
+if __name__ == "__main__":
+    cli()  # pragma: no cover

task2md/util/dir.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import click
+from pydantic import BaseModel
+
+
+class Dir(BaseModel):
+    """Utility class for a directory."""
+
+    path: str
+
+    def __init__(self, dir_path: click.Path | None = None, create: bool = False):
+        """Constructor.
+
+        Args:
+            dir_path (click.Path | None): Directory file path. \
+                Current working directory if None.
+            create (bool, optional): Create directory if doesn't exist. \
+                Defaults to False.
+
+        Raises:
+            FileNotFoundError: When create is False and directory not found.
+        """
+        if dir_path is None:
+            path = os.getcwd()
+        else:
+            path = click.format_filename(str(dir_path))
+
+        if not os.path.exists(path):
+            if create:
+                os.makedirs(path)
+            else:
+                raise FileNotFoundError(f"Directory {path} not found!")
+
+        super().__init__(path=path)

task2md-1.0.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.3
+Name: task2md
+Version: 1.0.0
+Summary: A program to generate markdown documentation files from Task files
+Project-URL: Homepage, https://gitlab.com/op_so/task/task2md
+Project-URL: Documentation, https://op_so.gitlab.io/task/task2md/
+Author-email: FX Soubirou <soubirou@yahoo.fr>
+License: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: pydantic>=2.6.3
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: types-pyyaml>=6.0.12.12
+Description-Content-Type: text/markdown
+
+# `task2md`
+
+[![Software License](https://img.shields.io/badge/license-MIT-informational.svg?style=for-the-badge)](LICENSE)
+[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release&style=for-the-badge)](https://github.com/semantic-release/semantic-release)
+[![Pipeline Status](https://gitlab.com/op_so/task/task2md/badges/main/pipeline.svg)](https://gitlab.com/op_so/task/task2md/pipelines)
+
+[![Built with Material for MkDocs](https://img.shields.io/badge/Material_for_MkDocs-526CFE?style=for-the-badge&logo=MaterialForMkDocs&logoColor=white)](https://op_so.gitlab.io/task/task2md/) Source code documentation
+
+A CLI tool to generate from [Task](https://taskfile.dev/) files, some markdown
+documentation files for [`mkdocs`](https://squidfunk.github.io/mkdocs-material/) static site.
+
+```bash
+Usage: task2md [OPTIONS] COMMAND [ARGS]...
+
+  A CLI tool to generate markdown documentation files from Task files.
+
+Options:
+  --version  Show the version and exit.
+  --help     Show this message and exit.
+
+Commands:
+  dir   Command to generate a markdown documentation file from a directory.
+  file  Command to generate a markdown documentation file from a Task file.
+```
+
+## `dir`
+
+Get all files with `yaml/yml` extension from the input directory and generate the
+markdown files in the output directory.
+
+```bash
+Usage: task2md dir [OPTIONS]
+
+  Command to generate a markdown documentation file from a directory.
+
+  Raises:     click.ClickException: Error when reading input file or writing
+  output file
+
+Options:
+  -i, --input DIRECTORY  Input directory  [required]
+  -d, --dir DIRECTORY    Output markdown documentation files directory.
+                         Default current directory.
+  --help                 Show this message and exit.
+```
+
+Example:
+
+```bash
+task2md dir --input Taskfile.d/ -d doc_dir/
+```
+
+## `file`
+
+Generate from the input file a markdown file in the output directory.
+
+```bash
+Usage: task2md file [OPTIONS]
+
+  Command to generate a markdown documentation file from a Task file.
+
+  Raises:     click.ClickException: Error when reading input file or writing
+  output file
+
+Options:
+  -i, --input FILE     Input Task yaml file.  [required]
+  -d, --dir DIRECTORY  Output markdown documentation files directory. Default
+                       current directory.
+  --help               Show this message and exit.
+```
+
+Example:
+
+```bash
+task2md file --input Taskfile.d/lint.yml -d doc_dir/
+```
+
+## Installation
+
+### With `Python` environment
+
+To use:
+
+- Minimal Python version: 3.10
+
+Installation with Python `pip`:
+
+```bash
+python3 -m pip install task2md
+task2md --help
+```
+
+## Authors
+
+<!-- vale off -->
+- **FX Soubirou** - *Initial work* - [GitLab repositories](https://gitlab.com/op_so)
+<!-- vale on -->
+
+## License
+
+<!-- vale off -->
+This program is free software: you can redistribute it and/or modify it under the terms of the MIT License (MIT).
+See the [LICENSE](https://opensource.org/licenses/MIT) for details.
+<!-- vale on -->

task2md-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+task2md/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+task2md/task2md.py,sha256=AoCIV0xE3-a5WibvXNGqLpaWDxZXQsVIIOwtmj3lq7U,3328
+task2md/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+task2md/task/file.py,sha256=09YxIXDgQShrnLdvMPh-yoB4UCjbOlbFxPYm-FgsgpQ,7466
+task2md/task/header.py,sha256=MY_uqIGgFPY6cGVs52ZegPtD0Szq0-Tq6PxTshl7Pgc,2180
+task2md/task/task.py,sha256=wrYNAql_LZhS9YVEj85OIjVcjF8ZdChenO-zb1dqUYc,4314
+task2md/task/variable.py,sha256=jSmG9jHeyHz7_gEu2bY2LYvJGBG_NRo1HRjfypM44FQ,713
+task2md/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+task2md/util/dir.py,sha256=2MeWmhMGkxFiJuZI6xcf71YRhhqBq1HqbDI4tKc2FOc,965
+task2md-1.0.0.dist-info/METADATA,sha256=TtuyDxej0KNYgjEncpnmVje-nWsFDlaPY8ewRxvltAI,3686
+task2md-1.0.0.dist-info/WHEEL,sha256=uNdcs2TADwSd5pVaP0Z_kcjcvvTUklh2S7bxZMF8Uj0,87
+task2md-1.0.0.dist-info/entry_points.txt,sha256=zXCjf5tbisw5ZzMarzBDlSkNgzV1YDsMx3s8h9azjkc,48
+task2md-1.0.0.dist-info/licenses/LICENSE,sha256=6j37YDpY2ikwX8yV80eUpAGPDShonchJW9nyFpqAGKM,1095
+task2md-1.0.0.dist-info/RECORD,,

task2md-1.0.0.dist-info/WHEEL

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

task2md-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+task2md = task2md.task2md:cli

task2md-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2024 FX Soubirou soubirou@yahoo.fr
+
+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.