mcp-hydrolix 0.1.0__py3-none-any.whl

mcp_hydrolix/__init__.py

@@ -0,0 +1,13 @@
+from .mcp_server import (
+    create_hydrolix_client,
+    list_databases,
+    list_tables,
+    run_select_query,
+)
+
+__all__ = [
+    "list_databases",
+    "list_tables",
+    "run_select_query",
+    "create_hydrolix_client",
+]

mcp_hydrolix/main.py

@@ -0,0 +1,9 @@
+from .mcp_server import mcp
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

mcp_hydrolix/mcp_env.py

@@ -0,0 +1,131 @@
+"""Environment configuration for the MCP Hydrolix server.
+
+This module handles all environment variable configuration with sensible defaults
+and type conversion.
+"""
+
+from dataclasses import dataclass
+import os
+from typing import Optional
+
+
+@dataclass
+class HydrolixConfig:
+    """Configuration for Hydrolix connection settings.
+
+    This class handles all environment variable configuration with sensible defaults
+    and type conversion. It provides typed methods for accessing each configuration value.
+
+    Required environment variables:
+        HYDROLIX_HOST: The hostname of the Hydrolix server
+        HYDROLIX_USER: The username for authentication
+        HYDROLIX_PASSWORD: The password for authentication
+
+    Optional environment variables (with defaults):
+        HYDROLIX_PORT: The port number (default: 8088)
+        HYDROLIX_VERIFY: Verify SSL certificates (default: true)
+        HYDROLIX_CONNECT_TIMEOUT: Connection timeout in seconds (default: 30)
+        HYDROLIX_SEND_RECEIVE_TIMEOUT: Send/receive timeout in seconds (default: 300)
+        HYDROLIX_DATABASE: Default database to use (default: None)
+    """
+
+    def __init__(self):
+        """Initialize the configuration from environment variables."""
+        self._validate_required_vars()
+
+    @property
+    def host(self) -> str:
+        """Get the Hydrolix host."""
+        return os.environ["HYDROLIX_HOST"]
+
+    @property
+    def port(self) -> int:
+        """Get the Hydrolix port.
+
+        Defaults to 8088.
+        Can be overridden by HYDROLIX_PORT environment variable.
+        """
+        if "HYDROLIX_PORT" in os.environ:
+            return int(os.environ["HYDROLIX_PORT"])
+        return 8088
+
+    @property
+    def username(self) -> str:
+        """Get the Hydrolix username."""
+        return os.environ["HYDROLIX_USER"]
+
+    @property
+    def password(self) -> str:
+        """Get the Hydrolix password."""
+        return os.environ["HYDROLIX_PASSWORD"]
+
+    @property
+    def database(self) -> Optional[str]:
+        """Get the default database name if set."""
+        return os.getenv("HYDROLIX_DATABASE")
+
+    @property
+    def verify(self) -> bool:
+        """Get whether SSL certificate verification is enabled.
+
+        Default: True
+        """
+        return os.getenv("HYDROLIX_VERIFY", "true").lower() == "true"
+
+    @property
+    def connect_timeout(self) -> int:
+        """Get the connection timeout in seconds.
+
+        Default: 30
+        """
+        return int(os.getenv("HYDROLIX_CONNECT_TIMEOUT", "30"))
+
+    @property
+    def send_receive_timeout(self) -> int:
+        """Get the send/receive timeout in seconds.
+
+        Default: 300 (Hydrolix default)
+        """
+        return int(os.getenv("HYDROLIX_SEND_RECEIVE_TIMEOUT", "300"))
+
+    def get_client_config(self) -> dict:
+        """Get the configuration dictionary for clickhouse_connect client.
+
+        Returns:
+            dict: Configuration ready to be passed to clickhouse_connect.get_client()
+        """
+        config = {
+            "host": self.host,
+            "port": self.port,
+            "username": self.username,
+            "password": self.password,
+            "secure": True,
+            "verify": self.verify,
+            "connect_timeout": self.connect_timeout,
+            "send_receive_timeout": self.send_receive_timeout,
+            "client_name": "mcp_hydrolix",
+        }
+
+        # Add optional database if set
+        if self.database:
+            config["database"] = self.database
+
+        return config
+
+    def _validate_required_vars(self) -> None:
+        """Validate that all required environment variables are set.
+
+        Raises:
+            ValueError: If any required environment variable is missing.
+        """
+        missing_vars = []
+        for var in ["HYDROLIX_HOST", "HYDROLIX_USER", "HYDROLIX_PASSWORD"]:
+            if var not in os.environ:
+                missing_vars.append(var)
+
+        if missing_vars:
+            raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
+
+
+# Global instance for easy access
+config = HydrolixConfig()

mcp_hydrolix/mcp_server.py

