datefind 0.1.0__py3-none-any.whl

datefind/__init__.py

@@ -0,0 +1,44 @@
+"""Datefind."""
+
+from collections.abc import Generator
+from typing import Literal
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from tzlocal import get_localzone
+
+from datefind.constants import FirstNumber
+from datefind.datefind import Date, DateFind
+
+
+def find_dates(
+    text: str, first: Literal["month", "day", "year"] = "month", tz: str = ""
+) -> Generator[Date, None, None]:
+    """Search text for dates and return them as Date objects.
+
+    Parse the input text to locate and extract dates in various formats. When ambiguous dates are encountered (e.g. 01/02/03), use the `first` parameter to determine the order of month/day/year. Convert all dates to the specified timezone.
+
+    Args:
+        text (str): The text to search for dates
+        first (Literal["month", "day", "year"]): The position of month/day/year when parsing ambiguous dates. Defaults to "month"
+        tz (str): The timezone name (e.g. "America/New_York") to localize dates. Uses system timezone if empty. Defaults to ""
+
+    Returns:
+        Generator[Date, None, None]: A generator yielding Date objects for each date found in the text
+
+    Raises:
+        ValueError: If an invalid first parameter or timezone is provided
+    """
+    try:
+        first_number = FirstNumber[first.upper()]
+    except KeyError as e:
+        msg = f"Invalid first number: {first}"
+        raise ValueError(msg) from e
+
+    try:
+        timezone = ZoneInfo(tz) if tz else get_localzone()
+    except ZoneInfoNotFoundError as e:
+        msg = f"Invalid timezone: {tz}"
+        raise ValueError(msg) from e
+
+    datefind = DateFind(text=text, tz=timezone, first_number=first_number)
+    return datefind.find_dates()

datefind/constants.py

@@ -0,0 +1,82 @@
+"""Constants for datefind."""
+
+from enum import Enum
+
+
+class FirstNumber(Enum):
+    """Enum for the first number to find in ambiguous dates."""
+
+    MONTH = "month"
+    DAY = "day"
+    YEAR = "year"
+
+
+class DayToNumber(Enum):
+    """Enum for the day to number."""
+
+    FIRST = 1
+    SECOND = 2
+    THIRD = 3
+    FOURTH = 4
+    FIFTH = 5
+    SIXTH = 6
+    SEVENTH = 7
+    EIGHTH = 8
+    NINTH = 9
+    TENTH = 10
+    ELEVENTH = 11
+    TWELFTH = 12
+    THIRTEENTH = 13
+    FOURTEENTH = 14
+    FIFTEENTH = 15
+    SIXTEENTH = 16
+    SEVENTEENTH = 17
+    EIGHTEENTH = 18
+    NINETEENTH = 19
+    TWENTIETH = 20
+    TWENTYFIRST = 21
+    TWENTYSECOND = 22
+    TWENTYTHIRD = 23
+    TWENTYFOURTH = 24
+    TWENTYFIFTH = 25
+    TWENTYSIXTH = 26
+    TWENTYSEVENTH = 27
+    TWENTYEIGHTH = 28
+    TWENTYNINTH = 29
+    THIRTIETH = 30
+    THIRTYFIRST = 31
+
+
+CENTURY = 20  # Used for years provided with two digits
+SEP_CHARS = r"/\:\-\,\.\s\_\+\@ "  # Define separator chars for reuse
+SEP_CHARS_REGEX = rf"[{SEP_CHARS}]*?"
+DD_FLEXIBLE = r"[12][0-9]|3[01]|0?[1-9]"
+DD = r"0[1-9]|[12][0-9]|3[01]"
+MM = r"0[1-9]|1[012]"
+MM_FLEXIBLE = r"1[012]|0?[1-9]"
+YYYY = r"19\d\d|20\d\d"
+YYYY_FLEXIBLE = rf"{YYYY}|\d\d"
+JANUARY = r"january|jan?"
+FEBRUARY = r"february|feb?"
+MARCH = r"march|mar?"
+APRIL = r"april|apr?"
+MAY = r"may"
+JUNE = r"june?"
+JULY = r"july?"
+AUGUST = r"august|aug?"
+SEPTEMBER = r"september|sept?"
+OCTOBER = r"october|oct?"
+NOVEMBER = r"november|nov?"
+DECEMBER = r"december|dec?"
+MONTH = rf"{JANUARY}|{FEBRUARY}|{MARCH}|{APRIL}|{MAY}|{JUNE}|{JULY}|{AUGUST}|{SEPTEMBER}|{OCTOBER}|{NOVEMBER}|{DECEMBER}"
+DAY_NUMBERS = rf"first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|eleventh|twelfth|thirteenth|fourteenth|fifteenth|sixteenth|seventeenth|eighteenth|nineteenth|twentieth|twenty{SEP_CHARS_REGEX}first|twenty{SEP_CHARS_REGEX}second|twenty{SEP_CHARS_REGEX}third|twenty{SEP_CHARS_REGEX}fourth|twenty{SEP_CHARS_REGEX}fifth|twenty{SEP_CHARS_REGEX}sixth|twenty{SEP_CHARS_REGEX}seventh|twenty{SEP_CHARS_REGEX}eighth|twenty{SEP_CHARS_REGEX}ninth|thirtieth|thirty{SEP_CHARS_REGEX}first"
+DIGIT_SUFFIXES = r"st|th|rd|nd"
+TODAY = r"today'?s?"
+YESTERDAY = r"yesterday'?s?"
+TOMORROW = r"tomorrow'?s?"
+LAST_WEEK = rf"last{SEP_CHARS_REGEX}week'?s?"
+NEXT_WEEK = rf"next{SEP_CHARS_REGEX}week'?s?"
+WEEKDAYS = (
+    r"monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tues?|wed|thu|thurs?|fri|sat|sun"
+)
+TIME_PERIOD = r"am|pm"

