kubernetes-watch 0.1.0__py3-none-any.whl

kube_watch/modules/providers/git.py

@@ -0,0 +1,33 @@
+import os
+from git import Repo
+
+from prefect import get_run_logger
+
+logger = get_run_logger()
+
+def clone_repo(git_pat, git_url, clone_base_path):
+    # Retrieve environment variables
+    access_token = git_pat # os.environ.get('GIT_PAT')
+    repo_url = git_url # os.environ.get('GIT_URL')
+    
+    if not access_token or not repo_url:
+        raise ValueError("Environment variables GIT_PAT or GIT_URL are not set")
+
+    # Correctly format the URL with the PAT
+    if 'https://' in repo_url:
+        # Splitting the URL and inserting the PAT
+        parts = repo_url.split('https://', 1)
+        repo_url = f'https://{access_token}@{parts[1]}'
+    else:
+        raise ValueError("URL must begin with https:// for PAT authentication")
+
+    # Directory where the repo will be cloned
+    repo_path = os.path.join(clone_base_path, 'manifest-repo')
+
+    # Clone the repository
+    if not os.path.exists(repo_path):
+        logger.info(f"Cloning repository into {repo_path}")
+        repo = Repo.clone_from(repo_url, repo_path)
+        logger.info("Repository cloned successfully.")
+    else:
+        logger.info(f"Repository already exists at {repo_path}")

kube_watch/modules/providers/github.py

@@ -0,0 +1,126 @@
+import requests
+from datetime import datetime, timedelta
+import pytz
+
+from prefect import get_run_logger
+
+logger = get_run_logger()
+
+def parse_datetime(dt_str):
+    """Parse a datetime string into a datetime object."""
+    return datetime.strptime(dt_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=pytz.UTC)
+
+
+def add_version_dependency(versions):
+    """
+    Finds untagged versions that were created within 2 minutes of any tagged version.
+
+    Args:
+    versions (list of dict): List of dictionaries, each containing 'created_at' and possibly 'tags'.
+
+    Returns:
+    list: A list of untagged versions that meet the criteria.
+    """
+    tagged_versions = [v for v in versions if v['metadata']['container']['tags']]
+    untagged_versions = [v for v in versions if not v['metadata']['container']['tags']]
+
+    # Convert all creation times to datetime objects
+    for v in versions:
+        v['created_datetime'] = parse_datetime(v['created_at'])
+
+    # Check each untagged version against all tagged versions
+    for v in versions:
+        if v in untagged_versions:
+            for tagged in tagged_versions:
+                time_diff = abs(tagged['created_datetime'] - v['created_datetime'])
+                if time_diff < timedelta(minutes=2):
+                    v['tag'] = tagged['tag']
+                    break  # Stop checking once a close tagged version is found
+
+    return versions
+
+
+def get_github_package_versions(token, organization, package_type, package_name):
+    """
+    This function returns all available versions in a github package registry `ghcr`.
+
+    :param: token: GitHub token with proper permissions
+    :param: organization: GitHub organization name
+    :param: package_type: GitHub package type (e.g. container, npm)
+    :param: package_name: GitHub package name
+    """
+    base_url = f"https://api.github.com/orgs/{organization}/packages/{package_type}/{package_name}/versions"
+    headers = {
+        'Authorization': f'token {token}',
+        'Accept': 'application/vnd.github.v3+json'
+    }
+    versions = []
+    url = base_url
+
+    while url:
+        logger.info(f"Requesting: {url}")  # Debug output to check the URL being requested
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            page_versions = response.json()
+            versions.extend(page_versions)
+            link_header = response.headers.get('Link', None)
+            if link_header:
+                links = {rel.split('; ')[1][5:-1]: rel.split('; ')[0][1:-1] for rel in link_header.split(', ')}
+                url = links.get("next", None)  # Get the URL for the next page
+                if url:
+                    logger.info(f"Next page link found: {url}")  # Debug output to check the next page link
+                else:
+                    logger.info("No next page link found in header.")  # End of pagination
+            else:
+                logger.info("No 'Link' header present, likely the last page.")  # If no 'Link' header, it's the last page
+                url = None
+        else:
+            logger.error(f"Failed to retrieve package versions: {response.status_code}, {response.text}")
+            url = None
+            
+    for item in versions:
+        tags = item['metadata']['container']['tags']
+        item['tag'] = tags[0] if len(tags) > 0 else None
+        
+    return versions
+
+
+def delete_versions(versions, token, organization, package_type, package_name):
+    """
+    :param: versions: list of versions to be deleted
+    :param: token: GitHub token with proper permissions
+    :param: organization: GitHub organization name
+    :param: package_type: GitHub package type (e.g. container, npm)
+    :param: package_name: GitHub package name
+    """
+    headers = {
+        'Authorization': f'token {token}',
+        'Accept': 'application/vnd.github.v3+json'
+    }
+    for version in versions:
+        delete_url = f"https://api.github.com/orgs/{organization}/packages/{package_type}/{package_name}/versions/{version['id']}"
+        response = requests.delete(delete_url, headers=headers)
+        if response.status_code == 204:
+            logger.info(f"Successfully deleted version: {version['metadata']['container']['tags']} (ID: {version['id']})")
+        else:
+            logger.info(f"Failed to delete version: {version['metadata']['container']['tags']} (ID: {version['id']}), {response.status_code}, {response.text}")
+
+
+
+def delete_untaged_versions(versions, token, organization, package_type, package_name):
+    # Identifying untagged versions that are related to a tagged version
+    untag_test = list(filter(lambda ver: ver['tag'] is None, versions))
+    logger.info(f"UNTAGGED BEFORE: {len(untag_test)}")
+    versions   = add_version_dependency(versions)
+    untag_vers = list(filter(lambda ver: ver['tag'] is None, versions))
+    logger.info(f"UNTAGGED BEFORE: {len(untag_vers)}")
+    
+    delete_versions(untag_vers, token, organization, package_type, package_name)
+
+
+def task_get_latest_image_digest(versions, tag_name):
+    lst = list(filter(lambda ver: ver['tag'] == tag_name, versions))
+    if len(lst) == 0:
+        raise ValueError(f"Provided tag: {tag_name} was not found.")
+    
+    return lst[0]['name']

