threadcheck 0.0.1__py3-none-any.whl

threadcheck/static/visitors.py

@@ -0,0 +1,324 @@
+import ast
+from pathlib import Path
+
+from .models import RaceWarning, Severity, WarningCategory, Confidence
+
+
+def _calc_confidence(context, func_name: str | None) -> Confidence:
+    if func_name and context.is_thread_target(func_name):
+        return Confidence.HIGH
+    if context.has_any_thread():
+        return Confidence.MEDIUM
+    return Confidence.LOW
+
+
+class GlobalVisitor(ast.NodeVisitor):
+    def __init__(self, filepath: Path, context):
+        self.filepath = filepath
+        self.context = context
+        self.warnings: list[RaceWarning] = []
+        self._globals_in_function: set[str] = set()
+        self._current_func: str | None = None
+
+    def visit_FunctionDef(self, node):
+        old = self._globals_in_function, self._current_func
+        self._globals_in_function = set()
+        self._current_func = node.name
+        self.generic_visit(node)
+        self._globals_in_function, self._current_func = old
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def visit_Global(self, node):
+        for name in node.names:
+            self._globals_in_function.add(name)
+
+    def _check_name(self, node):
+        if isinstance(node, ast.Name) and node.id in self._globals_in_function:
+            if self.context.is_protected(node.lineno):
+                return
+            confidence = _calc_confidence(self.context, self._current_func)
+            self.warnings.append(
+                RaceWarning(
+                    file=self.filepath,
+                    line=node.lineno,
+                    col=node.col_offset,
+                    severity=Severity.WARNING,
+                    category=WarningCategory.UNSAFE_GLOBAL,
+                    message=f"Global variable `{node.id}` modified without lock",
+                    suggestion=f"Use `threading.Lock()` to protect `{node.id}`",
+                    confidence=confidence,
+                )
+            )
+
+    def visit_Assign(self, node):
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self._check_name(target)
+            elif isinstance(target, (ast.Tuple, ast.List)):
+                for elt in target.elts:
+                    if isinstance(elt, ast.Name):
+                        self._check_name(elt)
+        self.generic_visit(node)
+
+    def visit_AugAssign(self, node):
+        self._check_name(node.target)
+        self.generic_visit(node)
+
+    def visit_Delete(self, node):
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self._check_name(target)
+        self.generic_visit(node)
+
+
+class NonlocalVisitor(ast.NodeVisitor):
+    def __init__(self, filepath: Path, context):
+        self.filepath = filepath
+        self.context = context
+        self.warnings: list[RaceWarning] = []
+        self._nonlocals_in_function: set[str] = set()
+        self._current_func: str | None = None
+
+    def visit_FunctionDef(self, node):
+        old = self._nonlocals_in_function, self._current_func
+        self._nonlocals_in_function = set()
+        self._current_func = node.name
+        self.generic_visit(node)
+        self._nonlocals_in_function, self._current_func = old
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def visit_Nonlocal(self, node):
+        for name in node.names:
+            self._nonlocals_in_function.add(name)
+
+    def _check_name(self, node):
+        if isinstance(node, ast.Name) and node.id in self._nonlocals_in_function:
+            if self.context.is_protected(node.lineno):
+                return
+            confidence = _calc_confidence(self.context, self._current_func)
+            self.warnings.append(
+                RaceWarning(
+                    file=self.filepath,
+                    line=node.lineno,
+                    col=node.col_offset,
+                    severity=Severity.WARNING,
+                    category=WarningCategory.UNSAFE_NONLOCAL,
+                    message=f"Nonlocal variable `{node.id}` modified without lock",
+                    suggestion=f"Use `threading.Lock()` to protect `{node.id}`",
+                    confidence=confidence,
+                )
+            )
+
+    def visit_Assign(self, node):
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self._check_name(target)
+            elif isinstance(target, (ast.Tuple, ast.List)):
+                for elt in target.elts:
+                    if isinstance(elt, ast.Name):
+                        self._check_name(elt)
+        self.generic_visit(node)
+
+    def visit_AugAssign(self, node):
+        self._check_name(node.target)
+        self.generic_visit(node)
+
+    def visit_Delete(self, node):
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self._check_name(target)
+        self.generic_visit(node)
+
+
+class ThreadVisitor(ast.NodeVisitor):
+    def __init__(self, filepath: Path, context):
+        self.filepath = filepath
+        self.context = context
+        self.warnings: list[RaceWarning] = []
+
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Attribute) and node.func.attr == "Thread":
+            if isinstance(node.func.value, ast.Name) and node.func.value.id == "threading":
+                target = None
+                for kw in node.keywords:
+                    if kw.arg == "target":
+                        if isinstance(kw.value, ast.Name):
+                            target = kw.value.id
+                        elif isinstance(kw.value, (ast.Lambda, ast.FunctionDef)):
+                            target = "<lambda>"
+                        elif isinstance(kw.value, ast.Attribute):
+                            target = ast.unparse(kw.value)
+                label = f" (target={target})" if target else ""
+                self.warnings.append(
+                    RaceWarning(
+                        file=self.filepath,
+                        line=node.lineno,
+                        col=node.col_offset,
+                        severity=Severity.INFO,
+                        category=WarningCategory.THREAD_USAGE,
+                        message=f"Thread creation detected{label}",
+                        suggestion="Ensure shared variable access in thread functions is lock-protected",
+                        confidence=Confidence.LOW,
+                    )
+                )
+        self.generic_visit(node)
+
+
+class SharedMutableVisitor(ast.NodeVisitor):
+    def __init__(self, filepath: Path, context):
+        self.filepath = filepath
+        self.context = context
+        self.warnings: list[RaceWarning] = []
+        self._module_level_assigns: set[str] = set()
+        self._in_function = False
+        self._current_func: str | None = None
+
+    def visit_Module(self, node):
+        for item in node.body:
+            if isinstance(item, ast.Assign):
+                for target in item.targets:
+                    if isinstance(target, ast.Name) and _is_mutable_literal(item.value):
+                        self._module_level_assigns.add(target.id)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self._in_function = True
+        self._current_func = node.name
+        self.generic_visit(node)
+        self._current_func = None
+        self._in_function = False
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def _add_warning(self, node, var_name: str, detail: str = ""):
+        if self.context.is_protected(node.lineno):
+            return
+        confidence = _calc_confidence(self.context, self._current_func)
+        msg = f"Module-level mutable object `{var_name}` modified inside function"
+        if detail:
+            msg = f"Module-level mutable object `{detail}` called from multiple threads"
+        self.warnings.append(
+            RaceWarning(
+                file=self.filepath,
+                line=node.lineno,
+                col=node.col_offset,
+                severity=Severity.WARNING,
+                category=WarningCategory.SHARED_MUTABLE,
+                message=msg,
+                suggestion="Consider using thread-safe data structures or add lock protection",
+                confidence=confidence,
+            )
+        )
+
+    def visit_Assign(self, node):
+        if self._in_function:
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id in self._module_level_assigns:
+                    self._add_warning(node, target.id)
+        self.generic_visit(node)
+
+    def visit_AugAssign(self, node):
+        if self._in_function and isinstance(node.target, ast.Name):
+            if node.target.id in self._module_level_assigns:
+                self._add_warning(node, node.target.id)
+        self.generic_visit(node)
+
+    def visit_Call(self, node):
+        if self._in_function:
+            if isinstance(node.func, ast.Attribute) and node.func.attr in (
+                "append", "extend", "pop", "remove", "clear",
+                "insert", "sort", "reverse", "update", "add", "discard",
+            ):
+                if isinstance(node.func.value, ast.Name) and node.func.value.id in self._module_level_assigns:
+                    detail = f"{node.func.value.id}.{node.func.attr}()"
+                    self._add_warning(node, node.func.value.id, detail)
+        self.generic_visit(node)
+
+
+class ClassAttributeVisitor(ast.NodeVisitor):
+    def __init__(self, filepath: Path, context):
+        self.filepath = filepath
+        self.context = context
+        self.warnings: list[RaceWarning] = []
+        self._current_class: str | None = None
+        self._current_method: str | None = None
+        self._class_is_thread = False
+
+    def visit_ClassDef(self, node):
+        old = self._current_class, self._class_is_thread
+        self._current_class = node.name
+        self._class_is_thread = any(
+            _is_name_or_attr(base, "Thread") for base in node.bases
+        )
+        self.generic_visit(node)
+        self._current_class, self._class_is_thread = old
+
+    def visit_FunctionDef(self, node):
+        old = self._current_method
+        if node.name in ("__init__", "__new__", "__class_getitem__"):
+            self._current_method = None
+            self.generic_visit(node)
+            self._current_method = old
+            return
+        self._current_method = node.name
+        self.generic_visit(node)
+        self._current_method = old
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+    def _check_attr(self, node, attr_name: str):
+        if self.context.is_protected(node.lineno):
+            return
+        in_thread_target = self._current_method and self.context.is_thread_target(
+            self._current_method
+        )
+        if in_thread_target or self._class_is_thread:
+            confidence = Confidence.HIGH
+        elif self.context.has_any_thread():
+            confidence = Confidence.MEDIUM
+        else:
+            confidence = Confidence.LOW
+        self.warnings.append(
+            RaceWarning(
+                file=self.filepath,
+                line=node.lineno,
+                col=node.col_offset,
+                severity=Severity.WARNING,
+                category=WarningCategory.CLASS_ATTRIBUTE,
+                message=(
+                    f"Attribute `{attr_name}` of class `{self._current_class}` "
+                    f"modified without lock in method `{self._current_method}`"
+                ),
+                suggestion="Use `threading.Lock()` to protect class attribute access",
+                confidence=confidence,
+            )
+        )
+
+    def visit_Assign(self, node):
+        if self._current_class and self._current_method:
+            for target in node.targets:
+                if isinstance(target, ast.Attribute):
+                    if isinstance(target.value, ast.Name) and target.value.id == "self":
+                        self._check_attr(node, target.attr)
+        self.generic_visit(node)
+
+    def visit_AugAssign(self, node):
+        if self._current_class and self._current_method:
+            if isinstance(node.target, ast.Attribute):
+                if isinstance(node.target.value, ast.Name) and node.target.value.id == "self":
+                    self._check_attr(node, node.target.attr)
+        self.generic_visit(node)
+
+
+def _is_mutable_literal(node):
+    return isinstance(node, (ast.List, ast.Dict, ast.Set, ast.ListComp, ast.SetComp, ast.DictComp))
+
+
+def _is_name_or_attr(node, name: str) -> bool:
+    if isinstance(node, ast.Name):
+        return node.id == name
+    if isinstance(node, ast.Attribute):
+        return node.attr == name
+    return False

