blitz-api-py 0.1.0__py3-none-any.whl

blitz_api/types/filters.py

@@ -0,0 +1,130 @@
+"""Typed request structures (``TypedDict``) for the search endpoints.
+
+These give call-site autocomplete and static checking for the nested filter
+objects accepted by ``search.people`` and ``search.companies``. Enum-constrained
+fields accept either an enum member (autocompleted, e.g. ``Industry.BANKING``) or
+a raw string, so power users are never blocked.
+
+All keys are optional unless noted; omit a filter to leave it unset.
+"""
+
+from __future__ import annotations
+
+from typing_extensions import NotRequired, TypedDict
+
+from .enums import (
+    CompanyType,
+    Continent,
+    EmployeeRange,
+    Industry,
+    JobFunction,
+    JobLevel,
+    SalesRegion,
+)
+
+# Each accepts an enum member (autocompleted) or a raw string, so callers are
+# never blocked by a value missing from the vendored taxonomy. Note: because the
+# enums subclass ``str``, ``Enum | str`` collapses to ``str`` for the type checker, so
+# the taxonomy is an autocomplete aid, not a statically enforced constraint — a typo'd
+# value is sent as-is and rejected (or ignored) by the API rather than caught by mypy.
+IndustryValue = Industry | str
+CompanyTypeValue = CompanyType | str
+EmployeeRangeValue = EmployeeRange | str
+ContinentValue = Continent | str
+SalesRegionValue = SalesRegion | str
+JobFunctionValue = JobFunction | str
+JobLevelValue = JobLevel | str
+
+
+class KeywordFilter(TypedDict, total=False):
+    """Free-text include/exclude keyword filter."""
+
+    include: list[str]
+    exclude: list[str]
+
+
+class IndustryFilter(TypedDict, total=False):
+    """Include/exclude filter over the fixed industry taxonomy."""
+
+    include: list[IndustryValue]
+    exclude: list[IndustryValue]
+
+
+class CompanyTypeFilter(TypedDict, total=False):
+    """Include/exclude filter over company types."""
+
+    include: list[CompanyTypeValue]
+    exclude: list[CompanyTypeValue]
+
+
+class RangeFilter(TypedDict, total=False):
+    """Numeric range filter. ``0`` means unset for most fields."""
+
+    min: float
+    max: float
+
+
+class CompanyHQFilter(TypedDict, total=False):
+    """Headquarters-location filter for company search."""
+
+    city: KeywordFilter
+    country_code: list[str]
+    continent: list[ContinentValue]
+    sales_region: list[SalesRegionValue]
+
+
+class CompanyFilter(TypedDict, total=False):
+    """Company search criteria, shared by ``search.companies`` and ``search.people``."""
+
+    linkedin_url: list[str]
+    name: KeywordFilter
+    industry: IndustryFilter
+    type: CompanyTypeFilter
+    employee_range: list[EmployeeRangeValue]
+    employee_count: RangeFilter
+    min_linkedin_followers: int
+    revenue: RangeFilter
+    naics_code: KeywordFilter
+    sic_code: KeywordFilter
+    web_traffic: RangeFilter
+    ad_spend: RangeFilter
+    keywords: KeywordFilter
+    founded_year: RangeFilter
+    hq: CompanyHQFilter
+
+
+class PeopleJobTitleFilter(TypedDict, total=False):
+    """Job-title filter. Wrap a value in ``[brackets]`` for an exact match."""
+
+    include_linkedin_headline: bool
+    include: list[str]
+    exclude: list[str]
+
+
+class PeopleLocationFilter(TypedDict, total=False):
+    """Location filter for the people side of a people search."""
+
+    city: list[str]
+    country_code: list[str]
+    continent: list[ContinentValue]
+    sales_region: list[SalesRegionValue]
+
+
+class PeopleFilter(TypedDict, total=False):
+    """People search criteria for ``search.people``."""
+
+    job_title: PeopleJobTitleFilter
+    job_function: list[JobFunctionValue]
+    job_level: list[JobLevelValue]
+    min_connections: int
+    location: PeopleLocationFilter
+    education: KeywordFilter
+
+
+class CascadeTier(TypedDict):
+    """One tier of a waterfall ICP cascade, tried in order until results are found."""
+
+    include_title: list[str]
+    location: list[str]
+    include_headline_search: bool
+    exclude_title: NotRequired[list[str]]