kube_watch/modules/providers/vault.py

@@ -0,0 +1,113 @@
+import hvac
+import os
+from prefect import get_run_logger
+
+from kube_watch.enums.providers import Providers
+
+logger = get_run_logger()
+
+def login(url, app_role_id, secret_id, path):
+    """
+    Login to Vault, using an existing token if available, or via AppRole otherwise.
+    
+    Parameters:
+        url (str): Vault server URL.
+        app_role_id (str): AppRole ID.
+        secret_id (str): AppRole Secret ID.
+        path (str): Path where the AppRole is enabled.
+
+    Returns:
+        dict: Dictionary containing the initialized vault_client.
+    """
+    vault_client = hvac.Client(url=url)
+    
+    # Attempt to use an existing token from environment variables
+    vault_token = os.getenv('VAULT_TOKEN', None)
+    if vault_token:
+        vault_client.token = vault_token
+        # Verify if the current token is still valid
+        try:
+            if vault_client.is_authenticated():
+                logger.info("Authenticated with existing token.")
+                return vault_client
+        except hvac.exceptions.InvalidRequest as e:
+            logger.warning("Failed to authenticate with the existing token:", str(e))
+
+    # If token is not valid or not present, authenticate with AppRole
+    try:
+        vault_client.auth.approle.login(
+            role_id=app_role_id, 
+            secret_id=secret_id, 
+            mount_point=f'approle/{path}'
+        )
+        
+        # Store the new token in environment variables for subsequent use
+        os.environ['VAULT_TOKEN'] = vault_client.token
+        logger.info("Authenticated with new token and stored in environment variable.")
+
+        return vault_client
+    except hvac.exceptions.InvalidRequest as e:
+        logger.error("Authentication failed with provided secret_id:", str(e))
+        raise RuntimeError("Authentication failed: unable to log in with the provided credentials.") from e
+
+
+
+def get_secret(vault_client, secret_path, vault_mount_point):
+    """
+    Retrieve a secret from Vault
+    """
+    res = vault_client.secrets.kv.v2.read_secret_version(
+        path=secret_path,
+        mount_point=vault_mount_point,
+        raise_on_deleted_version=True
+    )
+    return res.get('data', {}).get('data')
+
+
+def update_secret(vault_client, secret_path, secret_data, vault_mount_point):
+    """
+    Update or create a secret in Vault at the specified path.
+    
+    Args:
+        vault_client: The authenticated Vault client instance.
+        secret_path (str): The path where the secret will be stored or updated in Vault.
+        secret_data (dict): The secret data to store as a dictionary.
+        vault_mount_point (str): The mount point for the KV store.
+
+    Returns:
+        bool: True if the operation was successful, False otherwise.
+    """
+    try:
+        # Writing the secret data to Vault at the specified path
+        vault_client.secrets.kv.v2.create_or_update_secret(
+            path=secret_path,
+            secret=secret_data,
+            mount_point=vault_mount_point
+        )
+        print("Secret updated successfully.")
+        return True
+    except Exception as e:
+        print(f"Failed to update secret: {e}")
+        return False
+
+def generate_provider_creds(vault_client, provider, backend_path, role_name):
+        """
+        Generate credentials for a specified provider 
+        """
+        if provider == Providers.AWS:
+            backend_path = backend_path
+            role_name = role_name
+            creds_path = f"{backend_path}/creds/{role_name}"
+            return vault_client.read(creds_path)
+
+        raise ValueError("Unknown provider")
+
+
+
+def generate_new_secret_id(vault_client, role_name, vault_path, env_var_name):
+    new_secret_response = vault_client.auth.approle.generate_secret_id(
+        role_name=role_name,
+        mount_point=f'approle/{vault_path}'
+    )
+
+    return { env_var_name : new_secret_response['data']['secret_id'] }

