pytest-cmake 1.3.0__py3-none-any.whl

pytest_cmake/__main__.py

@@ -0,0 +1,29 @@
+import argparse
+from pathlib import Path
+import sys
+import sysconfig
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="pytest-cmake",
+        description="Utility commands for pytest-cmake packaging.",
+    )
+    parser.add_argument(
+        "--cmake_dir", "--cmake-dir",
+        action="store_true",
+        help="Print the CMake config directory path and exit.",
+    )
+    args = parser.parse_args(argv)
+
+    if args.cmake_dir:
+        data_root = Path(sysconfig.get_path("data"))
+        print(data_root / "share" / "Pytest" / "cmake")
+        return 0
+
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pytest_cmake-1.3.0.data/data/share/Pytest/cmake/FindPytest.cmake

@@ -0,0 +1,181 @@
+# Discover required Pytest target.
+#
+# This module defines the following imported targets:
+#     Pytest::Pytest
+#
+# It also exposes the 'pytest_discover_tests' function, which adds CTest
+# test for each Pytest test. The "BUNDLE_PYTHON_TESTS" environment variable
+# can be used to run all discovered tests together.
+#
+# Usage:
+#     find_package(Pytest)
+#     find_package(Pytest REQUIRED)
+#     find_package(Pytest 4.6.11 REQUIRED)
+#
+# Note:
+#     The Pytest_ROOT environment variable or CMake variable can be used to
+#     prepend a custom search path.
+#     (https://cmake.org/cmake/help/latest/policy/CMP0074.html)
+
+cmake_minimum_required(VERSION 3.20...4.2)
+
+include(FindPackageHandleStandardArgs)
+
+find_program(PYTEST_EXECUTABLE NAMES pytest)
+mark_as_advanced(PYTEST_EXECUTABLE)
+
+if(PYTEST_EXECUTABLE)
+    execute_process(
+        COMMAND "${PYTEST_EXECUTABLE}" --version
+        OUTPUT_VARIABLE _version
+        ERROR_VARIABLE _version
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    if (_version MATCHES "pytest (version )?([0-9]+\\.[0-9]+\\.[0-9]+)")
+        set(PYTEST_VERSION "${CMAKE_MATCH_2}")
+    endif()
+endif()
+
+find_package_handle_standard_args(
+    Pytest
+    REQUIRED_VARS
+        PYTEST_EXECUTABLE
+    VERSION_VAR
+        PYTEST_VERSION
+    HANDLE_COMPONENTS
+    HANDLE_VERSION_RANGE
+)
+
+if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
+    add_executable(Pytest::Pytest IMPORTED)
+    set_target_properties(Pytest::Pytest
+        PROPERTIES
+            IMPORTED_LOCATION "${PYTEST_EXECUTABLE}")
+
+    # Function to discover pytest tests and add them to CTest.
+    function(pytest_discover_tests NAME)
+        set(_BOOL_ARGS
+          STRIP_PARAM_BRACKETS
+          INCLUDE_FILE_PATH
+          BUNDLE_TESTS
+        )
+
+        set(_SINGLE_VALUE_ARGS
+          WORKING_DIRECTORY
+          TRIM_FROM_NAME
+          TRIM_FROM_FULL_NAME
+        )
+
+        set(_MULTI_VALUE_ARGS
+          TEST_PATHS
+          LIBRARY_PATH_PREPEND
+          PYTHON_PATH_PREPEND
+          ENVIRONMENT
+          PROPERTIES
+          DEPENDS
+          EXTRA_ARGS
+          DISCOVERY_EXTRA_ARGS
+        )
+
+        cmake_parse_arguments(
+            PARSE_ARGV 1 ""
+            "${_BOOL_ARGS}"
+            "${_SINGLE_VALUE_ARGS}"
+            "${_MULTI_VALUE_ARGS}"
+        )
+
+        # Set platform-specific library path environment variable.
+        if (CMAKE_SYSTEM_NAME STREQUAL Windows)
+            set(LIBRARY_ENV_NAME PATH)
+        elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
+            set(LIBRARY_ENV_NAME DYLD_LIBRARY_PATH)
+        else()
+            set(LIBRARY_ENV_NAME LD_LIBRARY_PATH)
+        endif()
+
+        # Convert paths to CMake-friendly format.
+        if(DEFINED ENV{${LIBRARY_ENV_NAME}})
+            cmake_path(CONVERT "$ENV{${LIBRARY_ENV_NAME}}" TO_CMAKE_PATH_LIST LIBRARY_PATH)
+        else()
+            set(LIBRARY_PATH "")
+        endif()
+        if(DEFINED ENV{PYTHONPATH})
+            cmake_path(CONVERT "$ENV{PYTHONPATH}" TO_CMAKE_PATH_LIST PYTHON_PATH)
+        else()
+            set(PYTHON_PATH "")
+        endif()
+
+        # Prepend specified paths to the library and Python paths.
+        if (_LIBRARY_PATH_PREPEND)
+            list(REVERSE _LIBRARY_PATH_PREPEND)
+            foreach (_path ${_LIBRARY_PATH_PREPEND})
+                set(LIBRARY_PATH "${_path}" "${LIBRARY_PATH}")
+            endforeach()
+        endif()
+
+        if (_PYTHON_PATH_PREPEND)
+            list(REVERSE _PYTHON_PATH_PREPEND)
+            foreach (_path ${_PYTHON_PATH_PREPEND})
+                set(PYTHON_PATH "${_path}" "${PYTHON_PATH}")
+            endforeach()
+        endif()
+
+        # Set default working directory if none is specified.
+        if (NOT _WORKING_DIRECTORY)
+            set(_WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+        endif()
+
+        get_filename_component(_WORKING_DIRECTORY "${_WORKING_DIRECTORY}" REALPATH)
+
+        # Override option by environment variable if available.
+        if (DEFINED ENV{BUNDLE_PYTHON_TESTS})
+            set(_BUNDLE_TESTS $ENV{BUNDLE_PYTHON_TESTS})
+        endif()
+
+        # Define file paths for generated CMake include files.
+        set(_include_file "${CMAKE_CURRENT_BINARY_DIR}/${NAME}_include.cmake")
+        set(_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${NAME}_tests.cmake")
+
+        add_custom_command(
+            VERBATIM
+            OUTPUT "${_tests_file}"
+            DEPENDS ${_DEPENDS}
+            COMMAND ${CMAKE_COMMAND}
+            -D "PYTEST_EXECUTABLE=${PYTEST_EXECUTABLE}"
+            -D "TEST_PATHS=${_TEST_PATHS}"
+            -D "TEST_GROUP_NAME=${NAME}"
+            -D "BUNDLE_TESTS=${_BUNDLE_TESTS}"
+            -D "LIBRARY_ENV_NAME=${LIBRARY_ENV_NAME}"
+            -D "LIBRARY_PATH=${LIBRARY_PATH}"
+            -D "PYTHON_PATH=${PYTHON_PATH}"
+            -D "TRIM_FROM_NAME=${_TRIM_FROM_NAME}"
+            -D "TRIM_FROM_FULL_NAME=${_TRIM_FROM_FULL_NAME}"
+            -D "STRIP_PARAM_BRACKETS=${_STRIP_PARAM_BRACKETS}"
+            -D "INCLUDE_FILE_PATH=${_INCLUDE_FILE_PATH}"
+            -D "WORKING_DIRECTORY=${_WORKING_DIRECTORY}"
+            -D "ENVIRONMENT=${_ENVIRONMENT}"
+            -D "TEST_PROPERTIES=${_PROPERTIES}"
+            -D "CTEST_FILE=${_tests_file}"
+            -D "EXTRA_ARGS=${_EXTRA_ARGS}"
+            -D "DISCOVERY_EXTRA_ARGS=${_DISCOVERY_EXTRA_ARGS}"
+            -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/PytestAddTests.cmake")
+
+        # Create a custom target to run the tests.
+        add_custom_target(${NAME} ALL DEPENDS ${_tests_file})
+
+        file(WRITE "${_include_file}"
+            "if(EXISTS \"${_tests_file}\")\n"
+            "    include(\"${_tests_file}\")\n"
+            "else()\n"
+            "    add_test(${NAME}_NOT_BUILT ${NAME}_NOT_BUILT)\n"
+            "endif()\n"
+        )
+
+        # Register the include file to be processed for tests.
+        set_property(DIRECTORY
+            APPEND PROPERTY TEST_INCLUDE_FILES "${_include_file}")
+
+    endfunction()
+
+endif()

pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestAddTests.cmake

@@ -0,0 +1,174 @@
+# Wrapper used to create individual CTest tests from Pytest tests.
+cmake_minimum_required(VERSION 3.20...4.2)
+
+if(CMAKE_SCRIPT_MODE_FILE)
+
+    # Initialize content for the CMake test file.
+    set(_content "")
+
+    # Convert library and Python paths to native format.
+    cmake_path(CONVERT "${LIBRARY_PATH}" TO_NATIVE_PATH_LIST LIBRARY_PATH)
+    cmake_path(CONVERT "${PYTHON_PATH}" TO_NATIVE_PATH_LIST PYTHON_PATH)
+
+    # Serialize path values separated by semicolons (required on Windows).
+    string(REPLACE [[;]] [[\\;]] LIBRARY_PATH "${LIBRARY_PATH}")
+    string(REPLACE [[;]] [[\\;]] PYTHON_PATH "${PYTHON_PATH}")
+
+    # Set up the encoded environment with required paths.
+    set(ENCODED_ENVIRONMENT
+        "${LIBRARY_ENV_NAME}=${LIBRARY_PATH}"
+        "PYTHONPATH=${PYTHON_PATH}"
+    )
+
+    # Serialize additional environment variables if any are provided.
+    foreach(env ${ENVIRONMENT})
+        string(REPLACE [[;]] [[\\;]] env "${env}")
+        list(APPEND ENCODED_ENVIRONMENT "${env}")
+    endforeach()
+
+    # Handle EXTRA_ARGS for individual tests
+    if(BUNDLE_TESTS)
+        list(PREPEND EXTRA_ARGS ${DISCOVERY_EXTRA_ARGS})
+    endif()
+
+    set(EXTRA_ARGS_WRAPPED)
+    foreach(arg IN LISTS EXTRA_ARGS)
+        list(APPEND EXTRA_ARGS_WRAPPED "[==[${arg}]==]")
+    endforeach()
+    list(JOIN EXTRA_ARGS_WRAPPED " " EXTRA_ARGS_STR)
+
+    # Macro to create individual tests with optional test properties.
+    macro(create_test NAME IDENTIFIERS)
+        string(APPEND _content "add_test([==[${NAME}]==] \"${PYTEST_EXECUTABLE}\"")
+
+        foreach(identifier ${IDENTIFIERS})
+            string(APPEND _content " [==[${identifier}]==]")
+        endforeach()
+
+        string(APPEND _content " ${EXTRA_ARGS_STR} )\n")
+
+        # Prepare the properties for the test, including the environment settings.
+        set(args "PROPERTIES ENVIRONMENT [==[${ENCODED_ENVIRONMENT}]==]")
+
+        # Add working directory
+        string(APPEND args " WORKING_DIRECTORY [==[${WORKING_DIRECTORY}]==]")
+
+        # Append any additional properties, escaping complex characters if necessary.
+        foreach(property ${TEST_PROPERTIES})
+            if(property MATCHES "[^-./:a-zA-Z0-9_]")
+                string(APPEND args " [==[${property}]==]")
+            else()
+                string(APPEND args " ${property}")
+            endif()
+        endforeach()
+
+        # Append the test properties to the content.
+        string(APPEND _content "set_tests_properties([==[${NAME}]==] ${args})\n")
+    endmacro()
+
+    # If tests are bundled together, create a single test group.
+    if (BUNDLE_TESTS)
+        create_test("\${TEST_GROUP_NAME}" "\${TEST_PATHS}")
+
+    else()
+        # Set environment variables for collecting tests.
+        set(ENV{${LIBRARY_ENV_NAME}} "${LIBRARY_PATH}")
+        set(ENV{PYTHONPATH} "${PYTHON_PATH}")
+        set(ENV{PYTHONWARNINGS} "ignore")
+
+        set(_command
+            "${PYTEST_EXECUTABLE}" --collect-only -q
+            "--rootdir=${WORKING_DIRECTORY}"
+            ${DISCOVERY_EXTRA_ARGS}
+        )
+
+        foreach(test_path IN LISTS TEST_PATHS)
+            list(APPEND _command "${test_path}")
+        endforeach()
+
+        # Collect tests.
+        execute_process(
+            COMMAND ${_command}
+            OUTPUT_VARIABLE _output_lines
+            ERROR_VARIABLE _output_lines
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            WORKING_DIRECTORY ${WORKING_DIRECTORY}
+        )
+
+        # Check for errors during test collection.
+        string(REGEX MATCH "(=+ ERRORS =+|ERROR:).*" _error "${_output_lines}")
+
+        if (_error)
+            message(${_error})
+            message(FATAL_ERROR "An error occurred during the collection of Python tests.")
+        endif()
+
+        # Convert the collected output into a list of lines.
+        string(REPLACE [[;]] [[\;]] _output_lines "${_output_lines}")
+        string(REPLACE "\n" ";" _output_lines "${_output_lines}")
+
+        # Regex pattern to identify pytest test identifiers.
+        set(test_pattern "([^:]+)\.py(::([^:]+))?::([^:]+)")
+
+        # Iterate through each line to identify and process tests.
+        foreach(line ${_output_lines})
+            string(REGEX MATCHALL ${test_pattern} matching "${line}")
+
+            # Skip lines that are not identified as tests.
+            if (NOT matching)
+                continue()
+            endif()
+
+            # Extract file, class, and function names from the test pattern.
+            set(_file ${CMAKE_MATCH_1})
+            set(_class ${CMAKE_MATCH_3})
+            set(_func ${CMAKE_MATCH_4})
+
+            # Optionally trim parts of the class or function name.
+            if (TRIM_FROM_NAME)
+                string(REGEX REPLACE "${TRIM_FROM_NAME}" "" _class "${_class}")
+                string(REGEX REPLACE "${TRIM_FROM_NAME}" "" _func "${_func}")
+            endif()
+
+            # Form the test name using class and function.
+            if (_class)
+                set(test_name "${_class}.${_func}")
+            else()
+                set(test_name "${_func}")
+            endif()
+
+            # Optionally strip parameter brackets from the test name.
+            if (STRIP_PARAM_BRACKETS)
+                string(REGEX REPLACE "\\[(.+)\\]$" ".\\1" test_name "${test_name}")
+            endif()
+
+            # Optionally include the file path in the test name.
+            if (INCLUDE_FILE_PATH)
+                cmake_path(CONVERT "${_file}" TO_CMAKE_PATH_LIST _file)
+                string(REGEX REPLACE "/" "." _file "${_file}")
+                set(test_name "${_file}.${test_name}")
+            endif()
+
+            # Optionally trim parts of the full test name.
+            if (TRIM_FROM_FULL_NAME)
+                string(REGEX REPLACE "${TRIM_FROM_FULL_NAME}" "" test_name "${test_name}")
+            endif()
+
+            # Prefix the test name with the test group name.
+            set(test_name "${TEST_GROUP_NAME}.${test_name}")
+            set(test_case "${line}")
+
+            # Create the test for CTest.
+            create_test("\${test_name}" "\${test_case}")
+        endforeach()
+
+        # Warn if no tests were discovered.
+        if(NOT _content)
+            message(WARNING "No Python tests have been discovered.")
+        endif()
+    endif()
+
+    # Write the generated test content to the specified CTest file.
+    file(WRITE ${CTEST_FILE} ${_content})
+
+endif()

pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestConfig.cmake

@@ -0,0 +1 @@
+include(${CMAKE_CURRENT_LIST_DIR}/FindPytest.cmake)

pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestConfigVersion.cmake

@@ -0,0 +1,2 @@
+set(PACKAGE_VERSION_COMPATIBLE TRUE)
+set(PACKAGE_VERSION_EXACT TRUE)

pytest_cmake-1.3.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: pytest-cmake
+Version: 1.3.0
+Summary: Provide CMake module for Pytest
+Project-URL: Documentation, https://python-cmake.github.io/pytest-cmake
+Project-URL: Repository, https://github.com/python-cmake/pytest-cmake
+Project-URL: Issues, https://github.com/python-cmake/pytest-cmake/issues
+Project-URL: Changelog, https://python-cmake.github.io/pytest-cmake/release/release_notes.html
+Author-email: Jeremy Retailleau <jeremy.retailleau@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2022 Jeremy Retailleau
+        
+        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.
+License-File: LICENSE
+Keywords: cmake,development,pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Build Tools
+Requires-Python: <4,>=3.7
+Requires-Dist: pytest<10,>=4
+Description-Content-Type: text/markdown
+
+# Pytest CMake
+
+[![PyPi version](https://img.shields.io/pypi/v/pytest-cmake.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.python.org/pypi/pytest-cmake)
+[![CMake](https://img.shields.io/badge/CMake-3.20...4.2-blue.svg?logo=CMake&logoColor=blue)](https://cmake.org)
+[![Test](https://github.com/python-cmake/pytest-cmake/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/python-cmake/pytest-cmake/actions/workflows/test.yml)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+This project provides convenient ways to use [Pytest](https://docs.pytest.org/)
+within a [CMake](https://cmake.org/) project. The package can be discovered from a specific range of
+versions on Linux, macOS or Windows using the
+[find_package](https://cmake.org/cmake/help/latest/command/find_package.html)
+function:
+
+```cmake
+find_package(Pytest 8.2.1 REQUIRED)
+```
+
+A ``pytest_discover_tests`` function is provided to simplify automatic
+testing for C++ projects with Python bindings. It can create CTest tests
+for each Python test collected within a controlled environment:
+
+```cmake
+pytest_discover_tests(
+    PythonTest
+    LIBRARY_PATH_PREPEND
+        $<TARGET_FILE_DIR:MyLibrary>
+    PYTHON_PATH_PREPEND
+        $<TARGET_FILE_DIR:MyLibrary>
+    TRIM_FROM_NAME "^test_"
+    DEPENDS MyLibrary
+)
+```
+
+Running the tests will display the status for each test collected as follows:
+
+```console
+    Start 1: PythonTest.greet_world
+1/4 Test #1: PythonTest.greet_world ...........   Passed    0.47 sec
+    Start 2: PythonTest.greet_john
+2/4 Test #2: PythonTest.greet_john ............   Passed    0.47 sec
+    Start 3: PythonTest.greet_julia
+3/4 Test #3: PythonTest.greet_julia ...........   Passed    0.47 sec
+    Start 4: PythonTest.greet_michael
+4/4 Test #4: PythonTest.greet_michael .........   Passed    0.54 sec
+```
+
+## Documentation
+
+Full documentation, including installation and setup guides, can be found at
+https://python-cmake.github.io/pytest-cmake/

pytest_cmake-1.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pytest_cmake/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_cmake/__main__.py,sha256=VvjZ0QSrkDeE5WcJQpDSvOa15PjvA1ljSXNr8clXiys,675
+pytest_cmake-1.3.0.data/data/share/Pytest/cmake/FindPytest.cmake,sha256=tHYL0K6FaEoY04A8x3lSeCNHT3rHYFuBY2e8Dm6sxQU,5898
+pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestAddTests.cmake,sha256=sSlJF_4CzqhSRbT_1kWaty8SaValWsEQ4rbpoe9QsRs,6337
+pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestConfig.cmake,sha256=mjY07j10zOr9ChuCWxaFcVddtZtUuCzgbsXNqkjXWV0,52
+pytest_cmake-1.3.0.data/data/share/Pytest/cmake/PytestConfigVersion.cmake,sha256=TRP8QeDuZBDb2XcQt6puOti7APCjC2rLsJQcAvPGUP0,69
+pytest_cmake-1.3.0.dist-info/METADATA,sha256=G-iou5qRWWZ1fz772-8gpverqsOz1o3T6D02K5Wzsls,4483
+pytest_cmake-1.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pytest_cmake-1.3.0.dist-info/entry_points.txt,sha256=5DF8oST81fUiAixoL9GQqrlj6I8yyiVwggL4R3RdxGc,60
+pytest_cmake-1.3.0.dist-info/licenses/LICENSE,sha256=T7t6Q9Wwnz_iCCF4eC1F6Ug1ouqNV4BlsenOE_6Rpdc,1073
+pytest_cmake-1.3.0.dist-info/RECORD,,

pytest_cmake-1.3.0.dist-info/WHEEL

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

pytest_cmake-1.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pytest-cmake = pytest_cmake.__main__:main

pytest_cmake-1.3.0.dist-info/licenses/LICENSE

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