datefind/datefind.py

@@ -0,0 +1,192 @@
+"""Datefind is a Python library for finding dates in text."""
+
+from collections.abc import Generator
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
+
+import regex as re
+from rich.console import Console
+
+from datefind.utils import DatePatternFactory
+
+from .constants import (
+    APRIL,
+    AUGUST,
+    CENTURY,
+    DECEMBER,
+    FEBRUARY,
+    JANUARY,
+    JULY,
+    JUNE,
+    MARCH,
+    MAY,
+    NOVEMBER,
+    OCTOBER,
+    SEP_CHARS,
+    SEPTEMBER,
+    DayToNumber,
+    FirstNumber,
+)
+
+console = Console()
+
+
+@dataclass
+class Date:
+    """Store information about a date found in text.
+
+    Properties:
+        date (datetime): The parsed datetime object
+        text (str): The full text that was searched
+        match (str): The specific text that matched the date pattern
+        span (tuple[int, int]): The start and end positions of the match in the text
+    """
+
+    date: datetime
+    text: str
+    match: str
+    span: tuple[int, int]
+
+
+class DateFind:
+    """Find and parse dates within text using pattern matching.
+
+    Searches text for date patterns and returns Date objects containing the parsed datetime, original text, matched pattern, and location of the match.
+
+    Args:
+        text (str): The text to search for dates
+        tz (ZoneInfo): The timezone to use for the parsed dates
+        first_number (FirstNumber): Whether the first number in a date pattern represents the day or month
+    """
+
+    def __init__(
+        self,
+        text: str,
+        tz: ZoneInfo,
+        first_number: FirstNumber,
+    ):
+        self.text = text
+        self.tz = tz
+        self.first_number = first_number
+        self.base_date = datetime(datetime.now(self.tz).year, 1, 1, tzinfo=self.tz)
+        self.factory = DatePatternFactory(first_number=self.first_number)
+
+    def find_dates(self) -> Generator[Date, None, None]:
+        """Search the text for date patterns and parse them into Date objects.
+
+        Parse dates in various formats including relative dates like 'today', 'yesterday', 'next week' as well as explicit dates with day, month and year components. All dates are converted to datetime objects in the timezone specified during initialization.
+
+        Yields:
+            Generator[Date, None, None]: A sequence of Date objects containing the parsed datetime, original text, matched pattern, and location of the match.
+        """
+        regex = self.factory.make_regex()
+        matches = regex.finditer(self.text)
+
+        for match in matches:
+            if match.groupdict().get("today"):
+                as_dt = datetime.now(self.tz)
+
+            elif match.groupdict().get("yesterday"):
+                as_dt = datetime.now(self.tz) - timedelta(days=1)
+
+            elif match.groupdict().get("tomorrow"):
+                as_dt = datetime.now(self.tz) + timedelta(days=1)
+
+            elif match.groupdict().get("last_week"):
+                as_dt = datetime.now(self.tz) - timedelta(days=7)
+
+            elif match.groupdict().get("next_week"):
+                as_dt = datetime.now(self.tz) + timedelta(days=7)
+
+            else:
+                day = self._day_to_number(match=match) or 1
+                month = self._month_to_number(match=match) or datetime.now(self.tz).month
+                year = self._year_to_number(match=match) or datetime.now(self.tz).year
+
+                as_dt = datetime(year=int(year), month=month, day=day, tzinfo=self.tz)
+
+            date = Date(
+                date=as_dt,
+                text=self.text,
+                match=match.group(),
+                span=match.span(),
+            )
+            yield date
+
+    @staticmethod
+    def _year_to_number(match: re.Match) -> int:
+        """Parse a year string from a regex match into a numeric year.
+
+        Convert 2-digit years to 4-digit years by prepending the current century. For example, '23' becomes '2023'.
+
+        Args:
+            match (re.Match): The regex match containing year information in named groups
+
+        Returns:
+            int: The numeric year value
+        """
+        if year := match.groupdict().get("year"):
+            if len(year) == 2:  # noqa: PLR2004
+                return int(f"{CENTURY}{year}")
+            return int(year)
+
+        return None
+
+    @staticmethod
+    def _month_to_number(match: re.Match) -> int:
+        """Parse a month string from a regex match into a numeric month (1-12).
+
+        Convert both text month names (e.g. "January", "Feb") and numeric months from the regex match. Text matching is case-insensitive.
+
+        Args:
+            match (re.Match): The regex match containing month information in named groups
+
+        Returns:
+            int: The numeric month value (1-12)
+        """
+        month_patterns = {
+            JANUARY: 1,
+            FEBRUARY: 2,
+            MARCH: 3,
+            APRIL: 4,
+            MAY: 5,
+            JUNE: 6,
+            JULY: 7,
+            AUGUST: 8,
+            SEPTEMBER: 9,
+            OCTOBER: 10,
+            NOVEMBER: 11,
+            DECEMBER: 12,
+        }
+
+        if month_as_text := match.groupdict().get("month_as_text"):
+            for pattern, number in month_patterns.items():
+                if re.search(pattern, month_as_text, re.IGNORECASE):
+                    return number
+
+        if month := match.groupdict().get("month"):
+            return int(month)
+
+        return None
+
+    @staticmethod
+    def _day_to_number(match: re.Match) -> int | None:
+        """Parse a day string from a regex match into a numeric day of month.
+
+        Convert both text day representations (e.g. "1st", "2nd") and numeric days from the regex match.
+
+        Args:
+            match (re.Match): The regex match containing day information in named groups
+
+        Returns:
+            int | None: The numeric day value, or None if no day found
+        """
+        if day_as_text := match.groupdict().get("day_as_text"):
+            day_as_text = re.sub(rf"[{SEP_CHARS}]", "", day_as_text)
+            return DayToNumber[day_as_text.upper()].value
+
+        if day := match.groupdict().get("day"):
+            return int(day)
+
+        return None