blitz_api/types/search.py

@@ -0,0 +1,36 @@
+"""Response models for the Search resource.
+
+``search.people``/``search.companies`` return ``CursorPage[...]`` and
+``search.employee_finder`` returns ``PageNumberPage[...]`` (auto-paging page objects
+defined in :mod:`blitz_api._pagination_async` / ``_pagination_sync``), so those
+per-endpoint response models no longer live here. Only the non-paginated waterfall
+result does.
+"""
+
+from __future__ import annotations
+
+from ._models import BlitzModel
+from .shared import Person
+
+__all__ = [
+    "WaterfallIcpMatch",
+    "WaterfallIcpResponse",
+]
+
+
+class WaterfallIcpMatch(BlitzModel):
+    """A single match from a waterfall ICP search.
+
+    ``icp`` is the cascade tier that matched (1 = highest priority) and
+    ``ranking`` is the overall relevance within the company (1 = most relevant).
+    """
+
+    icp: int | None = None
+    ranking: int | None = None
+    person: Person | None = None
+
+
+class WaterfallIcpResponse(BlitzModel):
+    """Result of ``search.waterfall_icp``."""
+
+    results: list[WaterfallIcpMatch] = []

blitz_api/types/shared.py

@@ -0,0 +1,119 @@
+"""Response models shared across multiple Blitz API endpoints.
+
+These mirror the JSON the API returns. Field shapes vary slightly between
+endpoints (e.g. ``Experience.company_name`` is only populated by people search,
+``HQ.postcode``/``street`` only by company enrichment), so divergent fields are
+modeled as ``Optional`` on a single superset type rather than duplicated.
+"""
+
+from __future__ import annotations
+
+from ._models import BlitzModel
+
+__all__ = [
+    "Location",
+    "Experience",
+    "Education",
+    "Certification",
+    "Person",
+    "HQ",
+    "Company",
+]
+
+
+class Location(BlitzModel):
+    """A geographic location attached to a person or a job."""
+
+    city: str | None = None
+    state_code: str | None = None
+    country_code: str | None = None
+    continent: str | None = None
+
+
+class Experience(BlitzModel):
+    """A single role from a person's work history."""
+
+    job_title: str | None = None
+    # Populated by ``search.people``; absent from employee-finder / reverse lookups.
+    company_name: str | None = None
+    company_linkedin_url: str | None = None
+    company_linkedin_id: str | None = None
+    company_domain: str | None = None
+    job_description: str | None = None
+    job_start_date: str | None = None
+    job_end_date: str | None = None
+    job_is_current: bool | None = None
+    job_location: Location | None = None
+
+
+class Education(BlitzModel):
+    """A single education entry from a person's profile."""
+
+    school: str | None = None
+    degree: str | None = None
+    start_date: str | None = None
+    end_date: str | None = None
+
+
+class Certification(BlitzModel):
+    """A professional certification listed on a person's profile."""
+
+    authority: str | None = None
+    name: str | None = None
+    url: str | None = None
+
+
+class Person(BlitzModel):
+    """A person profile returned by search and reverse-enrichment endpoints."""
+
+    first_name: str | None = None
+    last_name: str | None = None
+    full_name: str | None = None
+    nickname: str | None = None
+    civility_title: str | None = None
+    headline: str | None = None
+    about_me: str | None = None
+    location: Location | None = None
+    linkedin_url: str | None = None
+    connections_count: int | None = None
+    profile_picture_url: str | None = None
+    experiences: list[Experience] = []
+    education: list[Education] = []
+    skills: list[str] = []
+    certifications: list[Certification] = []
+
+
+class HQ(BlitzModel):
+    """A company's headquarters location.
+
+    Company enrichment returns ``postcode`` and ``street`` in addition to the
+    fields company search returns; both are optional here.
+    """
+
+    city: str | None = None
+    state: str | None = None
+    postcode: str | None = None
+    country_code: str | None = None
+    country_name: str | None = None
+    region: str | None = None
+    continent: str | None = None
+    street: str | None = None
+
+
+class Company(BlitzModel):
+    """A company profile returned by company search and company enrichment."""
+
+    linkedin_url: str | None = None
+    linkedin_id: int | None = None
+    name: str | None = None
+    about: str | None = None
+    specialties: list[str] | None = None
+    industry: str | None = None
+    type: str | None = None
+    size: str | None = None
+    employees_on_linkedin: int | None = None
+    followers: int | None = None
+    founded_year: int | None = None
+    hq: HQ | None = None
+    domain: str | None = None
+    website: str | None = None

