deewan 0.2.0__py3-none-any.whl

deewan/__init__.py

@@ -0,0 +1,16 @@
+"""Official server SDK for the Deewan API.
+
+    from deewan import Deewan
+
+    deewan = Deewan(api_key=os.environ["DEEWAN_API_KEY"])
+    room = deewan.rooms.create(name="Onboarding call")
+    link = deewan.rooms.create_join_link(room["id"], name="Sara", role="host")
+
+Use it on your server only: an API key must never reach a browser or an app.
+"""
+
+from ._client import Deewan, DeewanError
+from ._webhooks import verify_webhook
+
+__all__ = ["Deewan", "DeewanError", "verify_webhook"]
+__version__ = "0.2.0"

deewan/_client.py

@@ -0,0 +1,402 @@
+from __future__ import annotations
+
+import base64
+import json
+import random
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Iterator, Optional
+
+VERSION = "0.2.0"
+_LOCAL_HOSTS = {"localhost", "127.0.0.1", "::1"}
+
+
+class DeewanError(Exception):
+    """An API error. ``status`` is 0 when the request never got an answer."""
+
+    def __init__(self, status: int, code: str, message: str, request_id: Optional[str] = None, details: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        self.details = details
+
+    def __repr__(self) -> str:
+        return f"DeewanError(status={self.status}, code={self.code!r}, message={self.message!r})"
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    # urllib would follow a redirect with the Authorization header attached,
+    # even to another host. The API never redirects, so refuse all of them.
+    def redirect_request(self, req, fp, code, msg, headers, newurl):  # noqa: D401
+        return None
+
+
+def _never_sent(error: BaseException) -> bool:
+    """Failures before the request left: DNS, refused connection."""
+    reason = getattr(error, "reason", error)
+    return isinstance(reason, (ConnectionRefusedError, socket.gaierror))
+
+
+def _backoff(attempt: int) -> float:
+    return min(8.0, 0.5 * 2**attempt) + random.random() * 0.25
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(str(value), safe="")
+
+
+def _drop_none(values: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in values.items() if v is not None}
+
+
+class Deewan:
+    """The Deewan API client.
+
+    ``timeout`` is per request, in seconds. Reads (GET, DELETE) are retried on
+    429 and 5xx up to ``max_retries`` times; writes are retried only on 429 or
+    when the connection never opened, so nothing is applied twice.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://deewan.io/api/v1",
+        timeout: float = 15.0,
+        max_retries: int = 2,
+    ):
+        if not isinstance(api_key, str) or not api_key.startswith("dwn_"):
+            raise ValueError("Deewan: pass a valid api_key (it starts with dwn_).")
+        parsed = urllib.parse.urlparse(base_url)
+        if parsed.scheme != "https" and parsed.hostname not in _LOCAL_HOSTS:
+            raise ValueError("Deewan: base_url must use https.")
+        self._key = api_key
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+        self._retries = max_retries
+        self._opener = urllib.request.build_opener(_NoRedirect())
+        self.rooms = Rooms(self)
+        self.meetings = Meetings(self)
+        self.polls = Polls(self)
+        self.breakouts = Breakouts(self)
+        self.recordings = Recordings(self)
+        self.webhooks = Webhooks(self)
+
+    def me(self) -> dict[str, Any]:
+        """The key's workspace, scopes and environment."""
+        return self._request("GET", "/me")
+
+    # -------------------------------------------------------------- transport
+
+    def _request(self, method: str, path: str, body: Any = None, query: Optional[dict[str, Any]] = None) -> Any:
+        return json.loads(self._send(method, path, body, query) or b"null")
+
+    def _send(self, method: str, path: str, body: Any = None, query: Optional[dict[str, Any]] = None) -> bytes:
+        url = self._base + path
+        if query:
+            clean = _drop_none(query)
+            if clean:
+                url += "?" + urllib.parse.urlencode(clean)
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {
+            "Authorization": f"Bearer {self._key}",
+            "Accept": "application/json",
+            "User-Agent": f"deewan-sdk-python/{VERSION}",
+        }
+        if data is not None:
+            headers["Content-Type"] = "application/json"
+        safe = method in ("GET", "DELETE")
+
+        attempt = 0
+        while True:
+            request = urllib.request.Request(url, data=data, method=method, headers=headers)
+            try:
+                with self._opener.open(request, timeout=self._timeout) as response:
+                    return response.read()
+            except urllib.error.HTTPError as error:
+                retryable = error.code == 429 or error.code >= 500
+                if retryable and (safe or error.code == 429) and attempt < self._retries:
+                    after = error.headers.get("Retry-After") if error.headers else None
+                    try:
+                        wait = float(after) if after else _backoff(attempt)
+                    except ValueError:
+                        wait = _backoff(attempt)
+                    time.sleep(wait if wait > 0 else _backoff(attempt))
+                    attempt += 1
+                    continue
+                raise self._to_error(error) from None
+            except (urllib.error.URLError, socket.timeout, ConnectionError) as error:
+                if (safe or _never_sent(error)) and attempt < self._retries:
+                    time.sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                raise DeewanError(0, "network_error", str(getattr(error, "reason", error))) from None
+
+    @staticmethod
+    def _to_error(error: urllib.error.HTTPError) -> DeewanError:
+        request_id = error.headers.get("x-request-id") if error.headers else None
+        try:
+            payload = json.loads(error.read() or b"null") or {}
+        except ValueError:
+            payload = {}
+        detail = payload.get("error") if isinstance(payload, dict) else None
+        detail = detail if isinstance(detail, dict) else {}
+        return DeewanError(
+            error.code,
+            detail.get("code") or "http_error",
+            detail.get("message") or f"HTTP {error.code}",
+            request_id,
+            detail.get("details"),
+        )
+
+
+class Rooms:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def list(self, *, limit: Optional[int] = None, starting_after: Optional[str] = None) -> dict[str, Any]:
+        return self._c._request("GET", "/rooms", query={"limit": limit, "starting_after": starting_after})
+
+    def all(self, page_size: int = 100) -> Iterator[dict[str, Any]]:
+        """Every room, fetching pages as needed."""
+        after: Optional[str] = None
+        while True:
+            page = self.list(limit=page_size, starting_after=after)
+            yield from page["data"]
+            if not page.get("has_more") or not page["data"]:
+                return
+            after = page["data"][-1]["id"]
+
+    def create(self, *, name: str, description: Optional[str] = None, settings: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        return self._c._request("POST", "/rooms", _drop_none({"name": name, "description": description, "settings": settings}))
+
+    def retrieve(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/rooms/{_q(room_id)}")
+
+    def update(self, room_id: str, **changes: Any) -> dict[str, Any]:
+        """``name``, ``description``, ``locked`` or ``settings`` (a partial dict)."""
+        return self._c._request("PATCH", f"/rooms/{_q(room_id)}", changes)
+
+    def delete(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/rooms/{_q(room_id)}")
+
+    def create_join_link(
+        self,
+        room_id: str,
+        *,
+        name: str,
+        role: Optional[str] = None,
+        user_id: Optional[str] = None,
+        expires_in: Optional[int] = None,
+        locale: Optional[str] = None,
+        redirect_url: Optional[str] = None,
+        branding: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """A personal, expiring link into Deewan's hosted meeting page."""
+        body = _drop_none(
+            {"name": name, "role": role, "user_id": user_id, "expires_in": expires_in, "locale": locale, "redirect_url": redirect_url, "branding": branding}
+        )
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/join-links", body)
+
+    def create_token(
+        self,
+        room_id: str,
+        *,
+        name: str,
+        role: Optional[str] = None,
+        user_id: Optional[str] = None,
+        avatar: Optional[str] = None,
+        exchange_key: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Credentials for an interface you build yourself (web, React Native or Flutter SDK).
+
+        For a room with strict encryption, pass the participant's ``exchange_key``
+        (the client SDK makes it on their device); the response then has
+        ``e2ee == "strict"`` and no passphrase.
+        """
+        body = _drop_none({"name": name, "role": role, "user_id": user_id, "avatar": avatar, "exchange_key": exchange_key})
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/tokens", body)
+
+    def list_participants(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/rooms/{_q(room_id)}/participants")
+
+    def remove_participant(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/rooms/{_q(room_id)}/participants/{_q(identity)}")
+
+    def mute_participant(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/participants/{_q(identity)}/mute")
+
+    def make_cohost(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/participants/{_q(identity)}/cohost")
+
+    def remove_cohost(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/rooms/{_q(room_id)}/participants/{_q(identity)}/cohost")
+
+    def invite_to_speak(self, room_id: str, identity: str) -> dict[str, Any]:
+        """Webinars: lets someone in the audience turn on their microphone and camera."""
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/participants/{_q(identity)}/stage")
+
+    def move_to_audience(self, room_id: str, identity: str) -> dict[str, Any]:
+        """Webinars: sends someone back to the audience."""
+        return self._c._request("DELETE", f"/rooms/{_q(room_id)}/participants/{_q(identity)}/stage")
+
+    def list_waiting(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/rooms/{_q(room_id)}/waiting")
+
+    def admit(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/waiting/{_q(identity)}", {"decision": "admit"})
+
+    def deny(self, room_id: str, identity: str) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/waiting/{_q(identity)}", {"decision": "deny"})
+
+    def end(self, room_id: str) -> dict[str, Any]:
+        """Ends the meeting for everyone; the room remains."""
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/end")
+
+
+class Meetings:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def list(self, *, from_: Optional[str] = None, to: Optional[str] = None, limit: Optional[int] = None) -> dict[str, Any]:
+        return self._c._request("GET", "/meetings", query={"from": from_, "to": to, "limit": limit})
+
+    def create(self, *, title: str, starts_at: str, ends_at: str, **extra: Any) -> dict[str, Any]:
+        """Schedules a meeting. ``extra``: description, room_id, recurrence, recurrence_until, timezone."""
+        return self._c._request("POST", "/meetings", {"title": title, "starts_at": starts_at, "ends_at": ends_at, **extra})
+
+    def retrieve(self, meeting_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/meetings/{_q(meeting_id)}")
+
+    def update(self, meeting_id: str, **changes: Any) -> dict[str, Any]:
+        return self._c._request("PATCH", f"/meetings/{_q(meeting_id)}", changes)
+
+    def cancel(self, meeting_id: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/meetings/{_q(meeting_id)}")
+
+
+class Polls:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def list(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/rooms/{_q(room_id)}/polls")
+
+    def create(self, room_id: str, *, question: str, options: list[str], **extra: Any) -> dict[str, Any]:
+        """``extra``: kind ("single"|"multiple"), anonymous, results ("live"|"after_vote"|"after_close")."""
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/polls", {"question": question, "options": options, **extra})
+
+    def close(self, poll_id: str) -> dict[str, Any]:
+        return self._c._request("PATCH", f"/polls/{_q(poll_id)}", {"status": "closed"})
+
+    def reopen(self, poll_id: str) -> dict[str, Any]:
+        return self._c._request("PATCH", f"/polls/{_q(poll_id)}", {"status": "open"})
+
+    def delete(self, poll_id: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/polls/{_q(poll_id)}")
+
+
+class Breakouts:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def get(self, room_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/rooms/{_q(room_id)}/breakouts")
+
+    def start(self, room_id: str, *, rooms: Any, **extra: Any) -> dict[str, Any]:
+        """``rooms``: a count (1–50) or a list of names. ``extra`` as in the API reference."""
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/breakouts", {"rooms": rooms, **extra})
+
+    def move(self, room_id: str, participant: str, breakout_id: Optional[str], *, can_return: Optional[bool] = None) -> dict[str, Any]:
+        body = _drop_none({"participant": participant, "can_return": can_return})
+        body["breakout_id"] = breakout_id
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/breakouts/assignments", body)
+
+    def add_room(self, room_id: str, name: Optional[str] = None) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/breakouts/rooms", _drop_none({"name": name}))
+
+    def rename_room(self, room_id: str, breakout_id: str, name: str) -> dict[str, Any]:
+        return self._c._request("PATCH", f"/rooms/{_q(room_id)}/breakouts/rooms/{_q(breakout_id)}", {"name": name})
+
+    def remove_room(self, room_id: str, breakout_id: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/rooms/{_q(room_id)}/breakouts/rooms/{_q(breakout_id)}")
+
+    def announce(self, room_id: str, message: str) -> dict[str, Any]:
+        """Shows a short message in every room. Not end-to-end encrypted."""
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/breakouts/announce", {"message": message})
+
+    def end(self, room_id: str, *, warn: Optional[bool] = None) -> dict[str, Any]:
+        return self._c._request("POST", f"/rooms/{_q(room_id)}/breakouts/end", _drop_none({"warn": warn}))
+
+
+class Recordings:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def list(self, *, room_id: Optional[str] = None, limit: Optional[int] = None) -> dict[str, Any]:
+        return self._c._request("GET", "/recordings", query={"room_id": room_id, "limit": limit})
+
+    def retrieve(self, recording_id: str) -> dict[str, Any]:
+        return self._c._request("GET", f"/recordings/{_q(recording_id)}")
+
+    def delete(self, recording_id: str) -> dict[str, Any]:
+        """Deletes the recording and its stored parts. Cannot be undone."""
+        return self._c._request("DELETE", f"/recordings/{_q(recording_id)}")
+
+    def download_info(self, recording_id: str) -> dict[str, Any]:
+        """The encrypted parts and the key for this one recording."""
+        return self._c._request("POST", f"/recordings/{_q(recording_id)}/download")
+
+    def download(self, recording_id: str) -> tuple[bytes, str]:
+        """Fetches a recording and decrypts it here. Returns ``(bytes, mime_type)``.
+
+        Needs ``pip install "deewan[recordings]"``. Recordings are encrypted
+        where they were made; this is the only way to get a playable file.
+        """
+        try:
+            from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+        except ImportError as error:  # pragma: no cover
+            raise ImportError('Recordings.download needs: pip install "deewan[recordings]"') from error
+        info = self.download_info(recording_id)
+        enc = info["encryption"]
+        key = base64.urlsafe_b64decode(enc["key"] + "=" * (-len(enc["key"]) % 4))
+        iv_bytes = int(enc["iv_bytes"])
+        cipher = AESGCM(key)
+        chunks = []
+        for part in info["parts"]:
+            index = part["index"]
+            body = self._c._send("GET", f"/recordings/{_q(recording_id)}/parts/{int(index)}")
+            aad = f"deewan-recording:{recording_id}:{index}".encode("utf-8")
+            chunks.append(cipher.decrypt(body[:iv_bytes], body[iv_bytes:], aad))
+        return b"".join(chunks), info["mime_type"]
+
+
+class Webhooks:
+    def __init__(self, client: Deewan):
+        self._c = client
+
+    def list(self) -> dict[str, Any]:
+        return self._c._request("GET", "/webhooks")
+
+    def create(self, *, url: str, events: list[str], description: Optional[str] = None, enabled: Optional[bool] = None) -> dict[str, Any]:
+        """The response's ``secret`` is shown only once — store it."""
+        body = _drop_none({"url": url, "events": events, "description": description, "enabled": enabled})
+        return self._c._request("POST", "/webhooks", body)
+
+    def update(self, webhook_id: str, **changes: Any) -> dict[str, Any]:
+        return self._c._request("PATCH", f"/webhooks/{_q(webhook_id)}", changes)
+
+    def delete(self, webhook_id: str) -> dict[str, Any]:
+        return self._c._request("DELETE", f"/webhooks/{_q(webhook_id)}")
+
+    def test(self, webhook_id: str) -> dict[str, Any]:
+        return self._c._request("POST", f"/webhooks/{_q(webhook_id)}/test")
+
+    def deliveries(self, webhook_id: str) -> dict[str, Any]:
+        """The 50 most recent delivery attempts to this endpoint, newest first."""
+        return self._c._request("GET", f"/webhooks/{_q(webhook_id)}/deliveries")

deewan/_webhooks.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Optional, Union
+
+from ._client import DeewanError
+
+
+def verify_webhook(
+    raw_body: Union[str, bytes],
+    signature_header: Optional[str],
+    secret: str,
+    tolerance_seconds: int = 300,
+) -> dict[str, Any]:
+    """Verifies a webhook request and returns the parsed event.
+
+    Pass the raw body exactly as received (not re-serialized JSON) and the
+    ``Deewan-Signature`` header. Signatures older than ``tolerance_seconds``
+    are rejected, to stop replays.
+    """
+    if not signature_header:
+        raise DeewanError(400, "missing_signature", "Missing Deewan-Signature header.")
+    parts: dict[str, str] = {}
+    for item in signature_header.split(","):
+        key, _, value = item.strip().partition("=")
+        parts[key] = value
+    try:
+        timestamp = int(parts.get("t", ""))
+    except ValueError:
+        raise DeewanError(400, "bad_signature", "Malformed Deewan-Signature header.") from None
+    if not parts.get("v1"):
+        raise DeewanError(400, "bad_signature", "Malformed Deewan-Signature header.")
+    if abs(time.time() - timestamp) > tolerance_seconds:
+        raise DeewanError(400, "stale_signature", "Webhook timestamp is outside the allowed tolerance.")
+    body = raw_body.decode("utf-8") if isinstance(raw_body, bytes) else raw_body
+    expected = hmac.new(secret.encode("utf-8"), f"{timestamp}.{body}".encode("utf-8"), hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(expected, parts["v1"]):
+        raise DeewanError(400, "bad_signature", "Webhook signature does not match.")
+    return json.loads(body)

deewan-0.2.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.5
+Name: deewan
+Version: 0.2.0
+Summary: Official server SDK for the Deewan video meetings API: rooms, join links, meetings, polls, breakouts, recordings and webhooks.
+Project-URL: Documentation, https://deewan.io/en/docs/sdk
+Project-URL: Repository, https://github.com/deewanio/deewan-platform/tree/main/packages/python
+Project-URL: Issues, https://github.com/deewanio/deewan-platform/issues
+Author-email: Deewan <support@deewan.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: deewan,e2ee,meetings,video,webrtc
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: recordings
+Requires-Dist: cryptography>=42; extra == 'recordings'
+Description-Content-Type: text/markdown
+
+# deewan
+
+The official Python server SDK for the [Deewan](https://deewan.io) video meetings API.
+
+```bash
+pip install deewan
+pip install "deewan[recordings]"   # only to download (decrypt) recordings
+```
+
+```python
+import os
+from deewan import Deewan, DeewanError, verify_webhook
+
+deewan = Deewan(os.environ["DEEWAN_API_KEY"])
+
+room = deewan.rooms.create(name="Onboarding call")
+link = deewan.rooms.create_join_link(room["id"], name="Sara", role="host")
+token = deewan.rooms.create_token(room["id"], name="Omar")  # for a custom interface
+
+event = verify_webhook(raw_body, headers["Deewan-Signature"], os.environ["DEEWAN_WEBHOOK_SECRET"])
+```
+
+Python 3.9+, no dependencies. Requests time out after 15 s; reads are retried
+on 429 and 5xx, writes only when they can't have been applied. Redirects and
+plain http are refused, so the key is only ever sent to Deewan. Errors are
+`DeewanError` with `status`, `code`, `message` and `request_id`.
+
+Server-side only — the API key must never reach a browser or app.
+Full reference: https://deewan.io/en/docs/sdk

deewan-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+deewan/__init__.py,sha256=adJVPLKmXy_F5Oynm8B11ifDVL6ZfZukBR-gcLnlejw,506
+deewan/_client.py,sha256=ySXYiwk_hrTzUcWTvECUzb-xB9LrC7FRJ5OLKzsrOlg,18074
+deewan/_webhooks.py,sha256=Hp1FPLmy5EBWqP36HQHfRh0Wb8kF2NY6Z0gBqAKdXU4,1669
+deewan-0.2.0.dist-info/METADATA,sha256=eVBVzzsRZ2yI-BSJ2IQlK4mzzJj1CueNjGS23CIDr-s,1916
+deewan-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+deewan-0.2.0.dist-info/licenses/LICENSE,sha256=md0vUKCEZqoQHGXUNV8uYbE2IgDNvRH5fpTMJ5zGc2w,1063
+deewan-0.2.0.dist-info/RECORD,,

deewan-0.2.0.dist-info/WHEEL

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

deewan-0.2.0.dist-info/licenses/LICENSE

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