yta-httpx 0.0.1__py3-none-any.whl

yta_httpx/__init__.py

@@ -0,0 +1,3 @@
+"""
+The Youtube Autonomous Httpx Module
+"""

yta_httpx/client/__init__.py

@@ -0,0 +1,596 @@
+from yta_httpx.client.utils import _raise_exception_if_status_code, content_type_to_parse_mode
+from yta_httpx.enums import RequestMethod, ResponseParseMode, ResponseTransportMode
+from yta_httpx.exceptions import HttpRequestError
+from yta_httpx.types import ParsedResponseType, ParsedCompleteResponseType, ParsedStreamResponseType
+from typing import Any, Union
+
+import httpx
+import warnings
+
+
+class HttpClient:
+    """
+    HttpClient to send requests.
+    """
+
+    def __init__(
+        self,
+        timeout: float = 60.0,
+        default_headers: Union[dict, None] = None
+    ):
+        self._client = httpx.AsyncClient(
+            timeout = timeout,
+            headers = default_headers
+        )
+        """
+        *For internal use only*
+
+        The `httpx.AsyncClient` instance to be used to
+        send the reqeusts we need.
+        """
+        self.get: _HttpClientMethodNamespace = _HttpClientMethodNamespace(
+            http_client = self,
+            method = RequestMethod.GET
+        )
+        """
+        Shortcut to send `GET` requests.
+        """
+        self.post: _HttpClientMethodNamespace = _HttpClientMethodNamespace(
+            http_client = self,
+            method = RequestMethod.POST
+        )
+        """
+        Shortcut to send `POST` requests.
+        """
+
+    async def close(
+        self
+    ):
+        """
+        *Asynchronous method*
+
+        Force the client to be closed asynchronously.
+        """
+        await self._client.aclose()
+
+    def __del__(
+        self
+    ):
+        if not self._client.is_closed:
+            warnings.warn(
+                'HttpClient was not properly closed'
+            )
+
+    async def __aenter__(
+        self
+    ):
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type,
+        exc,
+        tb
+    ):
+        await self.close()
+
+    async def request_complete(
+        self,
+        method: RequestMethod,
+        url: str,
+        *,
+        headers: Union[dict, None] = None,
+        params: Union[dict, None] = None,
+        json: Union[dict, None] = None,
+        data: Any = None,
+        content: Union[bytes, None] = None,
+        response_parse_mode: ResponseParseMode = ResponseParseMode.RESPONSE,
+        timeout: int = 60
+    ) -> ParsedCompleteResponseType:
+        """
+        *Asynchronous method*
+
+        Method to send a completely customizable request
+        that will return the whole response and will not
+        be streamed (using not the `stream=True` option).
+        """
+        return request_complete(
+            client = self._client,
+            method = method,
+            url = url,
+            # TODO: What about the '*' (?)
+            headers = headers,
+            params = params,
+            json = json,
+            data = data,
+            content = content,
+            response_parse_mode = response_parse_mode,
+            timeout = timeout
+        )
+    
+    async def request_stream(
+        self,
+        method: RequestMethod,
+        url: str,
+        *,
+        headers: Union[dict, None] = None,
+        params: Union[dict, None] = None,
+        json: Union[dict, None] = None,
+        data: Any = None,
+        content: Union[bytes, None] = None,
+        response_parse_mode: ResponseParseMode = ResponseParseMode.RESPONSE,
+        chunk_size: int = 8192,
+        timeout: int = 60
+    ) -> ParsedCompleteResponseType:
+        """
+        *Asynchronous method*
+
+        Method to send a completely customizable request
+        that will return the response by chunks, as a
+        streamed response (using the `stream=True` option).
+        """
+        return request_stream(
+            client = self._client,
+            method = method,
+            url = url,
+            # TODO: What about the '*' (?)
+            headers = headers,
+            params = params,
+            json = json,
+            data = data,
+            content = content,
+            response_parse_mode = response_parse_mode,
+            chunk_size = chunk_size,
+            timeout = timeout
+        )
+
+class _HttpClientMethodNamespace:
+    """
+    *For internal use only*
+
+    Class to include the funcionality related to
+    the method of the `HttpClient` requests.
+
+    Class to be used as a hierarchical system.
+    """
+
+    def __init__(
+        self,
+        http_client: HttpClient,
+        method: RequestMethod
+    ):
+        method = RequestMethod.to_enum(method)
+
+        self._http_client: 'HttpClient' = http_client
+        """
+        *For internal use only*
+
+        The reference to the father `HttpClient` instance.
+        """
+        self._method: RequestMethod = method
+        """
+        *For internal use only*
+
+        The method that will be used for the requests that
+        are made by this instance.
+        """
+        self.stream = _HttpClientTransportModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = ResponseTransportMode.STREAM
+        )
+        """
+        Attribute to send a request that will be streamed.
+
+        If you are using a `stream`, check this code below
+        to handle the response:
+        ```
+        async for chunk in http_client.get.stream.as_bytes(...):
+            print(chunk)
+        ```
+        """
+        self.complete = _HttpClientTransportModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = ResponseTransportMode.COMPLETE
+        )
+        """
+        Attribute to send a request that will not be streamed.
+        """
+
+class _HttpClientTransportModeNamespace:
+    """
+    *For internal use only*
+
+    Class to include the funcionality related to
+    the transport mode of the `HttpClient` requests.
+
+    Class to be used as a hierarchical system.
+    """
+
+    def __init__(
+        self,
+        http_client: HttpClient,
+        method: RequestMethod,
+        transport_mode: ResponseTransportMode
+    ):
+        method = RequestMethod.to_enum(method)
+        transport_mode = ResponseTransportMode.to_enum(transport_mode)
+
+        self._http_client: 'HttpClient' = http_client
+        """
+        *For internal use only*
+
+        The reference to the father `HttpClient` instance.
+        """
+        self._method: RequestMethod = method
+        """
+        *For internal use only*
+
+        The method that will be used for the requests that
+        are made by this instance.
+        """
+        self._transport_mode: ResponseTransportMode = transport_mode
+        """
+        *For internal use only*
+
+        The transport mode that will be used for the requests
+        that are made by this instance.
+        """
+
+        self.as_json = _HttpClientParseModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = transport_mode,
+            parse_mode = ResponseParseMode.JSON
+        )
+        """
+        Attribute to send a request that will parse the result
+        as a json.
+        """
+        self.as_text = _HttpClientParseModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = transport_mode,
+            parse_mode = ResponseParseMode.TEXT
+        )
+        """
+        Attribute to send a request that will parse the result
+        as text.
+        """
+        self.as_bytes = _HttpClientParseModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = transport_mode,
+            parse_mode = ResponseParseMode.BYTES
+        )
+        """
+        Attribute to send a request that will parse the result
+        as bytes.
+        """
+        self.as_lines = _HttpClientParseModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = transport_mode,
+            parse_mode = ResponseParseMode.LINES
+        )
+        """
+        Attribute to send a request that will parse the result
+        as lines.
+        """
+        self.as_response = _HttpClientParseModeNamespace(
+            http_client = http_client,
+            method = method,
+            transport_mode = transport_mode,
+            parse_mode = ResponseParseMode.RESPONSE
+        )
+        """
+        Attribute to send a request that will return the
+        whole response as it is, as an object, parsed not.
+        """
+
+class _HttpClientParseModeNamespace:
+    """
+    *For internal use only*
+
+    Class to include the funcionality related to
+    the parse mode of the `HttpClient` requests.
+    
+    Class to be used as a hierarchical system.
+    """
+
+    def __init__(
+        self,
+        http_client: HttpClient,
+        method: RequestMethod,
+        transport_mode: ResponseTransportMode,
+        parse_mode: ResponseParseMode
+    ):
+        method = RequestMethod.to_enum(method)
+        transport_mode = ResponseTransportMode.to_enum(transport_mode)
+        parse_mode = ResponseParseMode.to_enum(parse_mode)
+
+        self._http_client: 'HttpClient' = http_client
+        """
+        *For internal use only*
+
+        The reference to the father `HttpClient` instance.
+        """
+        self._method: RequestMethod = method
+        """
+        *For internal use only*
+
+        The method that will be used for the requests that
+        are made by this instance.
+        """
+        self._transport_mode: ResponseTransportMode = transport_mode
+        """
+        *For internal use only*
+
+        The transport mode that will be used for the requests
+        that are made by this instance.
+        """
+        self._parse_mode: ResponseParseMode = parse_mode
+        """
+        *For internal use only*
+
+        The parse mode that will be used for the requests
+        that are made by this instance.
+        """
+
+    async def __call__(
+        self,
+        url: str,
+        headers: Union[dict, None] = None,
+        params: Union[dict, None] = None,
+        json: Union[dict, None] = None,
+        data: Any = None,
+        content: Union[bytes, None] = None,
+        chunk_size: int = 8196,
+        timeout: int = 60,
+        # TODO: No more specific args (?)
+        **kwargs
+    ):
+        if self._transport_mode == ResponseTransportMode.COMPLETE:
+            return await request_complete(
+                client = self._http_client._client,
+                method = self._method,
+                url = url,
+                headers = headers,
+                params = params,
+                json = json,
+                data = data,
+                content = content,
+                response_parse_mode = self._parse_mode,
+                timeout = timeout,
+                **kwargs
+            )
+        
+        return request_stream(
+            client = self._http_client._client,
+            method = self._method,
+            url = url,
+            headers = headers,
+            params = params,
+            json = json,
+            data = data,
+            content = content,
+            response_parse_mode = self._parse_mode,
+            chunk_size = chunk_size,
+            timeout = timeout
+        )
+
+        
+# Utils below
+async def request_complete(
+    client: 'AsyncClient',
+    method: RequestMethod,
+    url: str,
+    *,
+    headers: Union[dict, None] = None,
+    params: Union[dict, None] = None,
+    json: Union[dict, None] = None,
+    data: Any = None,
+    content: Union[bytes, None] = None,
+    response_parse_mode: ResponseParseMode = ResponseParseMode.RESPONSE,
+    timeout: int = 60
+) -> ParsedCompleteResponseType:
+    response = await client.request(
+        method = method.value,
+        url = url,
+        content = content,
+        data = data,
+        json = json,
+        params = params,
+        headers = headers,
+        timeout = timeout
+    )
+
+    await _raise_exception_if_status_code(response)
+
+    return await parse_response_content(
+        response = response,
+        transport_mode = ResponseTransportMode.COMPLETE,
+        parse_mode = response_parse_mode
+    )
+
+
+async def request_stream(
+    client: 'AsyncClient',
+    method: RequestMethod,
+    url: str,
+    *,
+    headers: Union[dict, None] = None,
+    params: Union[dict, None] = None,
+    json: Union[dict, None] = None,
+    data: Any = None,
+    content: Union[bytes, None] = None,
+    response_parse_mode: ResponseParseMode = ResponseParseMode.RESPONSE,
+    chunk_size: int = 8192,
+    timeout: int = 60
+) -> ParsedStreamResponseType:
+    async with client.stream(
+        method = method.value,
+        url = url,
+        content = content,
+        data = data,
+        json = json,
+        params = params,
+        headers = headers,
+        timeout = timeout
+    ) as response:
+        await _raise_exception_if_status_code(response)
+
+        parsed_stream = await parse_response_content(
+            response = response,
+            transport_mode = ResponseTransportMode.STREAM,
+            parse_mode = response_parse_mode,
+            chunk_size = chunk_size
+        )
+
+        async for chunk in parsed_stream:
+            yield chunk
+    
+
+async def _parse_stream_response(
+    response: httpx.Response,
+    parse_mode: ResponseParseMode,
+    chunk_size: int = 8192
+) -> ParsedStreamResponseType:
+    """
+    *For internal use only*
+
+    Method used by the `parse_response_content`
+    to parse the content when the request has
+    been done as a stream request and not as
+    a complete request.
+    """
+    # TODO: Can we validate if it was streaming (?)
+    parse_mode = ResponseParseMode.to_enum(parse_mode)
+
+    if parse_mode == ResponseParseMode.BYTES:
+        async for chunk in response.aiter_bytes(chunk_size):
+            yield chunk
+    elif parse_mode == ResponseParseMode.TEXT:
+        async for chunk in response.aiter_text():
+            yield chunk
+    elif parse_mode == ResponseParseMode.LINES:
+        async for line in response.aiter_lines():
+            yield line
+    elif parse_mode == ResponseParseMode.JSON:
+        async for line in response.aiter_lines():
+            if not line:
+                continue
+            # TODO: Check this...
+            import json
+            # TODO: Check if possible or not (?)
+            yield json.loads(line)
+    elif parse_mode == ResponseParseMode.RESPONSE:
+        # TODO: Non-sense, but here it is, maybe exc instead (?)
+        yield response
+
+async def _parse_complete_response(
+    response: httpx.Response,
+    parse_mode: ResponseParseMode,  
+) -> ParsedCompleteResponseType:
+    """
+    *For internal use only*
+
+    Method used by the `parse_response_content`
+    to parse the content when the request has
+    been done as a complete request and not as
+    a stream request.
+    """
+    parse_mode = ResponseParseMode.to_enum(parse_mode)
+
+    if parse_mode == ResponseParseMode.JSON:
+        return _parse_response_content_as_json(response = response)
+    elif parse_mode == ResponseParseMode.TEXT:
+        return response.text
+    elif parse_mode == ResponseParseMode.BYTES:
+        return response.content
+    elif parse_mode == ResponseParseMode.LINES:
+        # TODO: Non-sense, but here it is, maybe exc instead (?)
+        return response.text.splitlines()
+    elif parse_mode == ResponseParseMode.RESPONSE:
+        return response
+
+async def parse_response_content(
+    response: httpx.Response,
+    transport_mode: ResponseTransportMode = ResponseTransportMode.COMPLETE,
+    parse_mode: ResponseParseMode = ResponseParseMode.AUTO,
+    chunk_size: int = 8192
+) -> ParsedResponseType:
+    """
+    Parse the given `response` according to the 
+    `transport_mode` given and the `parse_mode` also
+    provided.
+
+    If the `parse_mode` is `AUTO`, we need to detect
+    the real `parse_mode` we need to apply based on
+    the `content_type` of the `response` provided,
+    which will be autodetected by us.
+    """
+    parse_mode = ResponseParseMode.to_enum(parse_mode)
+    transport_mode = ResponseTransportMode.to_enum(transport_mode)
+
+    if parse_mode == ResponseParseMode.AUTO:
+        parse_mode = _resolve_parse_mode(
+            response = response,
+            parse_mode = parse_mode
+        )
+
+    # Complete
+    if transport_mode == ResponseTransportMode.COMPLETE:
+        return await _parse_complete_response(
+            response = response,
+            parse_mode = parse_mode
+        )
+    
+    # Stream
+    return _parse_stream_response(
+        response = response,
+        parse_mode = parse_mode,
+        chunk_size = chunk_size
+    )
+    
+def _resolve_parse_mode(
+    response: 'Response',
+    parse_mode: ResponseParseMode
+) -> ResponseParseMode:
+    """
+    Method to resolve the `ResponseParseMode`
+    according to the `parse_mode` option provided
+    and the `content_type` of the `response`,
+    because if `ResponseParseMode.AUTO` is given it
+    will be autoselected based on it.
+    """
+    if parse_mode != ResponseParseMode.AUTO:
+        return parse_mode
+    
+    content_type = response.headers.get(
+        'content-type',
+        ''
+    ).lower()
+
+    return content_type_to_parse_mode(content_type)
+
+def _parse_response_content_as_json(
+    response: httpx.Response
+) -> dict:
+    """
+    *For internal use only*
+
+    Method to try to obtain the `response` as a `JSON`,
+    raising an exception if something is wrong.
+    """
+    try:
+        return response.json()
+
+    except Exception as e:
+        raise HttpRequestError(
+            status_code = response.status_code,
+            message = f'Invalid JSON response: {e}',
+            response_text = response.text
+        )
+