kube_watch/standalone/metarecogen/ckan_to_gn.py

@@ -0,0 +1,132 @@
+import requests
+# from pathlib import Path
+import os
+import sys
+
+"""
+A simple script to:
+    1. Retrieve all public records from a CKAN service
+    2. Insert CKAN records into a Geonetwork service
+
+This requires the 'iso19115' extension to be installed in CKAN and the following env. vars:
+    1. 'CKAN2GN_GN_USERNAME' geonetwork username for an account that can create records
+    2. 'CKAN2GN_GN_PASSWORD' geonetwork password for an account that can create records
+    3. 'CKAN2GN_GN_URL' geonetork service URL
+    4. 'CKAN2GN_CKAN_URL' CKAN service URL
+"""
+
+# Geonetwork username and password:
+GN_USERNAME = os.environ.get('CKAN2GN_GN_USERNAME')
+GN_PASSWORD = os.environ.get('CKAN2GN_GN_PASSWORD')
+
+# Geonetwork and CKAN server URLs
+GN_URL = os.environ.get('CKAN2GN_GN_URL')
+CKAN_URL = os.environ.get('CKAN2GN_CKAN_URL')
+
+def get_gn_xsrf_token(session):
+    """ Retrieves XSRF token from Geonetwork
+
+    :param session: requests Session object
+    :returns: XSRF as string or None upon error
+    """
+    authenticate_url = GN_URL + '/geonetwork/srv/eng/info?type=me'
+    response = session.post(authenticate_url)
+
+    # Extract XRSF token
+    xsrf_token = response.cookies.get("XSRF-TOKEN")
+    if xsrf_token:
+        return xsrf_token
+    return None
+
+def list_ckan_records():
+    """ Contacts CKAN and retrieves a list of package ids for all public records
+
+    :returns: list of package id strings or None upon error
+    """
+    session = requests.Session()
+    url_path =  'api/3/action/package_list' # Path('api') / '3' / 'action' / 'package_list'
+    url = f'{CKAN_URL}/{url_path}'
+    r = session.get(url)
+    resp = r.json()
+    if resp['success'] is False:
+        return None
+    return resp['result']
+
+def get_ckan_record(package_id):
+    """ Given a package id retrieves its record metadata
+
+    :param package_id: CKAN package_id string
+    :returns: package metadata as a dict or None upon error
+    """
+    session = requests.Session()
+    # Set up CKAN URL
+    url_path =  'api/3/action/iso19115_package_show' #  Path('api') / '3' / 'action' / 'iso19115_package_show'
+    url = f'{CKAN_URL}/{url_path}'
+    r = session.get(url, params={'format':'xml', 'id':package_id})
+    resp = r.json()
+    if resp['success'] is False:
+        return None
+    return resp['result']
+    
+
+def insert_gn_record(session, xsrf_token, xml_string):
+    """ Inserts a record into Geonetwork
+
+    :param session: requests Session object
+    :param xsrf_token: Geonetwork's XSRF token as a string
+    :param xml_string: XML to be inserted as a string
+    :returns: True or False if insert succeeded
+    """
+    # Set header for connection
+    headers = {'Accept': 'application/json',
+               'Content-Type': 'application/xml',
+               'X-XSRF-TOKEN': xsrf_token
+    }
+
+    # Set the parameters
+    # Currently 'uuidProcessing' is set to 'NOTHING' so that records that
+    # already exist are rejected by Geonetwork as duplicates
+    params = {'metadataType': 'METADATA',
+              'publishToAll': 'true',
+              'uuidProcessing': 'NOTHING',  # Available values : GENERATEUUID, NOTHING, OVERWRITE
+    }
+
+    # Send a put request to the endpoint to create record
+    response = session.put(GN_URL + '/geonetwork/srv/api/0.1/records',
+                        data=xml_string,
+                        params=params,
+                        auth=(GN_USERNAME, GN_PASSWORD),
+                        headers=headers
+    )
+    resp = response.json()
+
+    # Check if record was created in Geonetwork
+    if response.status_code == requests.codes['created'] and resp['numberOfRecordsProcessed'] == 1 and \
+            resp['numberOfRecordsWithErrors'] == 0:
+        print("Inserted")
+        return True
+    print(f"Insert failed: status code: {response.status_code}\n{resp}")
+    return False
+        
+
+if __name__ == "__main__":
+    # Check env. vars
+    if GN_USERNAME is None or GN_PASSWORD is None or GN_URL is None or CKAN_URL is None:
+        print("Please define the following env. vars:")
+        print("           'CKAN2GN_GN_USERNAME' 'CKAN2GN_GN_PASSWORD' 'CKAN2GN_GN_URL' 'CKAN2GN_CKAN_URL'")
+        sys.exit(1)
+    # Connect to server
+    session = requests.Session()
+    xsrf = get_gn_xsrf_token(session)
+    if xsrf is not None:
+        # Get records from CKAN
+        for id in list_ckan_records():
+            print(f"Inserting '{id}'")
+            xml_string = get_ckan_record(id)
+            if xml_string is not None:
+                # Insert GN record
+                insert_gn_record(session, xsrf, xml_string)
+            else:
+                print(f"Could not get record id {id} from CKAN")
+
+    

