lovelytics-cli 0.4.3__tar.gz → 0.4.8__tar.gz

{lovelytics_cli-0.4.3 → lovelytics_cli-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lovelytics-cli
-Version: 0.4.3
+Version: 0.4.8
 Summary: Development tools for Lovelytics Labs.
 License: LICENSE
 License-File: LICENSE

lovelytics_cli-0.4.8/love/auth.py

@@ -0,0 +1,155 @@
+"""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_with_pat(user, token, org=None):
+        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()
+
+        auth_data = {"email": data["data"]["email"], "token": data["token"]}
+        if org:
+            auth_data["orgId"] = org
+        return auth_data
+
+    @staticmethod
+    def _login_with_org_token(org, token):
+        res = requests.post(
+            f"{HEIMDALL_URL}/api/organization/login-with-token",
+            data={"orgId": org, "token": token},
+        )
+        res.raise_for_status()
+        data = res.json()
+        return {"orgId": org, "token": data["token"]}
+
+    @staticmethod
+    def _login_with_oidc():
+        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()
+        return {
+            "email": exchange_data["data"]["email"],
+            "token": exchange_data["token"],
+        }
+
+    @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:
+            auth_data = AuthHandler._login_with_pat(user, token, org)
+        elif org and token:
+            auth_data = AuthHandler._login_with_org_token(org, token)
+        else:
+            auth_data = AuthHandler._login_with_oidc()
+
+        os.makedirs(CONFIG_PATH, exist_ok=True)
+        with open(AUTH_FILE_PATH, "w") as f:
+            json.dump(auth_data, 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"):
+            return AuthHandler._login_with_pat(
+                os.environ["LOVELYTICS_USERNAME"],
+                os.environ["LOVELYTICS_TOKEN"],
+            )
+        elif os.getenv("LOVELYTICS_ORG") and os.getenv("LOVELYTICS_TOKEN"):
+            return AuthHandler._login_with_org_token(
+                os.environ["LOVELYTICS_ORG"],
+                os.environ["LOVELYTICS_TOKEN"],
+            )
+        else:
+            try:
+                with open(AUTH_FILE_PATH) as f:
+                    return json.load(f)
+            except FileNotFoundError:
+                raise Exception(
+                    "Not logged in. Please run 'love login' to log in to your account."
+                )
+
+    @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

{lovelytics_cli-0.4.3 → lovelytics_cli-0.4.8}/love/cli.py

@@ -1,21 +1,21 @@
 """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
+from love import crate as crate_commands
+from love import install as install_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,
+    CRATE_CACHE_DIR,
 )
 
 logger = logging.getLogger(__name__)
@@ -121,17 +121,94 @@ def install():
 @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]