@@ -0,0 +1,232 @@
+import logging
+from typing import Sequence
+import concurrent.futures
+import atexit
+
+import clickhouse_connect
+from clickhouse_connect.driver.binding import quote_identifier, format_query_value
+from dotenv import load_dotenv
+from mcp.server.fastmcp import FastMCP
+
+from mcp_hydrolix.mcp_env import config
+
+MCP_SERVER_NAME = "mcp-hydrolix"
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(MCP_SERVER_NAME)
+
+QUERY_EXECUTOR = concurrent.futures.ThreadPoolExecutor(max_workers=10)
+atexit.register(lambda: QUERY_EXECUTOR.shutdown(wait=True))
+SELECT_QUERY_TIMEOUT_SECS = 30
+
+load_dotenv()
+
+deps = [
+    "clickhouse-connect",
+    "python-dotenv",
+    "uvicorn",
+    "pip-system-certs",
+]
+
+mcp = FastMCP(MCP_SERVER_NAME, dependencies=deps)
+
+
+@mcp.tool()
+def list_databases():
+    """List available Hydrolix databases"""
+    logger.info("Listing all databases")
+    client = create_hydrolix_client()
+    result = client.command("SHOW DATABASES")
+    logger.info(f"Found {len(result) if isinstance(result, list) else 1} databases")
+    return result
+
+
+@mcp.tool()
+def list_tables(database: str, like: str = None):
+    """List available Hydrolix tables in a database"""
+    logger.info(f"Listing tables in database '{database}'")
+    client = create_hydrolix_client()
+    query = f"SHOW TABLES FROM {quote_identifier(database)}"
+    if like:
+        query += f" LIKE {format_query_value(like)}"
+    result = client.command(query)
+
+    # Get all table comments in one query
+    table_comments_query = (
+        f"SELECT name, comment FROM system.tables WHERE database = {format_query_value(database)}"
+    )
+    table_comments_result = client.query(table_comments_query)
+    table_comments = {row[0]: row[1] for row in table_comments_result.result_rows}
+
+    # Get all column comments in one query
+    column_comments_query = f"SELECT table, name, comment FROM system.columns WHERE database = {format_query_value(database)}"
+    column_comments_result = client.query(column_comments_query)
+    column_comments = {}
+    for row in column_comments_result.result_rows:
+        table, col_name, comment = row
+        if table not in column_comments:
+            column_comments[table] = {}
+        column_comments[table][col_name] = comment
+
+    def get_table_info(table):
+        logger.info(f"Getting schema info for table {database}.{table}")
+        schema_query = f"DESCRIBE TABLE {quote_identifier(database)}.{quote_identifier(table)}"
+        schema_result = client.query(schema_query)
+
+        columns = []
+        column_names = schema_result.column_names
+        for row in schema_result.result_rows:
+            column_dict = {}
+            for i, col_name in enumerate(column_names):
+                column_dict[col_name] = row[i]
+            # Add comment from our pre-fetched comments
+            if table in column_comments and column_dict["name"] in column_comments[table]:
+                column_dict["comment"] = column_comments[table][column_dict["name"]]
+            else:
+                column_dict["comment"] = None
+            columns.append(column_dict)
+
+        create_table_query = f"SHOW CREATE TABLE {database}.`{table}`"
+        create_table_result = client.command(create_table_query)
+
+        return {
+            "database": database,
+            "name": table,
+            "comment": table_comments.get(table),
+            "columns": columns,
+            "create_table_query": create_table_result,
+        }
+
+    tables = []
+    if isinstance(result, str):
+        # Single table result
+        for table in (t.strip() for t in result.split()):
+            if table:
+                tables.append(get_table_info(table))
+    elif isinstance(result, Sequence):
+        # Multiple table results
+        for table in result:
+            tables.append(get_table_info(table))
+
+    logger.info(f"Found {len(tables)} tables")
+    return tables
+
+
+def execute_query(query: str):
+    client = create_hydrolix_client()
+    try:
+        res = client.query(
+            query,
+            settings={
+                "readonly": 1,
+                "hdx_query_max_execution_time": SELECT_QUERY_TIMEOUT_SECS,
+                "hdx_query_max_attempts": 1,
+                "hdx_query_max_result_rows": 100_000,
+                "hdx_query_max_memory_usage": 2 * 1024 * 1024 * 1024,  # 2GiB
+                "hdx_query_admin_comment": f"User: {MCP_SERVER_NAME}",
+            },
+        )
+        column_names = res.column_names
+        rows = []
+        for row in res.result_rows:
+            row_dict = {}
+            for i, col_name in enumerate(column_names):
+                row_dict[col_name] = row[i]
+            rows.append(row_dict)
+        logger.info(f"Query returned {len(rows)} rows")
+        return rows
+    except Exception as err:
+        logger.error(f"Error executing query: {err}")
+        # Return a structured dictionary rather than a string to ensure proper serialization
+        # by the MCP protocol. String responses for errors can cause BrokenResourceError.
+        return {"error": str(err)}
+
+
+@mcp.tool()
+def run_select_query(query: str):
+    """Run a SELECT query in a Hydrolix time-series database using the Clickhouse SQL dialect.
+    Queries run using this tool will timeout after 30 seconds.
+
+    The primary key on tables queried this way is always a timestamp. Queries should include either
+    a LIMIT clause or a filter based on the primary key as a performance guard to ensure they return
+    in a reasonable amount of time. Queries should select specific fields and avoid the use of
+    SELECT * to avoid performance issues. The performance guard used for the query should be clearly
+    communicated with the user, and the user should be informed that the query may take a long time
+    to run if the performance guard is not used. When choosing a performance guard, the user's
+    preference should be requested and used if available. When using aggregations, the performance
+    guard should take form of a primary key filter, or else the LIMIT should be applied in a
+    subquery before applying the aggregations.
+
+    When matching columns based on substrings, prefix or suffix matches should be used instead of
+    full-text search whenever possible. When searching for substrings, the syntax `column LIKE
+    '%suffix'` or `column LIKE 'prefix%'` should be used.
+
+    Example query. Purpose: get logs from the `application.logs` table. Primary key: `timestamp`.
+    Performance guard: 10 minute recency filter.
+
+    `SELECT message, timestamp FROM application.logs WHERE timestamp > now() - INTERVAL 10 MINUTES`
+
+    Example query. Purpose: get the median humidity from the `weather.measurements` table. Primary
+    key: `date`. Performance guard: 1000 row limit, applied before aggregation.
+
+     `SELECT median(humidity) FROM (SELECT humidity FROM weather.measurements LIMIT 1000)`
+
+    Example query. Purpose: get the lowest temperature from the `weather.measurements` table over
+    the last 10 years. Primary key: `date`. Performance guard: date range filter.
+
+    `SELECT min(temperature) FROM weather.measurements WHERE date > now() - INTERVAL 10 YEARS`
+
+    Example query. Purpose: get the app name with the most log messages from the `application.logs`
+    table in the window between new year and valentine's day of 2024. Primary key: `timestamp`.
+    Performance guard: date range filter.
+     `SELECT app, count(*) FROM application.logs WHERE timestamp > '2024-01-01' AND timestamp < '2024-02-14' GROUP BY app ORDER BY count(*) DESC LIMIT 1`
+    """
+    logger.info(f"Executing SELECT query: {query}")
+    try:
+        future = QUERY_EXECUTOR.submit(execute_query, query)
+        try:
+            result = future.result(timeout=SELECT_QUERY_TIMEOUT_SECS)
+            # Check if we received an error structure from execute_query
+            if isinstance(result, dict) and "error" in result:
+                logger.warning(f"Query failed: {result['error']}")
+                # MCP requires structured responses; string error messages can cause
+                # serialization issues leading to BrokenResourceError
+                return {"status": "error", "message": f"Query failed: {result['error']}"}
+            return result
+        except concurrent.futures.TimeoutError:
+            logger.warning(f"Query timed out after {SELECT_QUERY_TIMEOUT_SECS} seconds: {query}")
+            future.cancel()
+            # Return a properly structured response for timeout errors
+            return {
+                "status": "error",
+                "message": f"Query timed out after {SELECT_QUERY_TIMEOUT_SECS} seconds",
+            }
+    except Exception as e:
+        logger.error(f"Unexpected error in run_select_query: {str(e)}")
+        # Catch all other exceptions and return them in a structured format
+        # to prevent MCP serialization failures
+        return {"status": "error", "message": f"Unexpected error: {str(e)}"}
+
+
+def create_hydrolix_client():
+    client_config = config.get_client_config()
+    logger.info(
+        f"Creating Hydrolix client connection to {client_config['host']}:{client_config['port']} "
+        f"as {client_config['username']} "
+        f"(secure={client_config['secure']}, verify={client_config['verify']}, "
+        f"connect_timeout={client_config['connect_timeout']}s, "
+        f"send_receive_timeout={client_config['send_receive_timeout']}s)"
+    )
+
+    try:
+        client = clickhouse_connect.get_client(**client_config)
+        # Test the connection
+        version = client.server_version
+        logger.info(f"Successfully connected to Hydrolix server version {version}")
+        return client
+    except Exception as e:
+        logger.error(f"Failed to connect to Hydrolix: {str(e)}")
+        raise

