hank-format 0.1.0__py3-none-any.whl

hank_format/__init__.py

@@ -0,0 +1,42 @@
+"""Shared string formatting functions for standardizing values across the Hank AI stack.
+
+Example:
+    >>> from hank_format import as_name, as_date_str, as_datetime_str, as_time_str
+    >>> as_name("Primary: John Doe")
+    'DOE, JOHN'
+    >>> as_date_str("12/31/2020 (age 30 yrs)")
+    '2020-12-31'
+    >>> as_datetime_str("2020-12-31T23:59", precision="minute")
+    '2020-12-31 23:59'
+    >>> as_time_str("11:30 pm")
+    '23:30'
+"""
+
+__version__ = "0.1.0"
+
+from ._datetime import (
+    Precision,
+    as_date,
+    as_date_str,
+    as_datetime,
+    as_datetime_str,
+    as_time,
+    as_time_str,
+    has_time,
+    is_date,
+)
+from ._name import as_name
+
+__all__ = [
+    "Precision",
+    "__version__",
+    "as_date",
+    "as_date_str",
+    "as_datetime",
+    "as_datetime_str",
+    "as_name",
+    "as_time",
+    "as_time_str",
+    "has_time",
+    "is_date",
+]

hank_format/_datetime.py

@@ -0,0 +1,329 @@
+"""Date, time, and datetime parsing and formatting.
+
+Public functions accept loosely formatted strings (anything ``dateutil``
+understands plus a few medical-record idioms), ``date``, ``datetime``, and
+``time`` objects, and ``None``. Object-returning functions return ``None`` when
+no usable value exists; string-returning functions return ``""``. Returned
+values never carry timezone info or microseconds.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import date, datetime, time
+from typing import Literal, TypeAlias
+
+from dateutil import parser
+from dateutil.relativedelta import relativedelta
+
+logger = logging.getLogger(__name__)
+
+Precision: TypeAlias = Literal["minute", "second"]
+"""Smallest unit kept in a formatted time string. Values are truncated, never rounded."""
+
+_SHORT_DATETIME_REGEX = re.compile(
+    r"^(?P<month>\d?\d)(?P<sep>/|-)(?P<day>\d?\d)(?P<time> \d?\d:?\d\d.*)$"
+)
+_TIMESPEC: dict[str, str] = {"minute": "minutes", "second": "seconds"}
+_FUTURE_WINDOW = relativedelta(days=2)
+_CENTURY = relativedelta(years=100)
+
+
+def _now() -> datetime:
+    """Current local time. Tests patch this to freeze the clock."""
+    return datetime.now()
+
+
+def _today() -> date:
+    return _now().date()
+
+
+def _timespec(precision: str) -> str:
+    try:
+        return _TIMESPEC[precision]
+    except KeyError:
+        raise ValueError(f"precision must be 'minute' or 'second', not {precision!r}") from None
+
+
+def _normalize(text: str) -> str:
+    """Rewrite strings ``dateutil`` cannot parse into an unambiguous form.
+
+    Drops a trailing parenthetical, rewrites bare ``MMDDYYYY`` to
+    ``MM-DD-YYYY`` (``dateutil`` reads 8 digits as ``YYYYMMDD``), and appends
+    the current year to a year-less ``MM/DD HH:MM`` (previous year when the
+    month/day would otherwise be in the future).
+
+    Example:
+        >>> _normalize("12/31/2020 (age 30 yrs)")
+        '12/31/2020'
+        >>> _normalize("01012024")
+        '01-01-2024'
+        >>> _normalize("20240101")
+        '20240101'
+        >>> _normalize("13012024")
+        '13012024'
+    """
+    text = text.partition("(")[0].strip()
+    if (
+        len(text) == 8
+        and text.isdecimal()
+        and 1 <= int(text[:2]) <= 12
+        and int(text[4:6]) in (19, 20)
+    ):
+        return f"{text[:2]}-{text[2:4]}-{text[4:]}"
+
+    def _append_year(match: re.Match[str]) -> str:
+        today = _today()
+        month, day = int(match["month"]), int(match["day"])
+        year = today.year - int((month, day) > (today.month, today.day))
+        return f"{month}{match['sep']}{day}{match['sep']}{year}{match['time']}"
+
+    return _SHORT_DATETIME_REGEX.sub(_append_year, text, 1)
+
+
+def _parse(text: str, default: datetime) -> datetime | None:
+    """``dateutil.parser.parse`` that ignores timezones and returns ``None`` on failure."""
+    try:
+        return parser.parse(text, ignoretz=True, default=default)
+    except (ValueError, OverflowError, TypeError) as err:
+        logger.debug("Could not parse %r: %s", text, err)
+        return None
+
+
+def _parses_consistently(
+    text: str, lower: datetime, upper: datetime, fields: tuple[str, ...]
+) -> bool:
+    """True if parsing ``text`` with two different defaults agrees on ``fields``.
+
+    A field that ``dateutil`` filled from the default differs between the two
+    parses, so agreement means the field was present in ``text``.
+    """
+    first, second = _parse(text, lower), _parse(text, upper)
+    if first is None or second is None:
+        return False
+    return all(getattr(first, f) == getattr(second, f) for f in fields)
+
+
+def is_date(value: str | date | datetime | None) -> bool:
+    """Return ``True`` if ``value`` carries year, month, and day information.
+
+    Example:
+        >>> is_date("12/31/2020")
+        True
+        >>> is_date("12/31/2020 (age 30 yrs)")
+        True
+        >>> is_date("23:59")
+        False
+        >>> is_date("not a date")
+        False
+        >>> is_date(None)
+        False
+    """
+    if value is None:
+        return False
+    if isinstance(value, date):
+        return True
+    if not isinstance(value, str):
+        raise TypeError(f"Expected str, date, datetime, or None, not {type(value).__name__}")
+    text = _normalize(value)
+    if len(text) < 7:
+        year = _today().year
+        lower, upper = datetime(year, 1, 1), datetime(year, 12, 31)
+    else:
+        lower, upper = datetime.min, datetime.max
+    return _parses_consistently(text, lower, upper, ("year", "month", "day"))
+
+
+def has_time(value: str | date | datetime | time | None) -> bool:
+    """Return ``True`` if ``value`` carries hour and minute information.
+
+    Example:
+        >>> has_time("2020-12-31T23:59")
+        True
+        >>> has_time("23:59")
+        True
+        >>> has_time("2020-12-31")
+        False
+        >>> has_time(None)
+        False
+    """
+    if value is None:
+        return False
+    if isinstance(value, (datetime, time)):
+        return True
+    if isinstance(value, date):
+        return False
+    if not isinstance(value, str):
+        raise TypeError(f"Expected str, date, datetime, time, or None, not {type(value).__name__}")
+    text = _normalize(value)
+    date_only = as_date_str(text)
+    if date_only and date_only == text:
+        return False
+    if ("T" not in text and " " not in text) or (not date_only and len(text) < 11):
+        text = f"1/1/1999 {text}"
+    year = _today().year
+    lower, upper = datetime(year, 1, 1, 0, 0), datetime(year, 1, 1, 23, 59)
+    return _parses_consistently(text, lower, upper, ("hour", "minute"))
+
+
+def _core_datetime(
+    value: str | date | datetime | time | None,
+    default_date: str | date | datetime | None,
+) -> datetime | None:
+    """Single conversion path shared by every public date/time function.
+
+    ``default_date`` supplies the calendar day for inputs that carry only a
+    time. Inputs that carry a date ignore it.
+    """
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.replace(microsecond=0, tzinfo=None)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day)
+    if isinstance(value, time):
+        day = as_date(default_date)
+        if day is None:
+            return None
+        return datetime.combine(day, value.replace(microsecond=0, tzinfo=None))
+    if not isinstance(value, str):
+        raise TypeError(f"Expected str, date, datetime, time, or None, not {type(value).__name__}")
+    text = _normalize(value)
+    if is_date(text):
+        parsed = _parse(text, datetime.combine(_today(), time()))
+        if parsed is not None and parsed > _now() + _FUTURE_WINDOW:
+            parsed -= _CENTURY
+        return None if parsed is None else parsed.replace(microsecond=0)
+    day = as_date(default_date)
+    if day is None or not has_time(text):
+        return None
+    parsed = _parse(f"{day.isoformat()} {text}", datetime.combine(day, time()))
+    return None if parsed is None else parsed.replace(microsecond=0)
+
+
+def as_date(value: str | date | datetime | None) -> date | None:
+    """Return the calendar date in ``value``, or ``None`` if it has none.
+
+    Any parsed date more than two days in the future rolls back one century
+    (a two-digit-year heuristic that also hits four-digit years), so
+    ``12/31/45`` is 1945, not 2045.
+
+    Example:
+        >>> as_date("2020-12-31T23:59")
+        datetime.date(2020, 12, 31)
+        >>> as_date("12/31/2020 (age 30 yrs)")
+        datetime.date(2020, 12, 31)
+        >>> as_date("01012024")
+        datetime.date(2024, 1, 1)
+        >>> as_date("23:59") is None
+        True
+        >>> as_date("not a date") is None
+        True
+    """
+    result = _core_datetime(value, None)
+    return None if result is None else result.date()
+
+
+def as_date_str(value: str | date | datetime | None) -> str:
+    """Return the date in ``value`` as ``YYYY-MM-DD``, or ``""`` if it has none.
+
+    Example:
+        >>> as_date_str("12/31/2020 11:30 pm")
+        '2020-12-31'
+        >>> as_date_str("not a date")
+        ''
+    """
+    result = as_date(value)
+    return "" if result is None else result.isoformat()
+
+
+def as_datetime(
+    value: str | date | datetime | time | None,
+    *,
+    default_date: str | date | datetime | None = None,
+) -> datetime | None:
+    """Return ``value`` as a naive ``datetime`` without microseconds, or ``None``.
+
+    A date without a time becomes midnight. A time without a date uses
+    ``default_date`` when given and is ``None`` otherwise.
+
+    Example:
+        >>> as_datetime("2020-12-31T23:59")
+        datetime.datetime(2020, 12, 31, 23, 59)
+        >>> as_datetime("2020-12-31")
+        datetime.datetime(2020, 12, 31, 0, 0)
+        >>> as_datetime("23:59") is None
+        True
+        >>> as_datetime("23:59", default_date="2020-12-31")
+        datetime.datetime(2020, 12, 31, 23, 59)
+    """
+    return _core_datetime(value, default_date)
+
+
+def as_datetime_str(
+    value: str | date | datetime | time | None,
+    *,
+    precision: Precision = "second",
+    default_date: str | date | datetime | None = None,
+) -> str:
+    """Return ``value`` as ``YYYY-MM-DD HH:MM:SS`` (or ``HH:MM`` with ``precision="minute"``).
+
+    Returns ``""`` when :func:`as_datetime` would return ``None``. Precision
+    truncates; it never rounds.
+
+    Example:
+        >>> as_datetime_str("2020-12-31T23:59")
+        '2020-12-31 23:59:00'
+        >>> as_datetime_str("2020-12-31 23:59:45", precision="minute")
+        '2020-12-31 23:59'
+        >>> as_datetime_str("23:59")
+        ''
+        >>> as_datetime_str("23:59", precision="minute", default_date="2020-12-31")
+        '2020-12-31 23:59'
+    """
+    timespec = _timespec(precision)
+    result = as_datetime(value, default_date=default_date)
+    return "" if result is None else result.isoformat(" ", timespec)
+
+
+def as_time(value: str | date | datetime | time | None) -> time | None:
+    """Return the clock time in ``value`` without microseconds, or ``None`` if it has none.
+
+    Example:
+        >>> as_time("2020-12-31T23:59:30")
+        datetime.time(23, 59, 30)
+        >>> as_time("11:30 pm")
+        datetime.time(23, 30)
+        >>> as_time("2020-12-31") is None
+        True
+    """
+    if not has_time(value):
+        return None
+    result = _core_datetime(value, _today())
+    return None if result is None else result.time()
+
+
+def as_time_str(
+    value: str | date | datetime | time | None,
+    *,
+    precision: Precision = "minute",
+) -> str:
+    """Return the clock time in ``value`` as ``HH:MM`` (or ``HH:MM:SS`` with ``precision="second"``).
+
+    Returns ``""`` when :func:`as_time` would return ``None``. Precision
+    truncates; it never rounds.
+
+    Example:
+        >>> as_time_str("2020-12-31T23:59:30")
+        '23:59'
+        >>> as_time_str("2020-12-31T23:59:30", precision="second")
+        '23:59:30'
+        >>> as_time_str("7:05 AM")
+        '07:05'
+        >>> as_time_str("2020-12-31")
+        ''
+    """
+    timespec = _timespec(precision)
+    result = as_time(value)
+    return "" if result is None else result.isoformat(timespec)

hank_format/_name.py

@@ -0,0 +1,80 @@
+"""Person-name formatting built on ``nameparser``."""
+
+from __future__ import annotations
+
+import re
+
+from nameparser import HumanName
+from nameparser.config import Constants
+
+_CONSTANTS = Constants()
+_CONSTANTS.string_format = "{last}, {first} {middle}, {suffix}"
+_CONSTANTS.suffix_acronyms.add("aprn", "aprn-crna", "apn", "-")
+_CONSTANTS.titles.remove("queen", "queen's", "king", "king's")
+
+_NOISE = re.compile(r"\[.*?\]|\(.*?\)|\*")
+_WHITESPACE = re.compile(r"\s+")
+_SPACE_BEFORE_TOKEN = re.compile(r"\s+(\S)")
+_REPEATED_COMMAS = re.compile(r",{2,}")
+
+
+def _cleanup(text: str) -> str:
+    """Normalize spacing and comma usage in a raw name string.
+
+    Turns a trailing ``CRED - CRED`` pair into ``CRED, CRED``, treats a period
+    after a leading surname as a comma (an OCR artifact), collapses
+    whitespace, removes spaces before commas, and collapses repeated commas.
+
+    Example:
+        >>> _cleanup("Steven Hardman, APRN - CRNA")
+        'Steven Hardman, APRN, CRNA'
+        >>> _cleanup("CZIEP. MATTHEW EDWIN MD")
+        'CZIEP, MATTHEW EDWIN MD'
+        >>> _cleanup("Doe ,,  John")
+        'Doe, John'
+    """
+    head, sep, tail = text.rpartition(",")
+    if sep and " - " in tail:
+        text = f"{head},{tail.replace(' - ', ', ')}"
+    tokens = _WHITESPACE.split(text)
+    if len(tokens) >= 3 and len(tokens[0]) >= 4 and tokens[0].endswith("."):
+        tokens[0] = f"{tokens[0][:-1]},"
+        text = " ".join(tokens)
+    text = _SPACE_BEFORE_TOKEN.sub(lambda m: ("" if "," in m[0] else " ") + m[1], text)
+    return _REPEATED_COMMAS.sub(",", text).strip()
+
+
+def as_name(value: str | None) -> str:
+    """Format a person's name as ``LAST, FIRST MIDDLE, SUFFIX`` in upper case.
+
+    Text before the last ``:`` (``Primary: John Doe``) and after the first
+    ``;`` is discarded, bracketed or parenthesized notes and asterisks are
+    removed, and over-collected trailing lines are dropped. Credential
+    suffixes are deduplicated and sorted with acronyms last.
+
+    Example:
+        >>> as_name("Primary: John Doe")
+        'DOE, JOHN'
+        >>> as_name("Steven Hardman, APRN - CRNA")
+        'HARDMAN, STEVEN, APRN, CRNA'
+        >>> as_name("Smith, John, PhD, MD")
+        'SMITH, JOHN, MD, PHD'
+        >>> as_name(None)
+        ''
+    """
+    if value is None:
+        return ""
+    if not isinstance(value, str):
+        raise TypeError(f"Expected str or None, not {type(value).__name__}")
+    text = _NOISE.sub("", value.rpartition(":")[-1]).strip()
+    while "\n" in text and len(text.split()) > 3:
+        text = text.rpartition("\n")[0]
+    if not text:
+        return ""
+    name = HumanName(_cleanup(text.split(";")[0]).strip(". "), constants=_CONSTANTS)
+    suffixes = {suffix.rstrip(" -") for suffix in name.suffix_list}
+    name.suffix = ", ".join(
+        sorted(suffixes, key=lambda s: (s.lower() in _CONSTANTS.suffix_acronyms, s.lower()))
+    ).strip("'\"")
+    formatted = name.full_name.upper().strip().replace(".", "").replace("''", "").replace('"', "")
+    return _cleanup(formatted.strip("-"))

hank_format-0.1.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: hank-format
+Version: 0.1.0
+Summary: Shared string formatting functions for standardizing values across the Hank AI stack.
+Author-email: Sam Hartzog <sam.hartzog@hank.ai>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: python-dateutil>=2.8,<3
+Requires-Dist: nameparser>=1.1,<2
+Project-URL: Home, https://github.com/hank-ai/hank-format
+Project-URL: Issues, https://github.com/hank-ai/hank-format/issues
+
+# hank-format
+
+Shared string formatting functions for standardizing names, dates, and times
+across the Hank AI stack.
+
+```bash
+pip install hank-format
+```
+
+## Usage
+
+```python
+from hank_format import as_name, as_date, as_date_str, as_datetime_str, as_time_str
+
+as_name("Primary: John Doe")                       # 'DOE, JOHN'
+as_name("Steven Hardman, APRN - CRNA")             # 'HARDMAN, STEVEN, APRN, CRNA'
+as_date("12/31/2020 (age 30 yrs)")                 # datetime.date(2020, 12, 31)
+as_date_str("01012024")                            # '2024-01-01'
+as_datetime_str("2020-12-31T23:59")                # '2020-12-31 23:59:00'
+as_datetime_str("23:59", precision="minute", default_date="2020-12-31")  # '2020-12-31 23:59'
+as_time_str("11:30 pm")                            # '23:30'
+```
+
+## API
+
+| Function | Returns | Notes |
+| --- | --- | --- |
+| `as_name(value)` | `str` | `LAST, FIRST MIDDLE, SUFFIX`, upper case. Strips `Label:` prefixes, `[notes]`, `(notes)`, `*`, and text after `;`. |
+| `is_date(value)` | `bool` | True when a year, month, and day are present. |
+| `has_time(value)` | `bool` | True when an hour and minute are present. |
+| `as_date(value)` | `date \| None` | Calendar date only. |
+| `as_date_str(value)` | `str` | `YYYY-MM-DD` or `""`. |
+| `as_datetime(value, *, default_date=None)` | `datetime \| None` | Midnight when no time is present. Time-only input needs `default_date`. |
+| `as_datetime_str(value, *, precision="second", default_date=None)` | `str` | `YYYY-MM-DD HH:MM:SS`, or `YYYY-MM-DD HH:MM` with `precision="minute"`. |
+| `as_time(value)` | `time \| None` | Clock time only. |
+| `as_time_str(value, *, precision="minute")` | `str` | `HH:MM`, or `HH:MM:SS` with `precision="second"`. |
+
+Conventions:
+
+- Inputs may be strings, `date`, `datetime`, `time`, or `None`. Other types raise `TypeError`.
+- Object variants return `None` and string variants return `""` when no usable value exists.
+- Returned values are timezone-naive and have no microseconds. `precision` truncates, never rounds.
+- Any parsed date more than two days in the future rolls back 100 years, including four-digit years and year-less `MM/DD` (`12/31/45` is 1945; `12/26` without a time is 1926 when today is 2026-10-08). This is a two-digit-year heuristic inherited from pdf-extractor; strip or validate far-future dates before calling if you need them intact.
+- Year-less `MM/DD HH:MM` strings take the current year, or the previous year if that would be in the future.
+
+## Migrating from pdf-extractor `utils`
+
+| Legacy | hank-format |
+| --- | --- |
+| `as_name(s)` | `as_name(s)` (lists and `vStr` handling stay in pdf-extractor) |
+| `as_date(v, date_only=True, as_dt=True)` | `as_date(v)` (returns `date`) |
+| `as_date(v, date_only=True)` | `as_date_str(v)` |
+| `as_date(v, as_dt=True)` | `as_datetime(v)` |
+| `as_date(v)` | `as_datetime_str(v)` |
+| `as_time(v, with_date=False)` | `as_time_str(v)` |
+| `as_time(v, strict=True)` | `as_datetime_str(v, precision="minute") if has_time(v) else ""` |
+| `as_time(v, default_date=d)` | `as_datetime_str(v, precision="minute", default_date=d) if has_time(v) else ""` |
+| `as_time(v)` | `as_datetime_str(v, precision="minute") if is_date(v) and has_time(v) else as_time_str(v)` |
+
+Legacy `as_time` returned `""` for anything without a time; the new datetime
+functions format a date-only value as midnight, hence the `has_time` guards.
+
+## Development
+
+Requires [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync                      # create .venv with Python 3.12 and the dev group
+uv run pytest                # tests with 100% coverage enforced
+uv run ruff check . && uv run ruff format --check .
+uv run pyright
+uv build                     # sdist + wheel into dist/
+```
+
+## Releasing
+
+1. Open a PR against `main` and add exactly one label: `release:patch`, `release:minor`, or `release:major`.
+2. On merge, the `Release` workflow bumps `__version__` in `hank_format/__init__.py`, runs the tests, builds, commits `Release vX.Y.Z`, tags it, and pushes. A separate `publish` job then uploads the built artifacts to PyPI.
+3. If only the `publish` job fails (for example, trusted publishing is not configured yet), fix the cause and re-run that failed job. Do not re-run the whole workflow: the version is already bumped and tagged, so a full re-run would bump it again.
+
+One-time setup:
+
+- On pypi.org, under the `hank-format` project (or as a pending publisher), add a trusted publisher with owner `hank-ai`, repository `hank-format`, workflow `release.yml`, environment `pypi`.
+- In the GitHub repo settings, create an environment named `pypi`.
+- The workflow pushes the version-bump commit to `main` with the default `GITHUB_TOKEN`. If `main` is protected, allow the token to bypass the rule or supply a PAT in a `RELEASE_TOKEN` secret and use it in the checkout step.
+

hank_format-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+hank_format/__init__.py,sha256=D5vhFT8Hfe4Nb-omYSaJNLaCkTNdrAN_YPYGLaq3i7w,859
+hank_format/_datetime.py,sha256=V03KRjoFdhSFK-u-BiILzL4Afp7KqgXwE45epZcdBWI,11049
+hank_format/_name.py,sha256=3v4irN7S_lGPJIHpoZYZ1Nrk1v3ECkmh_jEsVUEgN-s,3038
+hank_format/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hank_format-0.1.0.dist-info/licenses/LICENSE,sha256=ATf0xlSg-7xKu3m1GNH602Sfe91hV7CmM3z8ztWO3ro,1065
+hank_format-0.1.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+hank_format-0.1.0.dist-info/METADATA,sha256=8YVkTwli2MXQMpoarHCvhMwLadcQ5UIRxaBJEkWcKOY,5697
+hank_format-0.1.0.dist-info/RECORD,,

hank_format-0.1.0.dist-info/WHEEL

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

hank_format-0.1.0.dist-info/licenses/LICENSE

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