-    )
+    install_commands.install_python_package(package)
+
+
+@install.command(name="cli-tool")
+@click.argument("name")
+@click.option(
+    "--force", is_flag=True, default=False, help="Overwrite existing installation."
+)
+def cli_tool(name, force):
+    """Install a CLI tool binary from CodeArtifact via the Lando proxy."""
+    install_commands.install_cli_tool(name, force)
+
+
+# We use the name solution to reference to crates as it is more user-firendly
+@install.command(name="solution")
+@click.argument("crate_name")
+@click.option(
+    "--params-file",
+    "-p",
+    default=None,
+    help="Path to a YAML or JSON file containing parameters for the solution installation.",
+)
+@click.option(
+    "--download",
+    "-d",
+    is_flag=True,
+    default=False,
+    help="Force re-download of the solution even if a cached version exists.",
+)
+def install_crate(crate_name, params_file, download):
+    """Install a solution from CodeArtifact.
+
+    Downloads and installs the specified solution from the Lovelytics CodeArtifact
+    repository via Lando. Parameters can be provided via a config file (--params-file) and/or
+    environment variables prefixed with CRATE_ (e.g., CRATE_CATALOG_NAME). Environment
+    variables take precedence over values in the config file.
+
+    Downloaded solution archives are cached under ~/.lovelytics/crates/. Use --download
+    to force a fresh download even when a cached archive exists.
+    """
+    import subprocess  # nosec
+    import tempfile
+
+    # Load parameters from file and CRATE_ env vars
+    click.echo("Loading parameters...")
+    params = crate_commands.load_params(params_file)
+    if params:
+        click.echo(f"Loaded parameters: {list(params.keys())}")
+
+    click.echo(f"Installing solution '{crate_name}'...")
+
+    archive_path = crate_commands.get_cached_archive_path(crate_name)
+
+    if os.path.exists(archive_path) and not download:
+        click.echo(f"Using cached solution archive: {archive_path}")
+    else:
+        # Authenticate using JWT from love login (only needed for download)
+        user = auth.AuthHandler.get_auth()
+        jwt_token = user["token"]
+
+        os.makedirs(CRATE_CACHE_DIR, exist_ok=True)
+        click.echo("Downloading solution from CodeArtifact...")
+        crate_commands.download_crate(crate_name, CRATE_CACHE_DIR, jwt_token)
+        click.echo(f"Downloaded archive: {archive_path}")
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # Extract the crate archive
+        click.echo("Extracting solution...")
+        crate_path = crate_commands.extract_crate(archive_path, tmp_dir)
+        click.echo(f"Extracted to: {crate_path}")
+
+        # Ensure the crate binary is available
+        click.echo("Checking for solution binary...")
+        crate_bin = crate_commands.ensure_crate_binary()
+        click.echo(f"Using crate binary at: {crate_bin}")
+
+        # Build and run the crate install command
+        args = crate_commands.build_crate_install_args(crate_path, params)
+        cmd = [crate_bin, "install"] + args
+        click.echo(f"Running: {' '.join(cmd)}")
+
+        result = subprocess.run(cmd)  # nosec
+        if result.returncode != 0:
+            raise click.ClickException(
+                f"Solution installation failed with exit code {result.returncode}."
+            )
+
+    click.echo(f"Successfully installed solution '{crate_name}'.")
 
 
 @cli.command()

{lovelytics_cli-0.4.3 → lovelytics_cli-0.4.8}/love/config.py

@@ -30,3 +30,14 @@ CONFIG_OPTIONS = {
         "default_value": "3.3",
     },
 }
+
+# CodeArtifact configuration for crate downloads
+CODEARTIFACT_DOMAIN = "nousot"
+CODEARTIFACT_DOMAIN_OWNER = "316967775432"
+CODEARTIFACT_REPOSITORY = "common"
+CODEARTIFACT_NAMESPACE = "crates"
+
+# Crate binary configuration
+CRATE_BINARY_NAME = "crate"
+CRATE_INSTALL_DIR = os.path.join(os.path.expanduser("~"), ".local", "bin")
+CRATE_CACHE_DIR = os.path.join(CONFIG_PATH, "crates")

lovelytics_cli-0.4.8/love/crate.py