kube_watch/watch/__init__.py

@@ -0,0 +1 @@
+from .workflow import single_run_workflow, batch_run_workflow

kube_watch/watch/helpers.py

@@ -0,0 +1,126 @@
+from prefect import task
+import functools
+import asyncio
+from prefect.task_runners import ConcurrentTaskRunner, SequentialTaskRunner
+# from prefect_dask.task_runners import DaskTaskRunner
+from typing import Dict, List
+import yaml
+import importlib
+import os
+from kube_watch.models.workflow import WorkflowConfig, BatchFlowConfig, Task
+from kube_watch.enums.workflow import ParameterType, TaskRunners, TaskInputsType
+from kube_watch.modules.logic.merge import merge_logical_list
+
+def load_workflow_config(yaml_file) -> WorkflowConfig:
+    with open(yaml_file, 'r') as file:
+        data = yaml.safe_load(file)
+    return WorkflowConfig(**data['workflow'])
+
+
+def load_batch_config(yaml_file) -> BatchFlowConfig:
+    with open(yaml_file, 'r') as file:
+        data = yaml.safe_load(file)
+    return BatchFlowConfig(**data['batchFlows'])
+
+
+
+# def execute_task(func, *args, name="default_task_name", **kwargs):
+#     @task(name=name)
+#     def func_task():
+#         return func(*args, **kwargs)
+#     return func_task
+
+
+def func_task(name="default_task_name", task_input_type: TaskInputsType = TaskInputsType.ARG):
+    if task_input_type == TaskInputsType.ARG:
+        @task(name=name)
+        def execute_task(func, *args, **kwargs):
+            return func(*args, **kwargs)
+        return execute_task
+    if task_input_type == TaskInputsType.DICT:
+        @task(name=name)
+        def execute_task(func, dict_inp):
+            return func(dict_inp)
+        return execute_task
+    raise ValueError(f'Unknow Task Input Type. It should either be {TaskInputsType.ARG} or {TaskInputsType.DICT} but {task_input_type} is provided.')
+
+
+# @task
+# def execute_task(func, *args, **kwargs):
+#     return func(*args, **kwargs)
+
+
+
+def get_task_function(module_name, task_name):
+    # module = importlib.import_module(f"sparrow_watch.modules.{module_name}")
+    # klass = getattr(module, class_name)
+    # return getattr(klass, task_name)
+    """
+    Fetch a function directly from a specified module.
+    
+    Args:
+        module_name (str): The name of the module to import the function from. e.g. providers.aws
+        task_name (str): The name of the function to fetch from the module.
+        
+    Returns:
+        function: The function object fetched from the module.
+    """
+    module = importlib.import_module(f"kube_watch.modules.{module_name}")
+    return getattr(module, task_name)
+
+
+
+def resolve_parameter_value(param):
+    if param.type == ParameterType.FROM_ENV:
+        return os.getenv(param.value, '')  # Default to empty string if env var is not set
+    return param.value
+
+def prepare_task_inputs(parameters):
+    return {param.name: resolve_parameter_value(param) for param in parameters}
+
+
+def prepare_task_inputs_from_dep(task_data: Task, task_inputs: Dict, tasks):
+    for dep in task_data.dependency:
+        par_task   = tasks[dep.taskName]
+        par_res    = par_task.result()
+        if dep.inputParamName != None:
+            task_inputs.update({dep.inputParamName: par_res})
+
+    return task_inputs
+
+
+def resolve_conditional(task_data: Task, tasks):
+    lst_bools = []
+    for task_name in task_data.conditional.tasks:
+        if task_name not in tasks:
+            return False
+        
+        par_task   = tasks[task_name]
+        lst_bools.append(par_task.result())
+    return merge_logical_list(lst_bools, task_data.conditional.operation)
+    
+
+
+
+def submit_task(task_name, task_data, task_inputs, func):
+    execute_task = func_task(name=task_name, task_input_type=task_data.inputsArgType)
+    if task_data.inputsArgType == TaskInputsType.ARG:
+        return execute_task.submit(func, **task_inputs)
+    if task_data.inputsArgType == TaskInputsType.DICT:
+        return execute_task.submit(func, dict_inp=task_inputs)
+    raise ValueError("Unknown Input Arg Type.")
+
+
+
+def resolve_runner(runner):
+    if runner == TaskRunners.CONCURRENT:
+        return ConcurrentTaskRunner
+    if runner == TaskRunners.SEQUENTIAL:
+        return SequentialTaskRunner
+    if runner == TaskRunners.DASK:
+        raise ValueError("Dask Not Implemented")
+        # return DaskTaskRunner
+    if runner == TaskRunners.RAY:
+        raise ValueError("Ray Not Implemented")
+        # return RayTaskRunner
+    raise ValueError("Invalid task runner type")

