prettycsharp 1.0.0__py3-none-any.whl

prettycsharp/verify.py

@@ -0,0 +1,312 @@
+"""Checking that formatting changed layout, never meaning.
+
+The input and the output are parsed and reduced to canonical syntax trees,
+which must be equal. Canonicalization removes the differences the rewrites
+are allowed to make, each in its simplest form: every parenthesized
+expression is replaced by what it holds (the tree keeps the grouping), the
+modifiers of a declaration and a run of using directives are sorted, an
+attribute list is split into one list per attribute, a trailing comma is
+dropped, a single-statement body is put in expression form, a namespace is
+made file-scoped, an embedded statement gets braces, and regions are
+dropped. Comments must hold the same words, counted as a multiset, since
+rewrapping and reordering move them.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Sequence
+
+from prettycsharp.syntax import Comment, Node, SourceFile
+
+Canon = tuple[object, ...]
+
+_EMBEDDED = {
+    "if_statement": ("consequence", "alternative"),
+    "while_statement": ("body",),
+    "for_statement": ("body",),
+    "foreach_statement": ("body",),
+    "do_statement": ("body",),
+    "using_statement": ("body",),
+    "lock_statement": ("body",),
+    "fixed_statement": ("body",),
+}
+
+_BODY_OWNERS = frozenset(
+    {
+        "method_declaration",
+        "constructor_declaration",
+        "destructor_declaration",
+        "operator_declaration",
+        "conversion_operator_declaration",
+        "local_function_statement",
+        "accessor_declaration",
+    }
+)
+
+_MODIFIER_OWNERS = frozenset(
+    {
+        "class_declaration",
+        "struct_declaration",
+        "interface_declaration",
+        "record_declaration",
+        "enum_declaration",
+        "delegate_declaration",
+        "method_declaration",
+        "constructor_declaration",
+        "destructor_declaration",
+        "operator_declaration",
+        "conversion_operator_declaration",
+        "property_declaration",
+        "indexer_declaration",
+        "event_declaration",
+        "event_field_declaration",
+        "field_declaration",
+        "local_function_statement",
+    }
+)
+
+
+class VerificationError(Exception):
+    """The formatted text would not mean what the source meant."""
+
+
+def verify(before: SourceFile, after: SourceFile) -> None:
+    left = canonical(before.root)
+    right = canonical(after.root)
+    if left != right:
+        raise VerificationError(f"the formatted code differs from the source ({_first_difference(left, right)})")
+    if comment_words(before) != comment_words(after):
+        missing = comment_words(before) - comment_words(after)
+        extra = comment_words(after) - comment_words(before)
+        detail = next(iter(missing or extra))
+        raise VerificationError(f"the comments changed ({detail!r})")
+
+
+def comment_words(file: SourceFile) -> Counter[str]:
+    words: Counter[str] = Counter()
+    for comment in _all_comments(file):
+        text = comment.text
+        if text.startswith("///") and not text.startswith("////"):
+            words["///" + text[3:].strip()] += 1
+        elif text.startswith("//"):
+            words.update(text[2:].split())
+        else:
+            lines = [line.strip() for line in text.splitlines()]
+            words["/*" + "\n".join(lines)] += 1
+    return words
+
+
+def _all_comments(file: SourceFile) -> list[Comment]:
+    comments: list[Comment] = list(file.trailing_comments)
+    for token in file.tokens:
+        comments.extend(token.leading)
+        comments.extend(token.trailing)
+    return comments
+
+
+def canonical(node: Node) -> Canon:
+    if node.text is not None:
+        text = node.text.strip() if node.type == "preproc_arg" else node.text
+        return (node.type, text)
+    if node.type == "parenthesized_expression":
+        inner = [c for c in node.children if c.named]
+        if len(inner) == 1 and node.children[0].text == "(" and node.children[-1].text == ")":
+            return canonical(inner[0])
+    children = list(node.children)
+    if node.type == "compilation_unit":
+        children = _file_scoped(children)
+    if node.type in _BODY_OWNERS:
+        children = _expression_body(children)
+    if node.type in ("property_declaration", "indexer_declaration"):
+        children = _property_arrow(children)
+    out: list[object] = []
+    i = 0
+    while i < len(children):
+        child = children[i]
+        if child.type in ("preproc_region", "preproc_endregion"):
+            i += 1
+            continue
+        if child.type == "attribute_list" or child.type == "global_attribute":
+            out.extend(_split_attributes(child))
+        elif child.type == "using_directive":
+            run = []
+            while i < len(children) and children[i].type == "using_directive":
+                run.append(canonical(children[i]))
+                i += 1
+            out.extend(sorted(run, key=repr))
+            continue
+        elif child.type == "modifier" and node.type in _MODIFIER_OWNERS:
+            run = []
+            while i < len(children) and children[i].type == "modifier":
+                run.append(canonical(children[i]))
+                i += 1
+            out.extend(sorted(run, key=repr))
+            continue
+        elif (
+            child.text == ","
+            and i == len(children) - 2
+            and children[-1].text in ("}", "]")
+            and node.type != "array_rank_specifier"
+        ):
+            pass
+        elif node.type in _EMBEDDED and is_embedded(node, child) and _needs_braces(node, child):
+            out.append(("block", (("{", "{"), canonical(child), ("}", "}"))))
+        else:
+            out.append(canonical(child))
+        i += 1
+    return (node.type, tuple(out))
+
+
+def is_embedded(parent: Node, child: Node) -> bool:
+    """Whether ``child`` is a statement embedded in ``parent``, such as an if's body."""
+    fields = _EMBEDDED.get(parent.type)
+    if fields is None:
+        return False
+    if child.field in fields:
+        return True
+    # lock and fixed statements keep their body as an unnamed last child.
+    return (
+        parent.type in ("lock_statement", "fixed_statement")
+        and child is parent.children[-1]
+        and child.named
+        and child.type.endswith(("statement", "block"))
+    )
+
+
+def _needs_braces(parent: Node, child: Node) -> bool:
+    if child.type == "block":
+        return False
+    if parent.type == "if_statement" and child.field == "alternative" and child.type == "if_statement":
+        return False
+    return True
+
+
+def _split_attributes(node: Node) -> list[Canon]:
+    """``[t: A, B]`` as ``[t: A]`` ``[t: B]``."""
+    target: list[Canon] = []
+    attributes: list[Node] = []
+    for child in node.children:
+        if child.type == "attribute":
+            attributes.append(child)
+        elif child.type == "attribute_target_specifier":
+            target.append(canonical(child))
+        elif child.text not in ("[", "]", ","):
+            target.append(canonical(child))
+    if not attributes:
+        return [canonical(node)]
+    return [("attribute_list", (("[", "["), *target, canonical(a), ("]", "]"))) for a in attributes]
+
+
+def _expression_body(children: list[Node]) -> list[Node]:
+    """A block body of one return, expression or throw statement, in arrow form."""
+    for index, child in enumerate(children):
+        if child.field != "body" or child.type != "block":
+            continue
+        statements = child.children[1:-1]
+        if len(statements) != 1:
+            return children
+        statement = statements[0]
+        expression = _arrow_expression(statement)
+        if expression is None:
+            return children
+        arrow = Node(type="arrow_expression_clause", field="body")
+        arrow.children = [Node(type="=>", named=False, text="=>"), expression]
+        semicolon = Node(type=";", named=False, text=";")
+        rest = [c for c in children[index + 1 :] if c.text != ";"]
+        return [*children[:index], arrow, semicolon, *rest]
+    return children
+
+
+def _arrow_expression(statement: Node) -> Node | None:
+    kids = statement.children
+    if statement.type == "expression_statement" and len(kids) == 2 and kids[1].text == ";":
+        return kids[0]
+    # return x; and return this;, not return ref x;
+    if statement.type == "return_statement" and len(kids) == 3 and kids[2].text == ";" and kids[1].text != "ref":
+        return kids[1]
+    if statement.type == "throw_statement" and len(kids) == 3 and kids[2].text == ";":
+        thrown = Node(type="throw_expression")
+        thrown.children = [kids[0], kids[1]]
+        return thrown
+    return None
+
+
+def _property_arrow(children: list[Node]) -> list[Node]:
+    """A property with only a plain getter, in arrow form."""
+    for index, child in enumerate(children):
+        if child.type != "accessor_list":
+            continue
+        accessors = [c for c in child.children if c.type == "accessor_declaration"]
+        others = [c for c in child.children if c.type != "accessor_declaration" and c.text not in ("{", "}")]
+        if len(accessors) != 1 or others or index != len(children) - 1:
+            return children
+        accessor = accessors[0]
+        if [c.text for c in accessor.children if c.type != "block" and c.type != "arrow_expression_clause"] not in (
+            ["get"],
+            ["get", ";"],
+        ):
+            return children
+        body = _expression_body(accessor.children)
+        arrow = next((c for c in body if c.type == "arrow_expression_clause"), None)
+        if arrow is None:
+            return children
+        semicolon = Node(type=";", named=False, text=";")
+        return [*children[:index], arrow, semicolon]
+    return children
+
+
+def _file_scoped(children: list[Node]) -> list[Node]:
+    """The one block namespace of a file, as a file-scoped namespace."""
+    namespaces = [c for c in children if c.type == "namespace_declaration"]
+    if len(namespaces) != 1 or any(c.type == "file_scoped_namespace_declaration" for c in children):
+        return children
+    namespace = namespaces[0]
+    index = children.index(namespace)
+    allowed = ("using_directive", "extern_alias_directive", "global_attribute")
+    if any(c.type not in allowed and not c.type.startswith("preproc") for c in children[:index]):
+        return children
+    if any(not c.type.startswith("preproc") for c in children[index + 1 :]):
+        return children
+    body = namespace.child("body")
+    if body is None or body.type != "declaration_list" or len(body.children) < 2:
+        return children
+    members = body.children[1:-1]
+    if any(_contains_namespace(m) for m in members):
+        return children
+    head = [c for c in namespace.children if c is not body]
+    if any(c.text == ";" for c in head):
+        return children
+    scoped = Node(type="file_scoped_namespace_declaration")
+    scoped.children = [*head, Node(type=";", named=False, text=";")]
+    return [*children[:index], scoped, *members, *children[index + 1 :]]
+
+
+def _contains_namespace(node: Node) -> bool:
+    stack = [node]
+    while stack:
+        current = stack.pop()
+        if current.type in ("namespace_declaration", "file_scoped_namespace_declaration"):
+            return True
+        stack.extend(current.children)
+    return False
+
+
+def _first_difference(left: object, right: object, path: Sequence[str] = ()) -> str:
+    if isinstance(left, tuple) and isinstance(right, tuple):
+        if len(left) == 2 and len(right) == 2 and isinstance(left[1], str) and isinstance(right[1], str):
+            if left != right:
+                return f"{'/'.join(path)}: {left[1]!r} became {right[1]!r}"
+            return ""
+        if len(left) == 2 and len(right) == 2 and left[0] == right[0]:
+            a, b = left[1], right[1]
+            if isinstance(a, tuple) and isinstance(b, tuple):
+                for x, y in zip(a, b, strict=False):
+                    found = _first_difference(x, y, (*path, str(left[0])))
+                    if found:
+                        return found
+                if len(a) != len(b):
+                    return f"{'/'.join((*path, str(left[0])))}: {len(a)} children became {len(b)}"
+                return ""
+        return f"{'/'.join(path)}: {left[0]} became {right[0]}"
+    return "/".join(path)