mcp_hydrolix-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: mcp-hydrolix
+Version: 0.1.0
+Summary: An MCP server for Hydrolix.
+Project-URL: Home, https://github.com/hydrolix/mcp-hydrolix
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: clickhouse-connect>=0.8.0
+Requires-Dist: mcp[cli]>=1.3.0
+Requires-Dist: pip-system-certs>=4.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: uvicorn>=0.34.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Hydrolix MCP Server
+[![PyPI - Version](https://img.shields.io/pypi/v/mcp-hydrolix)](https://pypi.org/project/mcp-hydrolix)
+
+An MCP server for Hydrolix.
+
+## Features
+
+### Tools
+
+* `run_select_query`
+  - Execute SQL queries on your Hydrolix cluster.
+  - Input: `sql` (string): The SQL query to execute.
+  - All Hydrolix queries are run with `readonly = 1` to ensure they are safe.
+
+* `list_databases`
+  - List all databases on your Hydrolix cluster.
+
+* `list_tables`
+  - List all tables in a database.
+  - Input: `database` (string): The name of the database.
+
+## Configuration
+
+1. Open the Claude Desktop configuration file located at:
+   - On macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
+
+2. Add the following:
+
+```json
+{
+  "mcpServers": {
+    "mcp-hydrolix": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--with",
+        "mcp-hydrolix",
+        "--python",
+        "3.13",
+        "mcp-hydrolix"
+      ],
+      "env": {
+        "HYDROLIX_HOST": "<hydrolix-host>",
+        "HYDROLIX_PORT": "<hydrolix-port>",
+        "HYDROLIX_USER": "<hydrolix-user>",
+        "HYDROLIX_PASSWORD": "<hydrolix-password>",
+        "HYDROLIX_SECURE": "true",
+        "HYDROLIX_VERIFY": "true",
+        "HYDROLIX_CONNECT_TIMEOUT": "30",
+        "HYDROLIX_SEND_RECEIVE_TIMEOUT": "30"
+      }
+    }
+  }
+}
+```
+
+Update the environment variables to point to your own Hydrolix service.
+
+3. Locate the command entry for `uv` and replace it with the absolute path to the `uv` executable. This ensures that the correct version of `uv` is used when starting the server. On a mac, you can find this path using `which uv`.
+
+4. Restart Claude Desktop to apply the changes.
+
+### Environment Variables
+
+The following environment variables are used to configure the Hydrolix connection:
+
+#### Required Variables
+* `HYDROLIX_HOST`: The hostname of your Hydrolix server
+* `HYDROLIX_USER`: The username for authentication
+* `HYDROLIX_PASSWORD`: The password for authentication
+
+#### Optional Variables
+* `HYDROLIX_PORT`: The port number of your Hydrolix server
+  - Default: `8088`
+  - Usually doesn't need to be set unless using a non-standard port
+* `HYDROLIX_VERIFY`: Enable/disable SSL certificate verification
+  - Default: `"true"`
+  - Set to `"false"` to disable certificate verification (not recommended for production)
+* `HYDROLIX_CONNECT_TIMEOUT`: Connection timeout in seconds
+  - Default: `"30"`
+  - Increase this value if you experience connection timeouts
+* `HYDROLIX_SEND_RECEIVE_TIMEOUT`: Send/receive timeout in seconds
+  - Default: `"300"`
+  - Increase this value for long-running queries
+* `HYDROLIX_DATABASE`: Default database to use
+  - Default: None (uses server default)
+  - Set this to automatically connect to a specific database

mcp_hydrolix-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+mcp_hydrolix/__init__.py,sha256=DnAQkvoFf_QhrDNFLOmn-nHlldPUgtdN33k3xJWthgc,225
+mcp_hydrolix/main.py,sha256=WTZcvpIas2mIjNd_em7KWlXI_6IXZAdtdlQ7czmX1cs,96
+mcp_hydrolix/mcp_env.py,sha256=PIMxbhImiSGs4PaqrvEFXjA7wkr2AwEMkjCnKPyMEZg,4091
+mcp_hydrolix/mcp_server.py,sha256=EFkFy0658H0Fspo0e7oHiQNsWzBcP7tAcU0fo11iHz8,9813
+mcp_hydrolix-0.1.0.dist-info/METADATA,sha256=KZRd6hGV42Hcx_DIM6TGbbzkEaSLP2ovHtHpuyO-0aY,3368
+mcp_hydrolix-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_hydrolix-0.1.0.dist-info/entry_points.txt,sha256=vHa7F2rOCVu8lpsqR8BYbE1w8ugJSOYwX95w802Y5qE,56
+mcp_hydrolix-0.1.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+mcp_hydrolix-0.1.0.dist-info/RECORD,,

mcp_hydrolix-0.1.0.dist-info/WHEEL

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

mcp_hydrolix-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-hydrolix = mcp_hydrolix.main:main

mcp_hydrolix-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.