yta_httpx/client/utils.py

@@ -0,0 +1,62 @@
+from yta_httpx.enums import ResponseContentType, ResponseParseMode
+from yta_httpx.exceptions import HttpRequestError
+
+
+def content_type_to_parse_mode(
+    content_type: ResponseContentType
+) -> ResponseParseMode:
+    """
+    Transform the `content_type` provided into
+    the `ResponseParseMode` that has to be used
+    to parse that type of response.
+    """
+    try:
+        content_type = ResponseContentType.to_enum(content_type)
+    except:
+        print(f'The {content_type} is not registered in our system, ask the administrator to add it. Using "ResponseParseMode.BYTES" by default.')
+
+        return ResponseParseMode.BYTES
+
+    """
+    We must have all the `ResponseContentType` items
+    here with their corresponding mode, and if it is
+    not registered it will be detected above.
+    """
+    return {
+        ResponseContentType.APPLICATION_JSON: ResponseParseMode.JSON,
+        ResponseContentType.TEXT_PLAIN: ResponseParseMode.TEXT,
+        ResponseContentType.TEXT_HTML: ResponseParseMode.TEXT,
+        ResponseContentType.APPLICATION_XML: ResponseParseMode.TEXT,
+        ResponseContentType.IMAGE_JPEG: ResponseParseMode.BYTES,
+        ResponseContentType.VIDEO_MP4: ResponseParseMode.BYTES,
+        ResponseContentType.AUDIO_WAV: ResponseParseMode.BYTES,
+        ResponseContentType.TEXT_EVENT_STREAM: ResponseParseMode.LINES,
+        ResponseContentType.APPLICATION_XHTML_XML: ResponseParseMode.TEXT,
+        ResponseContentType.APPLICATION_JAVASCRIPT: ResponseParseMode.TEXT,
+        ResponseContentType.APPLICATION_PROBLEM_JSON: ResponseParseMode.JSON
+    }[content_type]
+
+async def _raise_exception_if_status_code(
+    response: 'httpx.Response'
+):
+    """
+    *Asynchronous method*
+
+    *For internal use only*
+
+    Raise an exception if the `status_code` is
+    indicating the error extracted from the
+    response itself.
+    """
+    if response.status_code >= 400:
+        try:
+            text = await response.aread()
+            text = text.decode()
+        except:
+            text = None
+
+        raise HttpRequestError(
+            status_code = response.status_code,
+            message = 'Request failed',
+            response_text = text
+        )

