lovelytics-cli 0.4.3__py3-none-any.whl

love/__main__.py

@@ -0,0 +1,5 @@
+"""Main method to support debugging."""
+if __name__ == "__main__":
+    from .cli import cli
+
+    cli()

love/auth.py

@@ -0,0 +1,169 @@
+"""Code to handle retrieving and storing authentication."""
+import requests
+import json
+from love.config import HEIMDALL_URL, AUTH_FILE_PATH, CONFIG_PATH
+import time
+import os
+import webbrowser
+
+
+class AuthHandler:
+    """Handles authentication for the application."""
+
+    def __init__(self):
+        """Initialize the AuthHandler."""
+        pass
+
+    @staticmethod
+    def login(user=None, token=None, org=None):
+        """
+        Handle logging in and storing authentication.
+
+        Goes through OIDC device flow to retreive login info.
+        """
+        if user and token:
+            payload = {
+                "username": user,
+                "password": token,
+            }
+            if org:
+                payload["orgId"] = org
+
+            res = requests.post(
+                f"{HEIMDALL_URL}/api/users/login-with-pat",
+                data=payload,
+            )
+            res.raise_for_status()
+            data = res.json()
+            email = data["data"]["email"]
+            jwt = data["token"]
+
+        else:
+            client_id = "love-cli"
+            res = requests.post(
+                f"{HEIMDALL_URL}/oidc/device/auth",
+                data={"client_id": client_id, "scope": "openid profile"},
+            )
+            res.raise_for_status()
+            data = res.json()
+            print(
+                f"Please visit {data['verification_uri_complete']} and enter code {data['user_code']} to login to Lovelytics Labs."
+            )
+            print("Opening browser...")
+            webbrowser.open(data["verification_uri_complete"])
+
+            authenticated = False
+            access_token = None
+            while not authenticated:
+                token_res = requests.post(
+                    f"{HEIMDALL_URL}/oidc/token",
+                    data={
+                        "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                        "device_code": data["device_code"],
+                        "client_id": client_id,
+                    },
+                )
+                token_data = token_res.json()
+                if token_res.status_code == 200:
+                    authenticated = True
+                    access_token = token_data["access_token"]
+
+                elif token_data["error"] not in ("authorization_pending", "slow_down"):
+                    print(token_data["error_description"])
+                    raise Exception(token_data["error_description"])
+
+                else:
+                    time.sleep(5)
+
+            exchange_res = requests.post(
+                f"{HEIMDALL_URL}/api/users/login-with-oidc",
+                headers={"Authorization": f"Bearer {access_token}"},
+            )
+            exchange_res.raise_for_status()
+            exchange_data = exchange_res.json()
+            email = exchange_data["data"]["email"]
+            jwt = exchange_data["token"]
+
+        os.makedirs(CONFIG_PATH, exist_ok=True)
+        with open(AUTH_FILE_PATH, "w") as f:
+            json.dump(
+                {
+                    "email": email,
+                    "token": jwt,
+                },
+                f,
+            )
+        print("Login successful.")
+
+    @staticmethod
+    def get_auth():
+        """
+        Get existing authentication.
+
+        Handle retrieving existing authentication from the auth file
+        or from an exported token.
+        """
+        if os.getenv("LOVELYTICS_USERNAME") and os.getenv("LOVELYTICS_TOKEN"):
+            payload = {
+                "username": os.environ["LOVELYTICS_USERNAME"],
+                "password": os.environ["LOVELYTICS_TOKEN"],
+            }
+            res = requests.post(
+                f"{HEIMDALL_URL}/api/users/login-with-pat",
+                data=payload,
+            )
+            res.raise_for_status()
+            data = res.json()
+            email = data["data"]["email"]
+            jwt = data["token"]
+            auth = {
+                "email": email,
+                "token": jwt,
+            }
+        elif os.getenv("LOVELYTICS_ORG") and os.getenv("LOVELYTICS_TOKEN"):
+            payload = {
+                "orgId": os.environ["LOVELYTICS_ORG"],
+                "token": os.environ["LOVELYTICS_TOKEN"],
+            }
+            res = requests.post(
+                f"{HEIMDALL_URL}/api/organization/login-with-token",
+                data=payload,
+            )
+            res.raise_for_status()
+            data = res.json()
+            jwt = data["token"]
+            auth = {
+                "orgId": os.environ["LOVELYTICS_ORG"],
+                "token": jwt,
+            }
+
+        else:
+            try:
+                with open(AUTH_FILE_PATH) as f:
+                    auth = json.load(f)
+
+            except FileNotFoundError:
+                raise Exception(
+                    "Not logged in. Please run 'love login' to log in to your account."
+                )
+
+        return auth
+
+    @staticmethod
+    def get_me():
+        """Get current user info."""
+        token = AuthHandler.get_auth()["token"]
+        res = requests.post(
+            f"{HEIMDALL_URL}/api/users/authenticated/me",
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        res.raise_for_status()
+        return res.json()
+
+    def store_auth(self):
+        """Store the authentication for the application."""
+        pass
+
+    def refresh_auth(self):
+        """Refresh the authentication for the application."""
+        pass

love/cli.py

@@ -0,0 +1,170 @@
+"""Definition of the CLI."""
+import subprocess  # nosec
+import click
+from love import auth
+from love import linguo as linguo_commands
+from love import forecast as forecast_commands
+import json
+import logging
+import click_log
+import os
+import urllib3
+from love.config import (
+    AIRFLOW_HOME,
+    SPARK_HOME,
+    CONFIG_OPTIONS,
+    CONFIG_PATH,
+    CONFIG_FILE_PATH,
+    LANDO_URL,
+)
+
+logger = logging.getLogger(__name__)
+click_log.basic_config(logger)
+
+
+@click.group()
+@click_log.simple_verbosity_option(logger)
+@click.pass_context
+def cli(ctx):
+    """Run the main CLI entry point."""
+    logger.debug("Setting environment variables.")
+    os.environ["AIRFLOW_HOME"] = AIRFLOW_HOME
+    os.environ["SPARK_HOME"] = SPARK_HOME
+    os.environ[
+        "AIRFLOW__CORE__SQL_ALCHEMY_CONN"
+    ] = "postgresql+psycopg2://postgres:postgres@localhost:5433/postgres"
+    if not os.path.exists(CONFIG_PATH):
+        logger.info(
+            "This appears to be your first time running 'love'. Setting some things up for you."
+        )
+        logger.info("Creating config file.")
+        os.makedirs(CONFIG_PATH, exist_ok=True)
+        config = dict()
+        for k, v in CONFIG_OPTIONS.items():
+            if v.get("default_value"):
+                config[k] = v["default_value"]
+        with open(CONFIG_FILE_PATH, "w") as f:
+            json.dump(config, f)
+
+
+@cli.group()
+def config():
+    """Manage configuration for the CLI."""
+    pass
+
+
+@config.command()
+@click.argument("config_name")
+@click.argument("config_value")
+def set(config_name, config_value):
+    """Set the appropriate config value."""
+    if config_name not in CONFIG_OPTIONS.keys():
+        raise click.ClickException(f"{config_name} is not a valid config value.")
+
+    with open(CONFIG_FILE_PATH, "r") as f:
+        config = json.load(f)
+    config[config_name] = config_value
+    with open(CONFIG_FILE_PATH, "w") as f:
+        json.dump(config, f)
+
+
+@cli.group()
+def linguo():
+    """Entrypoint for Linguo commands."""
+    pass
+
+
+@linguo.command()
+@click.argument(
+    "target_table",
+)
+def sql(target_table):
+    """Command for Linguo SQL generation."""
+    linguo_commands.mapping_sql(target_table)
+
+
+@cli.group()
+def df():
+    """Entrypoint for demand forecasting commands."""
+    pass
+
+
+@df.command(
+    name="run",
+)
+@click.option("--config", "-c", help="A JSON string of the forecast config.")
+@click.option(
+    "--config-file", "-f", help="A path to a JSON file of the forecast config."
+)
+def run_forecast(config, config_file):
+    """Command for running forecasts."""
+    if not config and not config_file:
+        raise click.ClickException("Must provide either --config or --config-file.")
+
+    if config:
+        config = json.loads(config)
+
+    if config_file:
+        with open(config_file) as f:
+            config = json.load(f)
+
+    forecast_commands.run(config)
+
+
+@cli.group()
+def install():
+    """Entrypoint for install commands."""
+    pass
+
+
+@install.command()
+@click.argument("package")
+def python_package(package):
+    """Install a package from our private repository."""
+    click.echo(f"Installing {package} from our private repository...")
+    user = auth.AuthHandler.get_auth()
+    protocol = "https" if LANDO_URL.startswith("https") else "http"
+    base_url = LANDO_URL.strip("https://").strip("http://")
+    index_url = (
+        f"{protocol}://lovelytics:{user['token']}@{base_url}/python"  # noqa: E231
+    )
+    encoded_url = urllib3.util.parse_url(index_url).url
+    subprocess.run(  # nosec
+        ["pip", "install", "--extra-index-url", encoded_url, package]
+    )
+
+
+@cli.command()
+@click.option("--user", help="A user to user for login.")
+@click.option("--token", help="An access token to use for login.")
+@click.option("--org", help="An organization ID to use for login.")
+def login(user, token, org):
+    """Login interactively to Lovelytics Labs."""
+    auth.AuthHandler.login(user, token, org)
+
+
+@cli.command()
+def me():
+    """Get info about the currently authenticated user."""
+    user_info = auth.AuthHandler.get_me()
+    if "email" in user_info["data"]:
+        click.echo(
+            json.dumps(
+                {
+                    "id": user_info["data"]["_id"],
+                    "email": user_info["data"]["email"],
+                    "firsName": user_info["data"]["firstName"],
+                    "lastName": user_info["data"]["lastName"],
+                    "isAdmin": user_info["data"]["isAdmin"],
+                }
+            )
+        )
+    else:
+        click.echo(
+            json.dumps(
+                {
+                    "orgId": user_info["data"]["orgId"],
+                    "tokenId": user_info["data"]["tokenId"],
+                }
+            )
+        )

love/config.py

@@ -0,0 +1,32 @@
+"""Configuration values for the CLI."""
+import os
+
+CONFIG_PATH = os.path.join(os.path.expanduser("~"), ".lovelytics")
+CONFIG_FILE_PATH = os.path.join(CONFIG_PATH, "config.json")
+AUTH_FILE_PATH = os.path.join(CONFIG_PATH, ".auth.json")
+LIB_PATH = os.path.abspath(os.path.join(CONFIG_PATH, "lib"))
+SPARK_HOME = os.path.join(LIB_PATH, "pyspark")
+AIRFLOW_HOME = os.path.join(CONFIG_PATH, "airflow")
+LAKEHOUSE_PATH = os.path.join(CONFIG_PATH, "lakehouse")
+POSTGRES_PATH = os.path.join(CONFIG_PATH, "postgres")
+AWS_PATH = os.path.join(os.path.expanduser("~"), ".aws")
+AWS_CRED_PATH = os.path.join(AWS_PATH, "sso", "cache")
+DBT_PROFILE_DIR = os.path.join(CONFIG_PATH, "profiles")
+LANDO_URL = os.getenv("LANDO_URL", "https://landoapi.saas.lovelytics.com")
+HEIMDALL_URL = os.getenv("HEIMDALL_URL", "https://heimdall.lovelytics.com")
+GATEWAY_URL = os.getenv("GATEWAY_URL", "https://api.lovelytics.com")
+
+CONFIG_OPTIONS = {
+    "runtime": {
+        "valid_values": ["native", "docker"],
+        "default_value": "docker",
+    },
+    "spark_version": {
+        "valid_values": [
+            "3.1",
+            "3.2",
+            "3.3",
+        ],
+        "default_value": "3.3",
+    },
+}

love/forecast.py

@@ -0,0 +1,24 @@
+"""Artifacts for forecasting commands."""
+import logging
+import os
+import requests
+from love.auth import AuthHandler
+
+
+API_URL = os.getenv("LOVE_API_URL", "https://api.lovelytics.com")
+logger = logging.getLogger(__name__)
+
+
+def run(forecast_config):
+    """Run a forecast with the specified config."""
+    logger.info("Running forecast with given config.")
+    token = AuthHandler.get_auth()["token"]
+    headers = {"Authorization": f"Bearer {token}"}
+    res = requests.post(
+        f"{API_URL}/solutions/scf/forecasts", json=forecast_config, headers=headers
+    )
+
+    if res.status_code != 201:
+        raise Exception(f"Error running forecast: {res.text}")
+
+    print(f"Forecast started with ID {res.json()['forecastID']}.")

love/linguo.py

@@ -0,0 +1,76 @@
+"""Artifacts for interacting with Linguo."""
+import logging
+from love.auth import AuthHandler
+import requests
+from love.config import GATEWAY_URL
+import yaml
+import os
+
+
+logger = logging.getLogger(__name__)
+
+
+def parse_target(target_table):
+    """Parse the target table."""
+    if "." in target_table:
+        model, table = target_table.split(".")
+    else:
+        raise Exception("Target table must be in the format <model>.<table>.")
+
+    return model, table
+
+
+def check_dbt_project():
+    """Check if the local directory is a dbt project."""
+    print("Parsing dbt project file.")
+    dbt_project_file = os.path.join(os.getcwd(), "dbt_project.yml")
+    if not os.path.exists(dbt_project_file):
+        raise Exception("Current directory is not a dbt project.")
+
+    with open(dbt_project_file, "r") as f:
+        dbt_project = yaml.safe_load(f)
+
+    return dbt_project
+
+
+def get_dbt_schema(dbt_project, model):
+    """Get the dbt schema for the given model."""
+    print("Getting dbt schema.")
+    model_path = dbt_project["model-paths"][0]
+    with open(os.path.join(os.getcwd(), model_path, model, "schema.yml"), "r") as f:
+        schema_file = yaml.safe_load(f)
+
+    return schema_file
+
+
+def mapping_sql(target_table):
+    """
+    Generate a SQL mapping.
+
+    Infers source data from tables in the warehouse
+    and generates a SQL mapping to the given target table.
+    """
+    model, table = parse_target(target_table)
+    dbt_project = check_dbt_project()
+    schema = get_dbt_schema(dbt_project, model)
+    print(f"Parsing source tables from dbt schema for {model}.")
+    raw_tables = schema["sources"][0]["tables"]
+    target = list(filter(lambda x: x["name"] == table, schema["models"]))[0]
+    print(f"Parsing target table {target_table}.")
+    print("Calling Linguo to generate target SQL.")
+    token = AuthHandler.get_auth()["token"]
+    res = requests.post(
+        f"{GATEWAY_URL}/v2/linguo/mapping/sql",
+        json={"sources": raw_tables, "target": target},
+        headers={"Authorization": f"Bearer {token}"},
+    )
+    data = res.json()
+    print("Generating a table according to the following logic:")
+    print(data["description"])
+    print("Writing to SQL file.")
+    model_path = dbt_project["model-paths"][0]
+    sql_path = os.path.join(os.getcwd(), model_path, model, f"{table}.sql")
+    with open(sql_path, "w") as f:
+        f.write(data["sql_code"])
+
+    print(f"Successfully wrote SQL to {sql_path}.")

love/utils.py

@@ -0,0 +1,67 @@
+"""Reusable utilities for the CLI."""
+import botocore
+from love.config import SPARK_HOME, CONFIG_PATH, POSTGRES_PATH
+import base64
+import docker
+import boto3
+
+
+def get_docker_client():
+    """Retrieve a Docker client with proper auth."""
+    try:
+        docker_client = docker.from_env()
+    except docker.errors.DockerException:
+        print("ERROR: Failed to connect to Docker. Is Docker running?")
+        exit(1)
+    ecr_client = boto3.client("ecr", region_name="us-east-2")
+
+    try:
+        token = ecr_client.get_authorization_token()["token"]
+        username, password = (
+            base64.b64decode(token["authorizationData"][0]["authorizationToken"])
+            .decode()
+            .split(":")
+        )
+        registry = token["authorizationData"][0]["proxyEndpoint"]
+    except botocore.exceptions.NoCredentialsError:
+        print("ERROR: Could not find AWS credentials. Are you logged into AWS?")
+        exit(1)
+
+    docker_client.login(username, password, registry=registry)
+    return docker_client
+
+
+def check_and_run(
+    docker_client,
+    *args,
+    wait=True,
+    ignore_existing=False,
+    skip_if_exists=False,
+    **kwargs,
+):
+    """Check for an existing container and rerun."""
+    try:
+        networks = docker_client.networks.list(names=["nousot"])
+        network = networks[0]
+    except (docker.errors.NotFound, IndexError):
+        network = docker_client.networks.create("nousot", driver="bridge")
+
+    kwargs["network"] = network.name
+    container_name = f"nousot_{kwargs['name']}"
+    kwargs["name"] = container_name
+    kwargs["auto_remove"] = not skip_if_exists
+    if not ignore_existing:
+        try:
+            print(f"Searching for container {container_name}.")
+            container = docker_client.containers.get(container_name)
+            if skip_if_exists:
+                return
+            else:
+                container.stop()
+        except docker.errors.NotFound:
+            print("Container not running.")
+    container = docker_client.containers.run(*args, **kwargs)
+    if wait:
+        for line in container.logs(stream=True):
+            print(line.decode().strip())
+    return container

lovelytics_cli-0.4.3.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: lovelytics-cli
+Version: 0.4.3
+Summary: Development tools for Lovelytics Labs.
+License: LICENSE
+License-File: LICENSE
+Author: Lovelytics Labs
+Author-email: labs@lovelytics.com
+Requires-Python: >=3.10.0,<3.14
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+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: boto3 (>=1.26.11,<2.0.0)
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: click-log (>=0.4.0,<0.5.0)
+Requires-Dist: docker (>=6.0.1,<7.0.0)
+Requires-Dist: pyyaml (>=6.0.0,<6.1.0)
+Requires-Dist: requests (>=2.32.0,<3.0.0)
+Requires-Dist: virtualenv (>=20.17.0,<21.0.0)
+Description-Content-Type: text/markdown
+
+# love-cli
+Developer command line interface for the Lovelytics Labs.
+

lovelytics_cli-0.4.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+love/__main__.py,sha256=e7K3l74_UvZUv6tARPVSiEgJaGzWkkBvzQTwloTLQF0,103
+love/auth.py,sha256=kpRDZA0ZRGDXbCtDPT2JKxPuSNtD-Dayv2_jFDTWgGU,5441
+love/cli.py,sha256=z9ZSVuOHsngU2T2y2-BsLnm5V5IVtixbg5S5_ocWG7o,4702
+love/config.py,sha256=nwY_s9y8rvFnPRpSvCziz6qSTec6FwEkWPN3Obd2HNU,1176
+love/forecast.py,sha256=raJ9zwzW4f3tY0v3Ur8q-4ql95l4j98Jz-8XA-VQgXc,730
+love/linguo.py,sha256=L_FweST5Cn1Juwmurgg9UPNpmSGveXKAAUs74Mt_9is,2441
+love/utils.py,sha256=TjhGPJeJ6RwSHJa03zHEZSZjG38vBBHntzzJrqun5vA,2159
+lovelytics_cli-0.4.3.dist-info/METADATA,sha256=bbEgZ_USzVGtTSR2zGzVRkekNk6kPPwAjMJjxkVzGs8,933
+lovelytics_cli-0.4.3.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+lovelytics_cli-0.4.3.dist-info/entry_points.txt,sha256=mPPt1m9xjnyw2km8-I2YYT9t3I-a2w0Gblfhla3kLEo,37
+lovelytics_cli-0.4.3.dist-info/licenses/LICENSE,sha256=5U_thn-lPwMgmZ0f0uMOONoLpqdxwkNA2-TSsbOEA2Q,4744
+lovelytics_cli-0.4.3.dist-info/RECORD,,

lovelytics_cli-0.4.3.dist-info/WHEEL

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

lovelytics_cli-0.4.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+love=love.cli:cli
+

lovelytics_cli-0.4.3.dist-info/licenses/LICENSE

@@ -0,0 +1,116 @@
+PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 Lovelytics, LLC. All rights reserved.
+
+NOTICE: This software and its source code are the exclusive property of
+Lovelytics, LLC ("Licensor") and are protected by copyright law and
+international treaties.
+
+ACCEPTANCE OF TERMS
+
+BY INSTALLING, COPYING, OR OTHERWISE USING THIS SOFTWARE, LICENSEE
+AGREES TO BE BOUND BY THE TERMS OF THIS LICENSE. IF LICENSEE DOES NOT
+AGREE TO THESE TERMS, LICENSEE MUST NOT INSTALL OR USE THE SOFTWARE.
+
+1. GRANT OF LICENSE
+
+   Subject to the terms of this License, Licensor grants the recipient
+   ("Licensee") a limited, non-exclusive, non-transferable, non-sublicensable
+   license to install and use this software solely for Licensee's internal
+   business purposes in connection with Licensee's authorized engagement
+   with Licensor.
+
+2. RESTRICTIONS
+
+   Licensee shall not, and shall not permit any third party to:
+
+   a) copy, reproduce, distribute, publish, or otherwise transfer this
+      software or any portion thereof to any third party;
+
+   b) sublicense, sell, rent, lease, or otherwise commercially exploit
+      this software;
+
+   c) use, incorporate, or adapt this software or any portion thereof
+      in any other product, project, or software;
+
+   d) reverse engineer, decompile, disassemble, or attempt to derive
+      the source code of any compiled portion of this software, except
+      as expressly permitted by applicable law;
+
+   e) remove, alter, or obscure any proprietary notices, labels, or
+      marks on or in this software.
+
+3. TERMINATION
+
+   This License is effective until terminated. It terminates immediately
+   and automatically, without notice, upon the cessation of Licensee's
+   authorized engagement with Licensor. Upon termination, Licensee will
+   no longer receive updates, patches, or new versions of the software.
+   Licensee may retain and continue to use only the version(s) of the
+   software obtained during the term of its authorized engagement with
+   Licensor, subject to all remaining terms of this License.
+
+4. CONFIDENTIALITY
+
+   Licensee acknowledges that the software, including its design, interfaces,
+   and connection to Licensor's internal systems, constitutes confidential
+   information of Licensor ("Confidential Information"). Licensee shall:
+
+   a) hold the Confidential Information in strict confidence using at least
+      the same degree of care it uses to protect its own confidential
+      information, but no less than reasonable care;
+
+   b) not disclose the Confidential Information to any third party without
+      the prior written consent of Licensor;
+
+   c) limit access to the Confidential Information to those of its employees
+      or contractors who have a need to know and are bound by confidentiality
+      obligations no less restrictive than those in this License.
+
+   These obligations survive termination of this License.
+
+5. OWNERSHIP
+
+   This software is licensed, not sold. Licensor retains all right, title,
+   and interest in and to the software, including all intellectual property
+   rights therein. No title or ownership of the software is transferred
+   to Licensee under this License.
+
+6. NO WARRANTIES
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
+   LICENSOR DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR-FREE OR
+   UNINTERRUPTED.
+
+7. LIMITATION OF LIABILITY
+
+   IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN
+   CONNECTION WITH THIS LICENSE OR THE USE OF THE SOFTWARE, EVEN IF
+   ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+8. SEVERABILITY AND WAIVER
+
+   If any provision of this License is held to be invalid, illegal, or
+   unenforceable under applicable law, that provision shall be modified to
+   the minimum extent necessary to make it enforceable, or if modification
+   is not possible, severed from this License. The remaining provisions
+   shall continue in full force and effect. The failure of either party to
+   enforce any right or provision of this License shall not constitute a
+   waiver of that right or provision.
+
+9. GOVERNING LAW
+
+   This License shall be governed by and construed in accordance with the
+   laws of the State of Washington, United States of America, without regard
+   to its conflict of law provisions.
+
+10. ENTIRE AGREEMENT
+
+   This License constitutes the entire agreement between the parties with
+   respect to the subject matter hereof and supersedes all prior and
+   contemporaneous understandings.
+
+For licensing inquiries, contact: loveyourdata@lovelytics.com