kube_watch/watch/workflow.py

@@ -0,0 +1,107 @@
+from prefect import flow,  get_run_logger
+import asyncio
+from typing import List
+import secrets
+import os
+import kube_watch.watch.helpers as helpers
+from kube_watch.models.workflow import WorkflowOutput
+from kube_watch.enums.workflow import TaskRunners, TaskInputsType
+
+
+# @TODO: CONCURRENCY DOES NOT WORK PROPERLY AT FLOW LEVEL
+def create_flow_based_on_config(yaml_file, run_async=True):
+    workflow_config = helpers.load_workflow_config(yaml_file)
+    flow_name       = workflow_config.name
+    runner          = helpers.resolve_runner(workflow_config.runner)
+    random_suffix   = secrets.token_hex(6)
+    flow_run_name   = f"{flow_name} - {random_suffix}"
+
+    @flow(name=flow_name, flow_run_name=flow_run_name, task_runner=runner)
+    async def dynamic_workflow():
+        logger = get_run_logger()
+        tasks = {}
+        logger.info(f"Starting flow: {flow_name}")
+        for task_data in workflow_config.tasks:
+            task_name   = task_data.name
+            func        = helpers.get_task_function(task_data.module, task_data.task)
+            task_inputs = helpers.prepare_task_inputs(task_data.inputs.parameters) if task_data.inputs else {}
+
+            condition_result = True
+            if task_data.conditional:
+                condition_result = helpers.resolve_conditional(task_data, tasks)
+
+            if condition_result:
+                # Resolve dependencies only if the task is going to be executed
+                if task_data.dependency:
+                    task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
+                
+                task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
+                tasks[task_data.name] = task_future
+            
+            # if task_data.dependency:
+            #     task_inputs = helpers.prepare_task_inputs_from_dep(task_data, task_inputs, tasks)
+        
+            # if task_data.conditional:
+            #     condition_result  = helpers.resolve_conditional(task_data, tasks)
+            #     if condition_result:
+            #         task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
+            #         tasks[task_data.name] = task_future
+            # else:
+            #     task_future = helpers.submit_task(task_name, task_data, task_inputs, func)
+            #     tasks[task_data.name] = task_future
+
+        return tasks
+    return dynamic_workflow
+
+
+# SINGLE
+def single_run_workflow(yaml_file, return_state=True) -> WorkflowOutput:
+    dynamic_flow  = create_flow_based_on_config(yaml_file, run_async=False)
+    flow_run = dynamic_flow(return_state=return_state)
+    return WorkflowOutput(**{'flow_run': flow_run, 'config': dynamic_flow}) 
+
+
+# BATCH
+
+@flow(name="Batch Workflow Runner - Sequential")
+def batch_run_sequential(batch_config, batch_dir) -> List[WorkflowOutput]:
+    # batch_config = helpers.load_batch_config(batch_yaml_file)
+    # batch_dir = os.path.dirname(batch_yaml_file)
+    flows = []
+    for item in batch_config.items:
+        yaml_file_path = os.path.join(batch_dir, item.path)
+        output = single_run_workflow(yaml_file_path, return_state = True)
+        flows.append(output)
+
+    return flows
+
+# @TODO: CONCURRENCY DOES NOT WORK PROPERLY AT FLOW LEVEL
+@flow(name="Batch Workflow Runner - Concurrent")
+async def batch_run_concurrent(batch_config, batch_dir) -> List[WorkflowOutput]:
+    # Asynchronous flow run submissions
+    flow_runs = []
+    for item in batch_config.items:
+        yaml_file_path = os.path.join(batch_dir, item.path)
+        # Here you create flow runs but do not await them yet
+        flow_function = create_flow_based_on_config(yaml_file_path, run_async=True)
+        flow_run_future = flow_function(return_state=True)  # Ensure this is submitted asynchronously
+        flow_runs.append(flow_run_future)
+        is_async = asyncio.iscoroutinefunction(flow_function)
+
+
+    # Await all flow runs to finish concurrently
+    results = await asyncio.gather(*flow_runs)
+    return [WorkflowOutput(**{'flow_run': result, 'config': flow_function}) for result, flow_function in zip(results, flow_runs)]
+
+
+def batch_run_workflow(batch_yaml_file):
+    batch_config = helpers.load_batch_config(batch_yaml_file)
+    batch_dir = os.path.dirname(batch_yaml_file)
+
+    if batch_config.runner == TaskRunners.SEQUENTIAL:
+        return batch_run_sequential(batch_config, batch_dir)
+    
+    if batch_config.runner == TaskRunners.CONCURRENT:
+        return asyncio.run(batch_run_concurrent(batch_config, batch_dir))
+
+    raise ValueError('Invalid flow runner type')

kubernetes_watch-0.1.0.dist-info/LICENSE

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