yta_httpx/enums.py

@@ -0,0 +1,65 @@
+from yta_constants.enum import YTAEnum as Enum
+
+
+class RequestMethod(Enum):
+    """
+    The different methods of a request.
+    """
+    GET = 'GET'
+    POST = 'POST'
+
+class ResponseTransportMode(Enum):
+    """
+    Enum class to indicate the way you want to load
+    and receive the content of the response, that
+    can be at once, or by chunks through an iterator
+    that is caused by an streamed response.
+    """
+    STREAM = 'stream'
+    """
+    The response content will be given chunk by chunk
+    with an iterator.
+    """
+    COMPLETE = 'complete'
+    """
+    The response content will be given all of it at
+    once.
+    """
+
+class ResponseParseMode(Enum):
+    """
+    The way we want to parse the content that comes
+    as a result of a request.
+    """
+    AUTO = 'auto'
+    """
+    The way to parse the content will be chosen
+    according to the response content type.
+    """
+    JSON = 'json'
+    TEXT = 'text'
+    BYTES = 'bytes'
+    LINES = 'lines'
+    RESPONSE = 'response'
+    """
+    This mode will return the whole response and as
+    it was received, not only the content.
+    """
+
+class ResponseContentType(Enum):
+    """
+    The `content_type` field that could come in a
+    request.
+    """
+    APPLICATION_JSON = 'application/json'
+    TEXT_PLAIN = 'text/plain'
+    TEXT_HTML = 'text/html'
+    APPLICATION_XML = 'application/xml'
+    IMAGE_JPEG = 'image/jpeg'
+    VIDEO_MP4 = 'video/mp4'
+    AUDIO_WAV = 'audio/wav'
+    APPLICATION_OCTET_STREAM = 'application/octet-stream'
+    TEXT_EVENT_STREAM = 'text/event-stream'
+    APPLICATION_XHTML_XML = 'application/xhtml+xml'
+    APPLICATION_JAVASCRIPT = 'application/javascript'
+    APPLICATION_PROBLEM_JSON = 'application/problem+json'