blitz_api/types/utils.py

@@ -0,0 +1,35 @@
+"""Response models for the Utilities resource."""
+
+from __future__ import annotations
+
+from ._models import BlitzModel
+
+__all__ = [
+    "CurrentDateResponse",
+    "EmploymentDistributionItem",
+    "CompanyEmploymentDistributionResponse",
+]
+
+
+class CurrentDateResponse(BlitzModel):
+    """Result of ``utils.current_date``."""
+
+    datetime: str | None = None
+    timestamp: int | None = None
+    timezone: str | None = None
+    timezone_name: str | None = None
+
+
+class EmploymentDistributionItem(BlitzModel):
+    """Employee count for a single country."""
+
+    country: str | None = None
+    count: int | None = None
+
+
+class CompanyEmploymentDistributionResponse(BlitzModel):
+    """Result of ``utils.company_employment_distribution``."""
+
+    company_linkedin_url: str | None = None
+    total_employees: int | None = None
+    distribution: list[EmploymentDistributionItem] = []

blitz_api_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: blitz-api-py
+Version: 0.1.0
+Summary: Typed Python SDK for the Blitz API — B2B data, search, and enrichment.
+Project-URL: Homepage, https://blitz-api.ai
+Project-URL: Documentation, https://docs.blitz-api.ai
+Project-URL: Repository, https://github.com/api-blitz/blitz-api-py
+Project-URL: Issues, https://github.com/api-blitz/blitz-api-py/issues
+Project-URL: Changelog, https://github.com/api-blitz/blitz-api-py/blob/main/CHANGELOG.md
+Author-email: Blitz API <founders@blitz-api.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: b2b,blitz,blitz-api,enrichment,gtm,linkedin,sales,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: pydantic<3,>=2.13
+Requires-Dist: typing-extensions>=4.10
+Description-Content-Type: text/markdown
+
+# blitz-api-py
+
+The typed Python SDK for the [Blitz API](https://blitz-api.ai) — B2B data, search,
+and enrichment.
+
+- **Fully typed** — Pydantic v2 response models with attribute access and IDE
+  autocomplete, `TypedDict` request filters, and a shipped `py.typed` marker so
+  mypy/pyright see the types in your own code.
+- **Sync & async** — `BlitzAPI` and `AsyncBlitzAPI` over `httpx`.
+- **Resilient** — built-in client-side rate limiting, retries with backoff on
+  `429`/`5xx`, and a typed exception hierarchy.
+- **Forward-compatible** — new fields the API adds never break deserialization.
+
+> Create and manage API keys at [app.blitz-api.ai](https://app.blitz-api.ai).
+
+## Installation
+
+```bash
+pip install blitz-api-py
+# or: uv add blitz-api-py
+```
+
+Requires Python 3.10+.
+
+## Quickstart
+
+```python
+from blitz_api import BlitzAPI
+from blitz_api.types import Industry, JobLevel
+
+# api_key defaults to the BLITZ_API_KEY environment variable.
+with BlitzAPI() as client:
+    # Health-check the key before a batch job.
+    info = client.account.key_info()
+    print(info.valid, info.remaining_credits, info.max_requests_per_seconds)
+
+    # LinkedIn profile URL -> verified work email.
+    email = client.enrichment.email(
+        person_linkedin_url="https://www.linkedin.com/in/example-person",
+    )
+    if email.found:
+        print(email.email)
+
+    # Search people with typed, autocompleted filters.
+    people = client.search.people(
+        company={"industry": {"include": [Industry.SOFTWARE_DEVELOPMENT]}},
+        people={"job_level": [JobLevel.VP]},
+        max_results=10,
+    )
+    for person in people.results:
+        print(person.full_name, person.headline)
+```
+
+### Async
+
+```python
+import asyncio
+from blitz_api import AsyncBlitzAPI
+
+async def main() -> None:
+    async with AsyncBlitzAPI() as client:
+        result = await client.enrichment.company(
+            company_linkedin_url="https://www.linkedin.com/company/openai",
+        )
+        print(result.company.name if result.company else None)
+
+asyncio.run(main())
+```
+
+## Authentication
+
+Pass the key explicitly or via the `BLITZ_API_KEY` environment variable:
+
+```python
+client = BlitzAPI(api_key="sk_...")          # explicit
+client = BlitzAPI()                           # reads BLITZ_API_KEY
+```
+
+The key is sent in the `x-api-key` header. Never expose it in client-side code —
+always call the API from your backend.
+
+## Endpoints
+
+All methods are grouped into four namespaces:
+
+| Namespace | Methods |
+| --- | --- |
+| `client.account` | `key_info()` |
+| `client.search` | `people()`, `companies()`, `employee_finder()`, `waterfall_icp()` |
+| `client.enrichment` | `email()`, `phone()`, `email_to_person()`, `phone_to_person()`, `company()`, `domain_to_linkedin()`, `linkedin_to_domain()` |
+| `client.utils` | `current_date()`, `company_employment_distribution()` |
+
+Every method returns a typed Pydantic model (see `blitz_api.types`). Enum-backed
+filter fields (e.g. `Industry`, `JobLevel`, `Continent`) accept either an enum
+member or a raw string.
+
+## Pagination
+
+The search methods return an **auto-paginating page**: iterate it and the SDK fetches
+each subsequent page for you. `search.people`/`search.companies` are cursor-based;
+`search.employee_finder` is page-based — both behave identically here.
+
+```python
+# Iterate every matching person across all pages — no cursor handling needed.
+for person in client.search.people(people={"job_level": ["VP"]}):
+    print(person.full_name)
+
+# Async works the same way.
+async for person in await async_client.search.people(people={"job_level": ["VP"]}):
+    ...
+
+# Bound how much you pull.
+for person in client.search.people(...).auto_paging_iter(max_items=200):
+    ...
+
+# Per-page control: inspect totals / cursors as you go.
+for page in client.search.companies(company={...}).iter_pages(max_pages=5):
+    print(page.total_results, len(page.results), page.cursor)
+
+# Or page manually.
+page = client.search.people(people={...}, max_results=50)
+print(page.results, page.cursor)
+nxt = page.get_next_page()        # None once exhausted
+```
+
+The page types (`CursorPage`, `PageNumberPage`, and their `Async*` variants) are
+exported from `blitz_api`.
+
+## Configuration
+
+```python
+client = BlitzAPI(
+    api_key=None,                 # falls back to BLITZ_API_KEY
+    base_url="https://api.blitz-api.ai",
+    timeout=30.0,                 # seconds, or an httpx.Timeout
+    max_retries=3,                # retries on 429 / 5xx / network errors
+    rate_limit_rps=5.0,           # client-side throttle; None to disable
+)
+```
+
+The client-side rate limiter is a sliding window — at most `rate_limit_rps` requests
+in any rolling second — so a single client instance stays under the API's limit (5 req/s
+by default; check your key's limit via
+`client.account.key_info().max_requests_per_seconds`). Across multiple processes you may
+still hit `429` — the retry path handles that.
+
+Every method also accepts a per-call `timeout` (seconds or an `httpx.Timeout`) when one
+endpoint needs longer than the client default:
+
+```python
+client.search.people(people={"job_level": ["VP"]}, timeout=10.0)
+```
+
+## Error handling
+
+```python
+from blitz_api import (
+    BlitzError, AuthenticationError, InsufficientCreditsError,
+    NotFoundError, RateLimitError, APIStatusError, APIConnectionError,
+    APITimeoutError, APIResponseValidationError,
+)
+
+try:
+    client.enrichment.email(person_linkedin_url="...")
+except InsufficientCreditsError:
+    ...                            # 402 — out of credits
+except AuthenticationError:
+    ...                            # 401 — bad key
+except APIStatusError as err:
+    print(err.status_code, err.message, err.body)
+except APIResponseValidationError:
+    ...                            # 2xx whose body wasn't valid / didn't match the model
+except BlitzError:
+    ...                            # base class for everything this SDK raises
+```
+
+`429` and `5xx` are retried automatically (with backoff) up to `max_retries`;
+`401`/`402`/`404` raise immediately. Connect timeouts and connection errors are retried,
+but a **read timeout is not** — the server may already have processed (and billed) the
+request, so it surfaces as `APITimeoutError` rather than risking a double charge.
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup, the test/type/lint
+commands, the enum code generator, and the automated release process.
+
+## License
+
+[MIT](LICENSE)

blitz_api_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+blitz_api/__init__.py,sha256=zkPoN9id23GMbR-r6d4e-twmwd1yL2zp92MOKJjdOUs,1546
+blitz_api/_base_client.py,sha256=SRkyPmxD8Tl4-N_3IRjmWB7S4AvTqLl2HBXkA4yB5TQ,7006
+blitz_api/_client.py,sha256=KvsDperoLthofE3T35atm7pzcAfr6FvaFqvOcR5kQCI,500
+blitz_api/_client_async.py,sha256=7xYjsjkmhiK7_j4IuWopvtpSklg2Xbpuo_8Rw3B80EY,5099
+blitz_api/_client_sync.py,sha256=i3lA0WL0_ehnfXWLarlXRzGFIjfteg-AE0PbRzaMYoY,5098
+blitz_api/_compat.py,sha256=zAQwSfCQbC-zzHGyUHCvRQXNf4Eao-7tCgzaaVJI-So,1113
+blitz_api/_constants.py,sha256=Bd-HojCZNBDVS5v295vunawszR43wRO44HFmmS_VnVQ,1322
+blitz_api/_exceptions.py,sha256=doWnsQbd5XaQqXB2pqgMseeYwwPWHETugzlMzJJEWeg,3798
+blitz_api/_pagination_async.py,sha256=e2MlTRh32gQSaaq-RqRB2Ocy0VQDSkSA4XSg_tI1id8,4746
+blitz_api/_pagination_base.py,sha256=3kVPUkEIz4G74j2AJLwhqNmnyekbT4S-3mG2-PvwL1U,1920
+blitz_api/_pagination_sync.py,sha256=mqt6iA8Dits3RK_T3TX2JLK1dcE0yAU93VKDGaBBU9U,4823
+blitz_api/_rate_limit.py,sha256=cm6P1pWWdS7gc0Br-rVJ6MuMlRhWGluVDBq--cGUUdI,578
+blitz_api/_rate_limit_async.py,sha256=kcG31uHWo3exMZDzX9wFVeTU-LccJWqF_38ELN_Vqek,2711
+blitz_api/_rate_limit_sync.py,sha256=gCqLYCsXh8-m5sVOuntGEUjskavT1Uyh_IY7S-OBky8,2863
+blitz_api/_version.py,sha256=IOEzhCbX916JIkvZr03GFY4bl9YqSkfjdqLO4qJ2FOs,50
+blitz_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+blitz_api/resources/__init__.py,sha256=mWslhutXjoMVu53ANbvreG53epF_l0R-gvKMlBzZ0YA,856
+blitz_api/resources/_async/__init__.py,sha256=fayqNuA3x517MqMUeDrjrsAcgw-3Gkz7E0d7sZX2HeA,69
+blitz_api/resources/_async/account.py,sha256=-vn2XZv0HLixsAYgO9gHl_FsLvh9u3f9az7Kpy4parM,758
+blitz_api/resources/_async/enrichment.py,sha256=t08fk4M1Jue6M4ZMWBvxSAwkVDkF-FiBXFxkxM8PP0M,3862
+blitz_api/resources/_async/search.py,sha256=Ncyj0O17Pe3qI_KoONmX1pX149oYsZb4QA-qfQm5gDE,5224
+blitz_api/resources/_async/utils.py,sha256=bUO0OgAT9nhq7kvfHK1mH8PLMEvqJI70ZFDErs-BHQA,1453
+blitz_api/resources/_sync/__init__.py,sha256=bA0UT2ZHjIc6IlkaFDVk_Ii-Z_Y66-Zse_aADGAHQLw,253
+blitz_api/resources/_sync/account.py,sha256=l6y-zT2bucXNw7Ahq0JDgBLj1z7-uBk2TkZQGjmIiCw,914
+blitz_api/resources/_sync/enrichment.py,sha256=gDLSEs7OVzeP2rD34UGGjH0bhv4K1kWf61eeSz5iE0g,3949
+blitz_api/resources/_sync/search.py,sha256=WxiYS-_59d2jv6Zgv825ot4347ic8_xvl-sBs26RE28,5302
+blitz_api/resources/_sync/utils.py,sha256=iRDdno1LVceUokCmnn24gtEIcuuSmh6FSrNhgY6MvtM,1595
+blitz_api/types/__init__.py,sha256=IIJtCbDf8siDZTJrepph6N1k7KQ1dwAoaiXkxwErO_4,2257
+blitz_api/types/_models.py,sha256=ap1K9KVVdO_9cvnKYC8YElZUYfNKYRgs3WArd3NJ-dY,752
+blitz_api/types/account.py,sha256=DZ9x7Mx5ad8AJCgZ5y8nnYOuANNeDrs9brzezmg69XQ,702
+blitz_api/types/enrichment.py,sha256=ymNXS_j4oi6oKSe87787wQC1mvhUc-zUK0Iorb22sUU,2036
+blitz_api/types/enums.py,sha256=91PyiqGSfY39h774HbLo6IHY0Uxzc0l37bBWKpQTsDE,34617
+blitz_api/types/filters.py,sha256=F-XoRSOFxovWgGE03cvK-MvsJbdOcsT6uSTuu4WEIj4,3805
+blitz_api/types/search.py,sha256=-BSEfeLyVb_GR8YICeLHecA-AM5tvWpS8mlmH9X194I,1019
+blitz_api/types/shared.py,sha256=1oJriRNR8xEAEJnZtXqviH1l6C1Sl8_LHh0M_udTUFs,3446
+blitz_api/types/utils.py,sha256=VYzPZy2p8GfXnETQ1gPCqKPT4LrCvUal_oTtcJ9LBdQ,878
+blitz_api_py-0.1.0.dist-info/METADATA,sha256=uLaH_JG_zedmpu2Bv_EoSpzCM2NzGQqfEMJi_Hp7J-o,7829
+blitz_api_py-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+blitz_api_py-0.1.0.dist-info/licenses/LICENSE,sha256=mTMTtchY-ZrmXdm9MUKXRPzPi7eR2CE2BA5Ocm9qw0M,1066
+blitz_api_py-0.1.0.dist-info/RECORD,,

blitz_api_py-0.1.0.dist-info/WHEEL

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

blitz_api_py-0.1.0.dist-info/licenses/LICENSE

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