datefind/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utilities for datefind."""
+
+from .date_factory import DatePatternFactory
+
+__all__ = ["DatePatternFactory"]

datefind/utils/date_factory.py

@@ -0,0 +1,163 @@
+"""Create regex patterns for matching dates in text.
+
+Contains pattern definitions and factory classes for building flexible date-matching regular expressions that handle various date formats and styles.
+"""
+
+from typing import assert_never
+
+import regex as re
+
+from datefind.constants import (
+    DAY_NUMBERS,
+    DD,
+    DD_FLEXIBLE,
+    DIGIT_SUFFIXES,
+    LAST_WEEK,
+    MM,
+    MM_FLEXIBLE,
+    MONTH,
+    NEXT_WEEK,
+    SEP_CHARS,
+    TODAY,
+    TOMORROW,
+    YESTERDAY,
+    YYYY,
+    YYYY_FLEXIBLE,
+    FirstNumber,
+)
+
+DD = f"(?P<day>{DD})(?:{DIGIT_SUFFIXES})?"
+DD_AS_TEXT = f"(?P<day_as_text>{DAY_NUMBERS})"
+DD_FLEXIBLE = f"(?P<day>{DD_FLEXIBLE})(?:{DIGIT_SUFFIXES})?"
+END = rf"(?![0-9]|[{SEP_CHARS}][0-9])"
+LAST_WEEK = rf"(?P<last_week>{LAST_WEEK})"
+MM = rf"(?P<month>{MM})"
+MM_FLEXIBLE = rf"(?P<month>{MM_FLEXIBLE})"
+MONTH_AS_TEXT = f"(?P<month_as_text>{MONTH})"
+NEXT_WEEK = rf"(?P<next_week>{NEXT_WEEK})"
+SEPARATOR = rf"[{SEP_CHARS}]*?"
+MONTH_DAY_SEPARATOR = rf"{SEPARATOR}(?:the|of)?{SEPARATOR}"
+START = rf"(?<![0-9]|[0-9][{SEP_CHARS}])"
+TODAY = rf"(?P<today>{TODAY})"
+TOMORROW = rf"(?P<tomorrow>{TOMORROW})"
+YESTERDAY = rf"(?P<yesterday>{YESTERDAY})"
+YYYY = rf"(?P<year>{YYYY})"
+YYYY_FLEXIBLE = rf"(?P<year>{YYYY_FLEXIBLE})"
+
+ISO8601 = r"(?P<year>-?(\:[1-9][0-9]*)?[0-9]{4})\-(?P<month>1[0-2]|0[1-9])\-(?P<day>3[01]|0[1-9]|[12][0-9])T(?P<hour>2[0-3]|[01][0-9])\:(?P<minute>[0-5][0-9]):(?P<seconds>[0-5][0-9])(?:[\.,]+(?P<microseconds>[0-9]+))?(?P<offset>(?:Z|[+-](?:2[0-3]|[01][0-9])\:[0-5][0-9]))?"
+
+
+YYYY_MONTH_DD = rf"""
+    {START}
+    {YYYY}
+    {SEPARATOR}
+    {MONTH_AS_TEXT}
+    {SEPARATOR}
+    ({DD_FLEXIBLE}|{DD_AS_TEXT})
+    {END}
+"""
+DD_MONTH_YYYY = rf"""
+    {START}
+    ({DD_FLEXIBLE}|{DD_AS_TEXT})
+    {MONTH_DAY_SEPARATOR}
+    {MONTH_AS_TEXT}
+    {SEPARATOR}
+    {YYYY}
+    {END}
+"""
+MONTH_DD_YYYY = rf"""
+    {START}
+    {MONTH_AS_TEXT}
+    {MONTH_DAY_SEPARATOR}
+    ({DD_FLEXIBLE}|{DD_AS_TEXT})
+    {SEPARATOR}
+    {YYYY}
+    {END}
+"""
+YYYY_MONTH = rf"""
+    {START}
+    {YYYY}
+    {SEPARATOR}
+    {MONTH_AS_TEXT}
+    {END}
+"""
+MONTH_DD = rf"""
+    {START}
+    {MONTH_AS_TEXT}
+    {SEPARATOR}
+    ({DD_FLEXIBLE}|{DD_AS_TEXT})
+    {END}
+"""
+MONTH_YYYY = rf"""
+    {START}
+    {MONTH_AS_TEXT}
+    {SEPARATOR}
+    {YYYY}
+    {END}
+"""
+NATURAL_DATE = rf"""
+    {START}
+    {TODAY}|{YESTERDAY}|{TOMORROW}|{LAST_WEEK}|{NEXT_WEEK}
+    {END}
+"""
+
+
+class DatePatternFactory:
+    """Factory for creating date patterns."""
+
+    def __init__(self, first_number: FirstNumber) -> None:
+        """Initialize the factory. Defaults to US date format with month first.
+
+        Args:
+            first_number (FirstNumber): The first number to use.
+        """
+        self.first_number = first_number
+
+    @staticmethod
+    def _make_pattern(order: list[str]) -> str:
+        """Create a regex pattern by joining date components in the specified order.
+
+        Combine date pattern components (year, month, day) with separators to form a complete regex pattern. The components are joined in the order specified, with each component separated by the SEPARATOR pattern except for the last one.
+
+        Args:
+            order (list[str]): List of date pattern components in the desired order (e.g. [YYYY, MM, DD])
+
+        Returns:
+            str: A raw formatted string containing the complete regex pattern with start/end markers
+        """
+        pattern = f"{START}"
+        for part in order:
+            pattern += part
+            if part != order[-1]:
+                pattern += f"{SEPARATOR}"
+        pattern += f"{END}"
+        return rf"{pattern}"
+
+    def make_regex(self) -> re.Pattern:
+        """Create a compiled regular expression pattern for matching dates in text.
+
+        Generate a regex pattern that matches various date formats including natural language dates (today, tomorrow, etc) and numeric dates. The order of numeric components is determined by the first_number setting specified during initialization.
+
+        Returns:
+            re.Pattern: A compiled regex pattern with flags for case-insensitive and verbose matching
+        """
+        common_patterns = rf"{DD_MONTH_YYYY}|{MONTH_DD_YYYY}|{YYYY_MONTH_DD}|{MONTH_DD}|{YYYY_MONTH}|{MONTH_YYYY}|{NATURAL_DATE}"
+
+        # Set patterns that rely on the first_number flag.
+        match self.first_number:
+            case FirstNumber.MONTH:
+                yyyy_xx_xx = self._make_pattern([YYYY, MM_FLEXIBLE, DD_FLEXIBLE])
+                xx_xx_xx = self._make_pattern([MM_FLEXIBLE, DD_FLEXIBLE, YYYY_FLEXIBLE])
+            case FirstNumber.DAY:
+                yyyy_xx_xx = self._make_pattern([YYYY, DD_FLEXIBLE, MM_FLEXIBLE])
+                xx_xx_xx = self._make_pattern([DD_FLEXIBLE, MM_FLEXIBLE, YYYY_FLEXIBLE])
+            case FirstNumber.YEAR:
+                yyyy_xx_xx = self._make_pattern([YYYY, MM_FLEXIBLE, DD_FLEXIBLE])
+                xx_xx_xx = self._make_pattern([YYYY_FLEXIBLE, MM_FLEXIBLE, DD_FLEXIBLE])
+            case _:  # pragma: no cover
+                assert_never(self.first_number)
+
+        return re.compile(
+            f"{common_patterns}|{yyyy_xx_xx}|{xx_xx_xx}",
+            re.IGNORECASE | re.VERBOSE | re.MULTILINE | re.UNICODE | re.DOTALL,
+        )

datefind-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: datefind
+Version: 0.1.0
+Summary: A python module for locating dates within text.
+Project-URL: Homepage, https://github.com/natelandau/datefind
+Project-URL: Repository, https://github.com/natelandau/datefind
+Author-email: Nate Landau <github@natenate.org>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <=3.13,>=3.11
+Requires-Dist: regex>=2024.11.6
+Requires-Dist: tzlocal>=5.3.1
+Description-Content-Type: text/markdown
+
+[![Tests](https://github.com/natelandau/datefind/actions/workflows/test.yml/badge.svg)](https://github.com/natelandau/datefind/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/natelandau/datefind/graph/badge.svg?token=CXstf6zblD)](https://codecov.io/gh/natelandau/datefind)
+
+# datefind
+
+A python module for locating dates within text. Use this package to search for dates and convert them to datetime objects.
+
+Finds dates in many different formats.
+
+-   All numeric - `2024-01-01`, `01/01/2024`, `01012024`
+-   Natural language - `January 1st, 2024`, `March nineteenth, 2024`, `twenty fifth of January`
+-   Fuzzy dates - `today`, `yesterday`, `tomorrow`, `last week`, `next week`
+
+> [!NOTE]\
+> datefind is designed to be used with year, month, and day only. It does not support hours, minutes, seconds, or microseconds.
+
+## Installation
+
+Requires Python 3.11 or higher.
+
+```bash
+pip install datefind
+```
+
+## Usage
+
+```python
+from datefind import find_dates
+
+string = "2024-01-01 and 2024-01-02"
+
+for date in find_dates(string, tz="America/New_York"):
+    print(date)
+
+>>> Date(
+    date=datetime.datetime(2024, 1, 1, 0, 0, tzinfo=zoneinfo.ZoneInfo(key='America/New_York')),
+    text='2024-01-01 and 2024-01-02',
+    match='2024-01-01',
+    span=(0, 10)
+    )
+>>> Date(
+    date=datetime.datetime(2024, 1, 2, 0, 0, tzinfo=zoneinfo.ZoneInfo(key='America/New_York')),
+    text='2024-01-01 and 2024-01-02',
+    match='2024-01-02',
+    span=(15, 25)
+    )
+```
+
+### find_dates
+
+The `find_dates()` function is the main entry point for the datefind package. It takes a string of text and returns a generator of Date objects.
+
+**Arguments**
+
+-   `text` - The text to search for dates.
+-   `first` - The first number to find in ambiguous dates. (one of `month`, `day`, `year`) Default is `month`
+-   `tz` - The timezone to use. Defaults to the local timezone.
+
+For each date found, a Date object is returned. The Date object has the following properties:
+
+-   `date` - The datetime object.
+-   `text` - The full original text.
+-   `match` - The matched portion of the text.
+-   `span` - The span of the matched text in the original text.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more information.

datefind-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+datefind/__init__.py,sha256=GpoYC8sodoyz_k3waK_W1vgBfvijaYy-FbdUjyKQv8A,1684
+datefind/constants.py,sha256=052CtVYb-ZR8lfO4012wsR6VmjG2Ovq29GjSiJFiW2M,2419
+datefind/datefind.py,sha256=TzG0wu07aQ0Ott5jvjOjKSH2CcbuPgWQHhKilbRIc-A,6150
+datefind/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datefind/utils/__init__.py,sha256=XI246xDLK81gQ0mfL9XoUytPX-_XoHJfDgvoEPbex2Y,110
+datefind/utils/date_factory.py,sha256=mvLXt1PDV13nyWeZ3c2AxmAU-dAtGKU4cMTfBVwE6EY,5190
+datefind-0.1.0.dist-info/METADATA,sha256=iPQPi0hP_sl7_xKkP1W9wnkqDXfp_0ry3HRB8tuiOIg,2888
+datefind-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datefind-0.1.0.dist-info/licenses/LICENSE,sha256=Ur0dbtYXGPg840eCwDlk8pyTq7q16l6-LCK2xZDoU6s,1078
+datefind-0.1.0.dist-info/RECORD,,

datefind-0.1.0.dist-info/WHEEL

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

datefind-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Nate Landau
+
+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.