yta_httpx/exceptions.py

@@ -0,0 +1,15 @@
+from typing import Union
+
+
+class HttpRequestError(Exception):
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        response_text: Union[str, None] = None
+    ):
+        self.status_code = status_code
+        self.message = message
+        self.response_text = response_text
+
+        super().__init__(f'{status_code} - {message}')

yta_httpx/types.py

@@ -0,0 +1,34 @@
+from typing import Union, Any
+from typing import Any, AsyncGenerator, Union
+
+import httpx
+
+
+JsonType = Union[
+    dict[str, Any],
+    list[Any]
+]
+
+StreamChunkType = Union[
+    bytes,
+    str,
+    JsonType
+]
+
+ParsedCompleteResponseType = Union[
+    JsonType,
+    str,
+    bytes,
+    httpx.Response
+]
+
+ParsedStreamResponseType = AsyncGenerator[
+    StreamChunkType,
+    None
+]
+
+ParsedResponseType = Union[
+    ParsedCompleteResponseType,
+    ParsedStreamResponseType
+]
+

yta_httpx-0.0.1.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: yta-httpx
+Version: 0.0.1
+Summary: Youtube Autonomous Httpx Module.
+License-File: LICENSE
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: >=3.8,<3.14
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Dist: httpx (>=0.0.1,<9999.9.9)
+Requires-Dist: yta_constants (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous Httpx Module
+
+The module to implement Http clients to make requests easily.

yta_httpx-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+yta_httpx/__init__.py,sha256=_kbCgTevMudl-5sKvCSG8BiUoqmkCVt4jSf7GaLranE,45
+yta_httpx/client/__init__.py,sha256=uwZAkbGuIUsOeOEf_1iOOvlL2QgZbU8AaJwD6zlwNlQ,18056
+yta_httpx/client/utils.py,sha256=fZh0-6xvXTD7q1vKDIU5d-b-QyNAiK3OzYmFGXUviSA,2244
+yta_httpx/enums.py,sha256=-WU7oT8f3Dq1a_QX9WjAwuR2N5VRdfnnfduLEajTmuI,1772
+yta_httpx/exceptions.py,sha256=eQXzOZjMVMOGiD4MyuIbZAZ-nimVkUHHVYaVtCAkUL0,378
+yta_httpx/types.py,sha256=ZoExXSXgZQTMiQg2d69MyarmfXp5XPcG4Myei21DVwg,502
+yta_httpx-0.0.1.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_httpx-0.0.1.dist-info/METADATA,sha256=WMO7BGB_KILBeYne9gasoJlSbAwFbsVwXhAM1EKdgek,787
+yta_httpx-0.0.1.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+yta_httpx-0.0.1.dist-info/RECORD,,

yta_httpx-0.0.1.dist-info/WHEEL

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

yta_httpx-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.