@@ -0,0 +1,163 @@
+"""Core logic for installing crates from CodeArtifact."""
+
+import json
+import logging
+import os
+import shutil
+import tarfile
+from typing import Optional
+
+import click
+import requests
+import yaml
+
+from love.config import (
+    CODEARTIFACT_NAMESPACE,
+    CRATE_BINARY_NAME,
+    CRATE_CACHE_DIR,
+    CRATE_INSTALL_DIR,
+    LANDO_URL,
+)
+
+logger = logging.getLogger(__name__)
+
+# Crate configuration - only CRATE_ENV_VAR_PREFIX is defined here as it's only used in this module
+CRATE_ENV_VAR_PREFIX = "CRATE_"
+
+# Mapping of parameter keys to crate binary CLI flags
+PARAM_FLAG_MAP = {
+    "catalog_name": "--catalog-name",
+    "sql_warehouse_id": "--sql-warehouse-id",
+    "instance_id": "--instance-id",
+    "deployed_by": "--deployed-by",
+}
+
+
+def get_cached_archive_path(name: str) -> str:
+    """Return the path where a named crate archive is/should be cached."""
+    return os.path.join(CRATE_CACHE_DIR, f"{name}.tar.gz")
+
+
+def download_crate(name: str, dest_dir: str, jwt_token: str) -> str:
+    """Download a crate archive via Lando's registry proxy."""
+    dest_path = os.path.join(dest_dir, f"{name}.tar.gz")
+
+    url = f"{LANDO_URL}/{CODEARTIFACT_NAMESPACE}/{name}"
+    try:
+        resp = requests.get(
+            url,
+            auth=("lovelytics", jwt_token),
+            stream=True,
+            timeout=120,
+        )
+        resp.raise_for_status()
+    except requests.RequestException as e:
+        raise click.ClickException(f"Failed to download crate '{name}': {e}")
+
+    try:
+        with open(dest_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                f.write(chunk)
+    except Exception as e:
+        raise click.ClickException(f"Error saving crate archive to {dest_path}: {e}")
+
+    return dest_path
+
+
+def extract_crate(archive_path: str, dest_dir: str) -> str:
+    """Extract a crate tar.gz archive to the destination directory."""
+    try:
+        with tarfile.open(archive_path, "r:gz") as tar:
+            members = tar.getnames()
+            if not members:
+                raise click.ClickException(f"Archive '{archive_path}' is empty.")
+            top_level_dir = members[0].split("/")[0]
+            tar.extractall(dest_dir)  # nosec
+
+        return os.path.join(dest_dir, top_level_dir)
+    except tarfile.TarError as e:
+        raise click.ClickException(f"Failed to extract archive '{archive_path}': {e}")
+    except click.ClickException:
+        raise
+    except Exception as e:
+        raise click.ClickException(f"Unexpected error extracting '{archive_path}': {e}")
+
+
+def load_params(params_file: Optional[str] = None) -> dict:
+    """Load crate parameters from a file and/or environment variables.
+
+    Parameters from environment variables (prefixed with CRATE_) take
+    precedence over values loaded from the file.
+
+    Raises a ClickException if no parameters are found from either source.
+    """
+    params = {}
+
+    if params_file is not None:
+        try:
+            with open(params_file, "r") as f:
+                content = f.read()
+        except (OSError, IOError) as e:
+            raise click.ClickException(
+                f"Failed to read params file '{params_file}': {e}"
+            )
+
+        try:
+            parsed = yaml.safe_load(content)
+        except yaml.YAMLError:
+            try:
+                parsed = json.loads(content)
+            except json.JSONDecodeError:
+                raise click.ClickException(
+                    f"Failed to parse params file '{params_file}' as YAML or JSON."
+                )
+
+        if isinstance(parsed, dict):
+            params.update(parsed)
+
+    for key, value in os.environ.items():
+        if key.startswith(CRATE_ENV_VAR_PREFIX):
+            param_key = key[len(CRATE_ENV_VAR_PREFIX) :].lower()
+            if param_key:
+                params[param_key] = value
+
+    if not params:
+        raise click.ClickException(
+            "No crate parameters were found. Please provide parameters via a params file "
+            "(--params-file) or environment variables prefixed with 'CRATE_'."
+        )
+
+    return params
+
+
+def ensure_crate_binary() -> str:
+    """Ensure the crate binary is available, raising an error if not found."""
+    existing = shutil.which(CRATE_BINARY_NAME)
+    if existing:
+        return existing
+
+    local_bin_path = os.path.join(CRATE_INSTALL_DIR, CRATE_BINARY_NAME)
+    if os.path.isfile(local_bin_path) and os.access(local_bin_path, os.X_OK):
+        return local_bin_path
+
+    raise click.ClickException(
+        f"Crate binary '{CRATE_BINARY_NAME}' not found. "
+        f"Please install it and ensure it is available in your PATH or at '{local_bin_path}'."
+    )
+
+
+def build_crate_install_args(source_path: str, params: dict) -> list:
+    """Build the list of CLI arguments for the crate install command."""
+    args = ["--path", source_path]
+
+    for key, value in params.items():
+        flag = PARAM_FLAG_MAP.get(key)
+        if flag:
+            args.extend([flag, str(value)])
+        else:
+            logger.warning(
+                f"Ignoring unrecognized parameter '{key}' "
+                f"(no matching crate CLI flag)."
+            )
+
+    return args

lovelytics_cli-0.4.8/love/install.py

@@ -0,0 +1,142 @@
+"""Logic for downloading and installing CLI tools and packages."""
+import os
+import platform
+import shutil
+import subprocess  # nosec
+import tarfile
+import tempfile
+
+import click
+import requests
+import urllib3
+
+from love import auth
+from love.config import LANDO_URL
+
+
+def get_platform_asset(name):
+    """Determine the platform-specific asset filename for the given tool name."""
+    system = platform.system()
+    machine = platform.machine()
+
+    if system == "Linux" and machine == "x86_64":
+        return f"{name}-linux-amd64.tar.gz"
+    elif system == "Darwin" and machine == "arm64":
+        return f"{name}-darwin-arm64.tar.gz"
+    else:
+        raise click.ClickException(
+            f"Unsupported platform: {system} {machine}. "
+            "Supported platforms: Linux x86_64, macOS ARM64."
+        )
+
+
+def get_platform_info():
+    """Determine the platform-specific os and arch values."""
+    system = platform.system()
+    machine = platform.machine()
+
+    if system == "Linux" and machine == "x86_64":
+        return ("linux", "amd64")
+    elif system == "Darwin" and machine == "arm64":
+        return ("darwin", "arm64")
+    else:
+        raise click.ClickException(
+            f"Unsupported platform: {system} {machine}. "
+            "Supported platforms: Linux x86_64, macOS ARM64."
+        )
+
+
+def get_installed_version(install_path):
+    """Run the binary with --version and return the version string, or None."""
+    try:
+        result = subprocess.run(  # nosec
+            [install_path, "--version"],
+            capture_output=True,
+            text=True,
+        )
+        output = (result.stdout + result.stderr).strip()
+        return output if output else None
+    except (FileNotFoundError, OSError):
+        return None
+
+
+def install_cli_tool(name, force):
+    """Download and install a CLI tool binary from CodeArtifact via the Lando proxy."""
+    os_name, arch = get_platform_info()
+    local_bin = os.path.expanduser("~/.local/bin")
+    install_path = os.path.join(local_bin, name)
+
+    if os.path.exists(install_path) and not force:
+        version = get_installed_version(install_path)
+        click.echo(
+            f"{name} is already installed (version: {version}). "
+            "Use --force to overwrite."
+        )
+        return
+
+    auth_info = auth.AuthHandler.get_auth()
+
+    click.echo(f"Downloading {name}...")
+    download_url = f"{LANDO_URL}/cli/{name}?os={os_name}&arch={arch}"
+    res = requests.get(  # nosec
+        download_url,
+        auth=("lovelytics", auth_info["token"]),
+        stream=True,
+        timeout=300,
+    )
+    if not res.ok:
+        raise click.ClickException(f"Failed to download {name}: HTTP {res.status_code}")
+
+    tmp_tarball = tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False)
+    try:
+        for chunk in res.iter_content(chunk_size=8192):
+            tmp_tarball.write(chunk)
+        tmp_tarball.close()
+
+        tmp_dir = tempfile.mkdtemp()
+        try:
+            click.echo(f"Unpacking {name}...")
+            with tarfile.open(tmp_tarball.name, "r:gz") as tar:
+                members = [m for m in tar.getmembers() if m.isfile()]
+                if not members:
+                    raise click.ClickException(
+                        f"No files found in the tarball for '{name}'."
+                    )
+                binary_member = members[0]
+
+                tar.extract(binary_member, path=tmp_dir)
+                extracted_path = os.path.join(tmp_dir, binary_member.name)
+
+            click.echo(f"Installing {name}...")
+            os.makedirs(local_bin, exist_ok=True)
+            shutil.copy2(extracted_path, install_path)
+            os.chmod(install_path, 0o755)  # nosec
+        finally:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+    finally:
+        os.unlink(tmp_tarball.name)
+
+    if local_bin not in os.environ.get("PATH", ""):
+        click.echo(
+            "WARNING: ~/.local/bin is not on your PATH. "
+            "Add the following to your shell profile:\n"
+            '  export PATH="$HOME/.local/bin:$PATH"'
+        )
+
+    version = get_installed_version(install_path)
+    click.echo(f"{name} {version} installed successfully.")
+
+
+def install_python_package(package):
+    """Download and install a Python package from the 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]
+    )

{lovelytics_cli-0.4.3 → lovelytics_cli-0.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "lovelytics-cli"
-version = "0.4.3"
+version = "0.4.8"
 description = "Development tools for Lovelytics Labs."
 authors = ["Lovelytics Labs <labs@lovelytics.com>"]
 readme = "README.md"
@@ -23,6 +23,9 @@ pre-commit = "^2.20.0"
 pytest = "^7.2.0"
 flake8 = "^5.0.4"
 twine = "^6.2.0"
+pydocstyle = "^6.3.0"
+bandit = "^1.9.4"
+pbr = "^7.0.3"
 
 [build-system]
 requires = ["poetry-core"]

lovelytics_cli-0.4.3/love/auth.py

@@ -1,169 +0,0 @@
-"""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