threadcheck-0.0.1.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: threadcheck
+Version: 0.0.1
+Summary: Data Race Detector for Free-Threading Python
+Project-URL: Homepage, https://github.com/ChidcGithub/Threadcheck
+Project-URL: Source, https://github.com/ChidcGithub/Threadcheck
+Project-URL: BugTracker, https://github.com/ChidcGithub/Threadcheck/issues
+Author: threadcheck contributors
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.12
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# threadcheck
+
+[![Python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI](https://img.shields.io/badge/pypi-v0.0.0-orange)](https://pypi.org/project/threadcheck/)
+[![Tests](https://img.shields.io/badge/tests-21%2F21-passing-brightgreen)]()
+
+[**中文文档**](README_CN.md)
+
+Python data race detector for the free-threading (no-GIL) era. Detects concurrent access to shared mutable state in multi-threaded Python programs through static analysis and runtime instrumentation.
+
+---
+
+## Problem
+
+Python 3.14 (2026) introduces free-threading, removing the Global Interpreter Lock (GIL). This enables true parallel execution of multi-threaded code, but the ecosystem lacks debugging tools for concurrency bugs. Go has `-race`, C++ has ThreadSanitizer, Java has SpotBugs. Python has nothing comparable without recompiling the interpreter with Clang and TSan.
+
+threadcheck is a pure-Python race detector that installs with `pip` and works out of the box.
+
+---
+
+## Features
+
+- **Static analysis** -- scans AST for shared mutable state (global, nonlocal, class attributes) and missing lock protection
+- **Runtime detection** -- instruments code via AST transformation at import time; tracks memory accesses with vector clocks and detects happens-before violations
+- **Lock-aware suppression** -- understands `threading.Lock`, `threading.RLock`, and `with`-based synchronization; raises confidence when locks are missing and suppresses warnings when they are present
+- **Confidence scoring** -- each warning tagged HIGH / MEDIUM / LOW based on thread context and lock coverage
+- **CLI tool** -- single-command static scan or instrumented execution
+- **JSON and SARIF output** -- suitable for CI/CD pipeline integration
+
+---
+
+## Installation
+
+```bash
+pip install threadcheck
+```
+
+Requires Python 3.12+. Python 3.14+ is recommended for free-threading features.
+
+---
+
+## Quick Start
+
+### Static Analysis
+
+Scan a file or directory for potential race conditions without running any code:
+
+```bash
+threadcheck scan my_project/
+```
+
+Output:
+
+```
+[WARNING] [HIGH] [unsafe_global] my_project/counter.py:8:8
+       Global variable `counter` modified without lock in thread
+       Suggestion: use `threading.Lock()` to protect access
+```
+
+JSON output:
+
+```bash
+threadcheck scan my_project/ --json -o report.json
+```
+
+### Runtime Detection
+
+Execute a script with instrumentation to detect actual data races:
+
+```bash
+threadcheck run my_script.py
+```
+
+Output for a racing script:
+
+```
+Data races detected:
+  [!] `counter`
+      Thread-28928 (write) at my_script.py:8
+      Thread-9888 (write) at my_script.py:8
+```
+
+A script protected with locks reports:
+
+```
+No data races detected
+```
+
+### CI Integration
+
+```bash
+pip install threadcheck
+threadcheck scan src/ --json -o threadcheck_report.json
+```
+
+---
+
+## Commands
+
+| Command | Description | Status |
+|---|---|---|
+| `scan <path>` | Static race analysis of file or directory | Stable |
+| `run <script>` | Execute script with runtime race detection | Beta |
+| `check-compat <path>` | Free-threading compatibility check | Planned |
+
+---
+
+## Library Usage
+
+```python
+from threadcheck import analyze_file, analyze_path
+
+warnings = analyze_file("my_module.py")
+warnings = analyze_path("src/")
+
+for w in warnings:
+    print(f"{w.file}:{w.line} [{w.confidence.value}] {w.message}")
+```
+
+```python
+from threadcheck.dynamic.tracker import ThreadCheckTracker
+from threadcheck.dynamic.transform import transform_and_compile
+
+code = transform_and_compile(source, "script.py")
+ThreadCheckTracker.start()
+exec(code, {"_threadcheck_tracker": ThreadCheckTracker})
+ThreadCheckTracker.stop()
+
+print(ThreadCheckTracker.format_races())
+ThreadCheckTracker.reset()
+```
+
+---
+
+## Architecture
+
+### Static Analysis Pipeline
+
+1. Parse source into AST
+2. Identify shared mutable state: globals, nonlocals, class attributes (`self.x`), module-level mutable objects
+3. Detect thread creation sites (`threading.Thread`)
+4. Cross-reference with lock usage (`with lock:`, `lock.acquire()`)
+5. Assign confidence: HIGH (thread target, no lock), MEDIUM (thread present, no lock), LOW (suspicious pattern, no thread context)
+6. Report findings with repair suggestions
+
+### Runtime Detection Pipeline
+
+1. Parse source into AST
+2. Identify shared variables per function scope
+3. Transform AST: inject `write_before()`, `lock_acquire()`, `lock_release()` calls around shared variable accesses
+4. Compile and execute transformed code under a tracker that maintains per-thread vector clocks
+5. On lock acquire, synchronize clocks (happens-before merge)
+6. After execution, scan access log for conflicting operations (concurrent writes or write-read pairs with no happens-before relationship)
+7. Report detected races with thread IDs and source locations
+
+---
+
+## Project Structure
+
+```
+threadcheck/
+├── pyproject.toml
+├── src/
+│   └── threadcheck/
+│       ├── __init__.py
+│       ├── __main__.py
+│       ├── _version.py          # single version source
+│       ├── cli.py               # argument parsing + dispatch
+│       ├── static/
+│       │   ├── analyzer.py      # static analysis entry point
+│       │   ├── visitors.py      # AST visitors (global, nonlocal, class attr, shared mutable)
+│       │   ├── lock_tracker.py  # lock usage analysis
+│       │   └── models.py        # RaceWarning, Severity, Confidence models
+│       ├── dynamic/
+│       │   ├── __main__.py      # run_script entry point
+│       │   ├── transform.py     # AST transformation engine
+│       │   ├── tracker.py       # runtime tracker with vector clocks
+│       │   ├── clock.py         # vector clock implementation
+│       │   └── hook.py          # sys.meta_path import hook
+│       ├── reporting/
+│       │   ├── formatter.py     # terminal output formatting
+│       │   └── types.py         # type re-exports
+│       └── pytest_plugin.py     # pytest integration (planned)
+├── tests/
+│   ├── fixtures/                # sample code with known races
+│   ├── test_static_analyzer.py
+│   └── test_dynamic_detector.py
+└── README.md / README_CN.md
+```
+
+---
+
+## Roadmap
+
+| Phase | Feature | Status |
+|---|---|---|
+| 1 | CLI, static analysis (globals/nonlocals) | Done |
+| 2 | Class attributes, lock suppression, confidence scoring | Done |
+| 3 | AST import hook, runtime instrumentation, vector clocks | Done |
+| 4 | Race report deduplication, enhanced happens-before analysis | Planned |
+| 5 | SARIF output, JSON reporting | Planned |
+| 6 | pytest plugin | Planned |
+| 7 | Free-threading compatibility checker | Planned |
+
+---
+
+## Limitations
+
+- Static analysis may produce false positives (reports race that cannot occur at runtime) and false negatives (misses races that involve indirect sharing through aliases or containers)
+- Runtime detection modifies the AST before execution; code that introspects its own source or frame objects may behave differently
+- Runtime instrumentation incurs overhead (approximately 2-5x slowdown for typical code)
+- Lock tracking supports `threading.Lock`, `threading.RLock`, and standard `with`-based patterns; other synchronization primitives (`threading.Event`, `threading.Condition`, third-party libraries) are not tracked
+
+---
+
+## License
+
+MIT
+
+---
+
+## Contributing
+
+Contributions are welcome. Please open an issue or submit a pull request on GitHub.

threadcheck-0.0.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+threadcheck/__init__.py,sha256=ySY4Q9AN1WXp1sDMrOd0SotrC1PwTNqBeDTt55wa8Z4,374
+threadcheck/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+threadcheck/_version.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+threadcheck/cli.py,sha256=RzbJWXtvjGBfZkdlxGIxYYA9DqajCEWnpQHFwGP6S8g,2834
+threadcheck/pytest_plugin.py,sha256=5AvZWl_CR7sZAmvcG8QqG7za50nn87GSKkCALnpvyjc,1918
+threadcheck/dynamic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+threadcheck/dynamic/__main__.py,sha256=9_Q8impnDtwP2SfvYCPCgTS0kmw1UQZhPCsDU42gI3I,962
+threadcheck/dynamic/clock.py,sha256=1zbHTHNFgwxCvP9yYA25UwFgCUnydkNOzcH1ogEisfY,907
+threadcheck/dynamic/hook.py,sha256=fg_OR4p9rlCs5ES09VPteq9riss-avd-PR1uMZEsxZk,3032
+threadcheck/dynamic/tracker.py,sha256=Ty8Fm2zWQxU8PP2MLb8tzhyExy40aNQdjgX29Vu5oEM,6215
+threadcheck/dynamic/transform.py,sha256=_ldNaih-q4U0OJcxBH11LwIKcT-AVKB3zI9JcxBr-zs,6556
+threadcheck/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+threadcheck/reporting/formatter.py,sha256=OZUdeOfcMq54J4b9jFQBhXgD_KSjVYsLCY9EGDu1Q_o,865
+threadcheck/reporting/sarif.py,sha256=cXih48-HhUXfIFcfG5GVa7xBiPVvidvLfnpMESCVR1o,3572
+threadcheck/reporting/types.py,sha256=KG8lwBtpGIEfi5YYb2xp-uHWxxXR71SwDWKWxnIeqq0,97
+threadcheck/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+threadcheck/static/analyzer.py,sha256=MvQDdGwAV_c8Gc4ms1R7sCrjA38jPcvU2Rf5SvJgaiA,3087
+threadcheck/static/lock_tracker.py,sha256=NbuR5zWKZ7jTdT2KRV06Sq1xPNCqeuvjnCnorQAIPUE,1476
+threadcheck/static/models.py,sha256=iUaQjvrfoocqBHf7nTAa493EZFr0RDxGcqb4g5xeOeo,1113
+threadcheck/static/visitors.py,sha256=yJCxZ_7K8c9DzDnQL4H1U85ViUAPhfZIujlkU1P3zf4,12538
+threadcheck-0.0.1.dist-info/METADATA,sha256=IrMM0wHwuvMjwBdOt7fHDLfIlhWtGM_LtZ7Vrs_bULM,8504
+threadcheck-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+threadcheck-0.0.1.dist-info/entry_points.txt,sha256=ZmGa6T6j2vSEq5-vjMGtunc55yiQDRGuyZG0W9PJDSU,105
+threadcheck-0.0.1.dist-info/licenses/LICENSE,sha256=wqDapPVwjdlXZPEEEoRLLST4Pw4vKcoFCjTPXW-VeXE,1062
+threadcheck-0.0.1.dist-info/RECORD,,

threadcheck-0.0.1.dist-info/WHEEL

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

threadcheck-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+threadcheck = threadcheck.cli:main
+
+[pytest11]
+threadcheck = threadcheck.pytest_plugin

threadcheck-0.0.1.dist-info/licenses/LICENSE

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