prettycsharp-1.0.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.5
+Name: prettycsharp
+Version: 1.0.0
+Summary: An opinionated formatter for C#, in the spirit of Prettier
+Project-URL: Homepage, https://github.com/WilliamSmithEdward/prettyCSharp
+Project-URL: Repository, https://github.com/WilliamSmithEdward/prettyCSharp
+Project-URL: Issues, https://github.com/WilliamSmithEdward/prettyCSharp/issues
+Author: William Smith Edward
+License-Expression: MIT
+License-File: LICENSE
+Keywords: c#,code-style,csharp,dotnet,formatter,prettier,tree-sitter
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: tomli>=1.1.0; python_version < '3.11'
+Requires-Dist: tree-sitter-c-sharp>=0.23.1
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: mypy==2.4.0; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Requires-Dist: ruff==0.17.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# prettycsharp
+
+[![PyPI version](https://img.shields.io/pypi/v/prettycsharp)](https://pypi.org/project/prettycsharp/)
+[![Python versions](https://img.shields.io/pypi/pyversions/prettycsharp)](https://pypi.org/project/prettycsharp/)
+[![Downloads](https://static.pepy.tech/badge/prettycsharp/month)](https://pepy.tech/projects/prettycsharp)
+[![CI](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/ci.yml)
+[![Security](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/security.yml)
+[![Malware scan](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/malware-scan.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/prettyCSharp/actions/workflows/malware-scan.yml)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/WilliamSmithEdward/prettyCSharp/badge)](https://scorecard.dev/viewer/?uri=github.com/WilliamSmithEdward/prettyCSharp)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/WilliamSmithEdward/prettyCSharp/blob/main/LICENSE)
+
+An opinionated formatter for C#, written in Python, in the spirit of Prettier.
+It parses each file with [tree-sitter](https://tree-sitter.github.io/) and
+reprints the whole file in one consistent layout: braces, indentation, line
+breaks, blank lines, alignment and a few safe rewrites such as file-scoped
+namespaces, sorted usings and expression-bodied members. It needs no .NET
+SDK.
+
+Before:
+
+```csharp
+using System;
+using Microsoft.Extensions.Logging;
+namespace Shop.Orders {
+public class OrderService {
+    static private readonly int MaxRetries=3;
+    public decimal Total(Order order) { return order.Lines.Where(l => l.IsTaxable).Sum(l => l.Amount); }
+    public void Ship(Order order) {
+        if (order == null) return;
+        if (order.IsPaid) { Send(order); } else { Hold(order); }
+    }
+}
+}
+```
+
+After:
+
+```csharp
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Shop.Orders;
+
+public class OrderService
+{
+    private static readonly int MaxRetries = 3;
+
+    public decimal Total(Order order) =>
+        order.Lines
+            .Where(l => l.IsTaxable)
+            .Sum(l => l.Amount);
+
+    public void Ship(Order order)
+    {
+        if (order == null) return;
+
+        if (order.IsPaid)
+        {
+            Send(order);
+        }
+
+        else
+        {
+            Hold(order);
+        }
+    }
+}
+```
+
+## Install
+
+Python 3.10 or later.
+
+```bash
+pip install prettycsharp
+```
+
+## Use
+
+```bash
+prettycsharp format src/
+```
+```bash
+prettycsharp check src/
+```
+```bash
+prettycsharp diff Order.cs
+```
+
+`format` rewrites files in place, `check` exits 1 when any file would
+change, and `diff` prints a unified diff. `--write`, `--check` and `--diff`
+are aliases. Given one file and no command, the formatted file goes to
+stdout; `-` formats stdin to stdout, with `--stdin-filepath` naming the
+path whose settings apply.
+
+A target can be a `.cs` file, a folder, a `.csproj` (the files it
+compiles, after its `Compile Include` and `Remove` items) or a `.sln` or
+`.slnx` (every C# project in it). Folders are searched for `.cs` files.
+
+| Option | Meaning |
+| --- | --- |
+| `-o KEY=VALUE`, `--option` | Set one setting, over every settings file. Repeatable. |
+| `--config FILE` | Use this settings file instead of searching for one. |
+| `--no-ignore` | Do not skip what `.gitignore` and `.prettycsharpignore` list. |
+| `--stdin-filepath PATH` | The path stdin stands for. |
+
+Exit status: 0 when nothing needs to change, 1 when `check` or `diff` found
+a file that would change, 2 when a file could not be read, parsed or
+formatted, or a setting is wrong. A file that does not parse is reported
+and left untouched.
+
+From Python:
+
+```python
+from prettycsharp import CSharpSyntaxError, FormattingError, Settings, format_source
+
+formatted = format_source(source)
+narrow = format_source(source, Settings().with_values({"max_line_length": 100}))
+```
+
+## Settings
+
+Settings come from, highest precedence first:
+
+1. `-o` options on the command line;
+2. the nearest `.prettycsharp.toml`, or `pyproject.toml` with a
+   `[tool.prettycsharp]` table, found by walking up from each file;
+3. the standard keys of `.editorconfig` (`indent_style`, `indent_size`,
+   `max_line_length`, `end_of_line`, `charset`, `insert_final_newline`,
+   and the Roslyn keys for braces, `else`/`catch`/`finally` placement, using
+   order, namespace style, braces and modifier order);
+4. the defaults.
+
+```toml
+# .prettycsharp.toml
+max_line_length = 100
+brace_style = "kr"
+continuation_keywords = "same_line"
+align_assignments = false
+```
+
+Every setting, its default, its alternatives and an example of each layout
+are in
+[DESIGN.md](https://github.com/WilliamSmithEdward/prettyCSharp/blob/main/DESIGN.md).
+
+## Skipping files and code
+
+`bin/`, `obj/`, hidden folders and generated files (`*.g.cs`,
+`*.Designer.cs`, and files marked `<auto-generated>`) are always skipped.
+So is whatever `.gitignore` lists inside a git repository, and whatever a
+`.prettycsharpignore` file lists, in gitignore syntax.
+
+Inside a file, `// prettycsharp-ignore` leaves the next statement or member
+as written, and `// prettycsharp-ignore-start` ... `// prettycsharp-ignore-end`
+leaves everything between them as written.
+
+## How it stays safe
+
+Every output is parsed again and compared with the input as syntax trees,
+with only the changes the settings allow (parentheses, modifier and using
+order, attribute lists, trailing commas, expression bodies, namespace style,
+braces and regions) taken out of the comparison. The comments must hold the
+same words. If anything else differs, the file is not changed and the
+command reports the difference. String literals, including verbatim, raw and
+interpolated strings, are printed exactly as written.
+
+## Limits
+
+prettycsharp reads C# through tree-sitter's C# grammar, which parses every
+`#if` branch as code. A declaration or statement split between `#if` and
+`#else` therefore does not parse, and neither does syntax newer than the
+grammar (such as C# 14's null-conditional assignment). Such files are
+reported with their line and column and left untouched.
+
+## License
+
+[MIT](https://github.com/WilliamSmithEdward/prettyCSharp/blob/main/LICENSE)

prettycsharp-1.0.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+prettycsharp/__init__.py,sha256=2YPCftqUxMqYgSCIdxolZEgiJUTzze9bg7Lfukgv1vY,378
+prettycsharp/__main__.py,sha256=YUL16nU2FBOx2nJWBvuMaqSUo73TWH4tEyat839_TIw,64
+prettycsharp/cli.py,sha256=yEsWvztAd9ulnnkC5MNU5vHTVBq-D3zrPnV3M_qtPhw,9949
+prettycsharp/config.py,sha256=uxyv-fESIrJewN9203MHCdx9NVeUNKT7BucXjoVQt_s,9221
+prettycsharp/doc.py,sha256=3_b-qNVEbf_PodyBp59lMfCIz-8jSAu24OdfF6IafHM,20097
+prettycsharp/formatter.py,sha256=hjTFhtvd1rQlVpYLRBmcM9hsmNqjihPD4tPpv2ed2OQ,3808
+prettycsharp/ignore.py,sha256=gVltaT7c6IbA18AHW5w1EH6LvmG9vPfSVfze0wtpyPg,6205
+prettycsharp/parsing.py,sha256=jBKIM4c8quIB0WAER1i0GgTkD7S-zcgJuBlGadfajtI,1809
+prettycsharp/project.py,sha256=mzps6K-_vHBfWjBiltZiIXSwbmTKu0HHMOM0XKfKlnE,7178
+prettycsharp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prettycsharp/rewrites.py,sha256=lrIJFmP3QkmmQLEBZcenljttrBZzgp8NJf50a1Ta7pw,27295
+prettycsharp/settings.py,sha256=4Zo_dxUyZHFA0VqZQPmtFV88Y_1_zUwjbX6s7jEBViw,7037
+prettycsharp/syntax.py,sha256=jzxS7JeYhrn4vNbO7UetDIm42ur3X3I5ESsnaDqd03A,12378
+prettycsharp/verify.py,sha256=usnNWXu68bu3Wz-dafg7pA1VbNMj7rTlMwYbPI9oEgw,12210
+prettycsharp/printer/__init__.py,sha256=Uz_MD6_IaW9GWuZXSQIX2pW3UDdwrig3e1d4ZMfAsKE,994
+prettycsharp/printer/core.py,sha256=ugiGlig7u064cwUiUy5x_mHBKUgDeF8cBzSnaX-sEcU,20295
+prettycsharp/printer/declarations.py,sha256=M3jsLOpY-GOPvPKynETb4Yt8ASla-sF16s8ykmcm_2s,26246
+prettycsharp/printer/expressions.py,sha256=jOOuo9kp62fEzqexv5LwqzQHvvgsqh1_dCjJlnbWFdc,45581
+prettycsharp/printer/statements.py,sha256=x7PhyAMfrnMQVDMhB-HM68tonq5EsceSvVguMznIQ3Y,26618
+prettycsharp-1.0.0.dist-info/METADATA,sha256=wHaFQWHgVZbOtWkvtT8yg_Mr1RTpmgFbHupnY56nUwA,7922
+prettycsharp-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+prettycsharp-1.0.0.dist-info/entry_points.txt,sha256=LezlCMNm4uvzhnLmoneMBwVwBbA7ye1HJSPlO8JI3Uc,55
+prettycsharp-1.0.0.dist-info/licenses/LICENSE,sha256=iwoVDiLOSUadguAENb1gGfsHgtnNubULiepCUeG7RXw,1077
+prettycsharp-1.0.0.dist-info/RECORD,,

prettycsharp-1.0.0.dist-info/WHEEL

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

prettycsharp-1.0.0.dist-info/entry_points.txt

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

prettycsharp-1.0.0.dist-info/licenses/LICENSE

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