lkr-dev-cli 0.0.41__tar.gz → 0.0.42__tar.gz

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.41
+Version: 0.0.42
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT
@@ -288,9 +288,51 @@ gcloud run deploy lkr-access-token-updater \
   --set-env-vars LOOKERSDK_CLIENT_ID=<your client id>,LOOKERSDK_CLIENT_SECRET=<your client secret>,LOOKERSDK_BASE_URL=<your instance url>,LOOKER_WHITELISTED_BASE_URLS=<your instance url>
   ```
 
-## UserAttributeUpdater `lkr-dev-cli`
+## Python SDK & Library Usage
 
-Exported from the `lkr-dev-cli` package is the `UserAttributeUpdater` pydantic class. This class has all the necessary logic to update a user attribute value. 
+When installing `lkr-dev-cli` in your Python environment, you can import tools and pre-authenticated Looker SDK clients directly into your scripts, apps, or Jupyter notebooks.
+
+### Package Import Aliases (`lkr` vs `lkr_dev_cli`)
+To maximize convenience and match user intuition, both `lkr` and `lkr_dev_cli` are available as identical top-level Python packages. You can use them completely interchangeably:
+
+```python
+from lkr import init_sdk, UserAttributeUpdater
+# works exactly identical to:
+from lkr_dev_cli import init_sdk, UserAttributeUpdater
+```
+
+### Initializing the Looker SDK (`init_sdk`)
+The `init_sdk()` function initializes and returns an authenticated `ExtendedLooker40SDK` instance. It automatically handles credential discovery and authentication:
+
+```python
+from lkr_dev_cli import init_sdk
+
+# Option 1: Explicit API Authentication
+sdk = init_sdk(
+    base_url="https://acme.cloud.looker.com",
+    client_id="your-client-id",
+    client_secret="your-client-secret",
+    verify_ssl=True,  # optional, defaults to True
+)
+
+# Option 2: Environment Variable API Authentication
+# Automatically uses LOOKERSDK_BASE_URL, LOOKERSDK_CLIENT_ID, LOOKERSDK_CLIENT_SECRET
+sdk = init_sdk()
+
+# Option 3: Database (SQLite) OAuth Login Profile
+# Uses your saved active session from running `lkr auth login`
+sdk = init_sdk()  # Picks the active current_instance = 1
+# Or pick a specific named login profile:
+sdk = init_sdk(instance_name="my_dev_instance")
+
+# Make an API call
+me = sdk.me()
+print(f"Hello, {me.display_name}")
+```
+
+### UserAttributeUpdater
+
+Exported from the package is the `UserAttributeUpdater` pydantic class. This class has all the necessary logic to update a user attribute value. 
 
 It supports the following operations:
 - Updating a default value

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/README.md

@@ -252,9 +252,51 @@ gcloud run deploy lkr-access-token-updater \
   --set-env-vars LOOKERSDK_CLIENT_ID=<your client id>,LOOKERSDK_CLIENT_SECRET=<your client secret>,LOOKERSDK_BASE_URL=<your instance url>,LOOKER_WHITELISTED_BASE_URLS=<your instance url>
   ```
 
-## UserAttributeUpdater `lkr-dev-cli`
+## Python SDK & Library Usage
 
-Exported from the `lkr-dev-cli` package is the `UserAttributeUpdater` pydantic class. This class has all the necessary logic to update a user attribute value. 
+When installing `lkr-dev-cli` in your Python environment, you can import tools and pre-authenticated Looker SDK clients directly into your scripts, apps, or Jupyter notebooks.
+
+### Package Import Aliases (`lkr` vs `lkr_dev_cli`)
+To maximize convenience and match user intuition, both `lkr` and `lkr_dev_cli` are available as identical top-level Python packages. You can use them completely interchangeably:
+
+```python
+from lkr import init_sdk, UserAttributeUpdater
+# works exactly identical to:
+from lkr_dev_cli import init_sdk, UserAttributeUpdater
+```
+
+### Initializing the Looker SDK (`init_sdk`)
+The `init_sdk()` function initializes and returns an authenticated `ExtendedLooker40SDK` instance. It automatically handles credential discovery and authentication:
+
+```python
+from lkr_dev_cli import init_sdk
+
+# Option 1: Explicit API Authentication
+sdk = init_sdk(
+    base_url="https://acme.cloud.looker.com",
+    client_id="your-client-id",
+    client_secret="your-client-secret",
+    verify_ssl=True,  # optional, defaults to True
+)
+
+# Option 2: Environment Variable API Authentication
+# Automatically uses LOOKERSDK_BASE_URL, LOOKERSDK_CLIENT_ID, LOOKERSDK_CLIENT_SECRET
+sdk = init_sdk()
+
+# Option 3: Database (SQLite) OAuth Login Profile
+# Uses your saved active session from running `lkr auth login`
+sdk = init_sdk()  # Picks the active current_instance = 1
+# Or pick a specific named login profile:
+sdk = init_sdk(instance_name="my_dev_instance")
+
+# Make an API call
+me = sdk.me()
+print(f"Hello, {me.display_name}")
+```
+
+### UserAttributeUpdater
+
+Exported from the package is the `UserAttributeUpdater` pydantic class. This class has all the necessary logic to update a user attribute value. 
 
 It supports the following operations:
 - Updating a default value

lkr_dev_cli-0.0.42/lkr/__init__.py

@@ -0,0 +1,5 @@
+from lkr.tools.classes import UserAttributeUpdater
+from lkr.extended_sdk_methods import ExtendedLooker40SDK
+from lkr.auth_service import init_sdk
+
+__all__ = ["UserAttributeUpdater", "ExtendedLooker40SDK", "init_sdk"]

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/lkr/auth_service.py

@@ -22,7 +22,13 @@ from lkr.constants import LOOKER_API_VERSION, OAUTH_CLIENT_ID
 from lkr.custom_types import NewTokenCallback
 from lkr.logger import logger
 
-__all__ = ["get_auth", "ApiKeyAuthSession", "DbOAuthSession", "is_auth_expired"]
+__all__ = [
+    "get_auth",
+    "ApiKeyAuthSession",
+    "DbOAuthSession",
+    "is_auth_expired",
+    "init_sdk",
+]
 
 
 def is_auth_expired(e: Exception) -> bool:
@@ -57,6 +63,7 @@ class ApiKeyApiSettings(ApiSettings):
             base_url=self.api_key.base_url,
             client_id=self.api_key.client_id,
             client_secret=self.api_key.client_secret,
+            verify_ssl=str(self.api_key.verify_ssl).lower(),
         )
 
 
@@ -624,3 +631,57 @@ class ApiKeyAuth:
         raise NotImplementedError(
             "ApiKeyAuth does not support getting current instance"
         )
+
+
+def init_sdk(
+    base_url: str | None = None,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+    verify_ssl: bool | None = None,
+    use_production: bool = True,
+    instance_name: str | None = None,
+) -> Looker40SDK:
+    resolved_base_url = base_url or os.environ.get("LOOKERSDK_BASE_URL")
+    resolved_client_id = client_id or os.environ.get("LOOKERSDK_CLIENT_ID")
+    resolved_client_secret = (
+        client_secret or os.environ.get("LOOKERSDK_CLIENT_SECRET")
+    )
+
+    resolved_verify_ssl: bool
+    if verify_ssl is not None:
+        resolved_verify_ssl = verify_ssl
+    else:
+        if "LOOKERSDK_VERIFY_SSL" in os.environ:
+            verify_ssl_str = os.environ.get("LOOKERSDK_VERIFY_SSL", "true").lower()
+            resolved_verify_ssl = verify_ssl_str not in ("false", "0", "f")
+        else:
+            resolved_verify_ssl = True
+
+    if resolved_base_url or resolved_client_id or resolved_client_secret:
+        if not (
+            resolved_base_url and resolved_client_id and resolved_client_secret
+        ):
+            missing = []
+            if not resolved_base_url:
+                missing.append("base_url")
+            if not resolved_client_id:
+                missing.append("client_id")
+            if not resolved_client_secret:
+                missing.append("client_secret")
+            raise ValueError(
+                f"Incomplete API key configuration. Missing: {', '.join(missing)}"
+            )
+        api_key = LookerApiKey(
+            client_id=resolved_client_id,
+            client_secret=resolved_client_secret,
+            base_url=resolved_base_url,
+            verify_ssl=resolved_verify_ssl,
+        )
+        return init_api_key_sdk(api_key, use_production=use_production)
+
+    ctx = LkrCtxObj(
+        force_oauth=True, oauth_account=instance_name, use_production=use_production
+    )
+    sql_auth = SqlLiteAuth(ctx)
+    return sql_auth.get_current_sdk()
+

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/lkr/classes.py

@@ -8,14 +8,18 @@ class LookerApiKey(BaseModel):
     client_id: str = Field(..., min_length=1)
     client_secret: str = Field(..., min_length=1)
     base_url: str = Field(..., min_length=1)
+    verify_ssl: bool = True
 
     @classmethod
     def from_env(cls):
         try:
+            verify_ssl_str = os.environ.get("LOOKERSDK_VERIFY_SSL", "true").lower()
+            verify_ssl = verify_ssl_str not in ("false", "0", "f")
             return cls(
                 client_id=os.environ.get("LOOKERSDK_CLIENT_ID"),  # type: ignore
                 client_secret=os.environ.get("LOOKERSDK_CLIENT_SECRET"),  # type: ignore
                 base_url=os.environ.get("LOOKERSDK_BASE_URL"),  # type: ignore
+                verify_ssl=verify_ssl,
             )
         except Exception:
             return None

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/lkr/extended_sdk_methods/__init__.py

@@ -8,6 +8,7 @@ from lkr.extended_sdk_methods.classes import (
     ProjectGeneratorColumn,
     ProjectGeneratorTable,
     SelectedTable,
+    ProjectCommitRequest,
 )
 from lkr.extended_sdk_methods.main import ExtendedLooker40SDK
 
@@ -22,4 +23,5 @@ __all__ = [
     "GenerateLookMLParameters",
     "SelectedTable",
     "GenerateLookMLWithNewFilesResponse",
+    "ProjectCommitRequest",
 ]

lkr_dev_cli-0.0.42/lkr/tools/lookml.py

@@ -0,0 +1,386 @@
+import os
+import re
+from typing import Annotated, Any, Optional
+
+import typer
+
+from lkr.auth_service import get_auth
+from lkr.extended_sdk_methods import (
+    ExtendedLooker40SDK,
+    FileContent,
+    ProjectCommitRequest,
+)
+from lkr.logger import logger
+
+__all__ = ["lookml_group"]
+
+lookml_group = typer.Typer(
+    name="lookml",
+    help="LookML synchronization and deployment tools",
+    no_args_is_help=True,
+)
+
+VALID_EXTENSIONS = (
+    ".lkml",
+    ".lookml",
+    ".json",
+    ".geojson",
+    ".md",
+    ".gitkeep",
+)
+
+
+def _get_file_id(f: Any) -> str:
+    if isinstance(f, dict):
+        return str(f.get("id") or f.get("path") or str(f))
+    if hasattr(f, "id") and f.id is not None:
+        return str(f.id)
+    if hasattr(f, "path") and f.path is not None:
+        return str(f.path)
+    return str(f)
+
+
+def _resolve_project_id(
+    folder_name: Optional[str], project_id_opt: Optional[str]
+) -> str:
+    if project_id_opt:
+        return project_id_opt
+    if folder_name:
+        return os.path.basename(os.path.abspath(folder_name.rstrip("/\\")))
+    env_proj = os.getenv("LOOKER_PROJECT_NAME")
+    if env_proj:
+        return env_proj
+    return os.path.basename(os.getcwd())
+
+
+def _ensure_remote_directory(
+    sdk: ExtendedLooker40SDK, project_id: str, file_path: str
+) -> None:
+    dir_path = os.path.dirname(file_path.replace("\\", "/"))
+    if not dir_path or dir_path == "." or dir_path == "/":
+        return
+
+    parts = [p for p in dir_path.split("/") if p]
+    current_path = ""
+    for part in parts:
+        current_path = f"{current_path}/{part}" if current_path else part
+        try:
+            sdk.create_project_directory(
+                project_id=project_id,
+                directory_path=current_path,
+            )
+        except Exception as e:
+            logger.debug(f"Directory creation notice for '{current_path}': {e}")
+
+
+@lookml_group.command(name="push")
+def push(
+    ctx: typer.Context,
+    folder_name: Annotated[
+        str, typer.Argument(help="Local folder name / Looker project ID to push")
+    ],
+    project_id_opt: Annotated[
+        Optional[str],
+        typer.Option(
+            "--project-id",
+            "--project",
+            help="Looker project ID to push to (if different from folder name)",
+        ),
+    ] = None,
+    deploy: Annotated[
+        bool,
+        typer.Option("--deploy", help="Commit and deploy to production after push"),
+    ] = False,
+    message: Annotated[
+        str, typer.Option("--message", help="Commit message when deploying")
+    ] = "push from lkr cli",
+):
+    """
+    Push local files to Looker, removing files on the instance that aren't being pushed.
+    """
+    auth = get_auth(ctx)
+    sdk: ExtendedLooker40SDK = auth.get_current_sdk()
+    project_id = _resolve_project_id(folder_name, project_id_opt)
+
+    lookml_dir = os.path.abspath(folder_name)
+    if not os.path.exists(lookml_dir):
+        logger.error(f"Local folder does not exist: {lookml_dir}")
+        raise typer.Exit(1)
+
+    logger.info(f"Reading local files from {lookml_dir} for project {project_id}...")
+    files_to_push = []
+    for root, _, files in os.walk(lookml_dir):
+        if ".git" in root.split(os.sep):
+            continue
+        for file in files:
+            if file in (".gitignore", ".DS_Store"):
+                continue
+            if any(file.endswith(ext) for ext in VALID_EXTENSIONS):
+                full_path = os.path.join(root, file)
+                rel_path = os.path.relpath(full_path, lookml_dir).replace("\\", "/")
+                with open(full_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                files_to_push.append({
+                    "path": rel_path,
+                    "root_name": file,
+                    "content": content,
+                })
+            else:
+                logger.warning(
+                    f"Local file '{file}' has an extension not supported by Looker and will be skipped."
+                )
+
+    successfully_pushed_paths = set()
+    for f in files_to_push:
+        structured_path = f["path"]
+        root_path = f["root_name"]
+        content = f["content"]
+
+        try:
+            logger.info(f"Uploading/Overwriting remote file: {structured_path}")
+            file_content = FileContent(path=structured_path, content=content)
+            try:
+                sdk.update_file(
+                    project_id=project_id,
+                    file_content=file_content,
+                )
+            except Exception:
+                try:
+                    sdk.create_file(
+                        project_id=project_id,
+                        file_content=file_content,
+                    )
+                except Exception:
+                    _ensure_remote_directory(
+                        sdk=sdk, project_id=project_id, file_path=structured_path
+                    )
+                    sdk.create_file(
+                        project_id=project_id,
+                        file_content=file_content,
+                    )
+            successfully_pushed_paths.add(structured_path)
+            continue
+        except Exception as struct_err:
+            logger.debug(
+                f"Structured upload notice ({struct_err}), initiating fallback to project root..."
+            )
+
+        if root_path.endswith(".model.lkml"):
+            content = re.sub(
+                r'include:\s*["\']/views/\*\*/\*\.view\.lkml["\']',
+                'include: "/*.view.lkml"',
+                content,
+            )
+
+        root_file_content = FileContent(path=root_path, content=content)
+        try:
+            sdk.update_file(
+                project_id=project_id,
+                file_content=root_file_content,
+            )
+        except Exception:
+            sdk.create_file(
+                project_id=project_id,
+                file_content=root_file_content,
+            )
+        successfully_pushed_paths.add(root_path)
+
+    logger.info("Retrieving remote file inventory to enforce one-way mirror...")
+    existing_remote = sdk.all_project_files(project_id=project_id) or []
+    for rf in existing_remote:
+        rf_path = _get_file_id(rf)
+        if not any(rf_path.endswith(ext) for ext in VALID_EXTENSIONS):
+            logger.warning(
+                f"Remote file '{rf_path}' has an extension not supported by Looker."
+            )
+        if (
+            rf_path not in successfully_pushed_paths
+            and not rf_path.endswith(".gitkeep")
+            and rf_path != "manifest.lkml"
+        ):
+            logger.info(f"Deleting remote orphan file: {rf_path}")
+            try:
+                sdk.delete_file(project_id=project_id, file_path=rf_path)
+            except Exception as dpe:
+                logger.debug(f"Deletion notice for {rf_path}: {dpe}")
+
+    logger.info("Push completed successfully.")
+
+    if deploy:
+        logger.info(f"Committing and deploying project {project_id} to production...")
+        try:
+            commit_req = ProjectCommitRequest(message=message).model_dump(
+                exclude_none=True
+            )
+            sdk.commit(project_id=project_id, body=commit_req)
+        except Exception as commit_err:
+            logger.debug(f"Commit notice: {commit_err}")
+
+        sdk.deploy_to_production(project_id=project_id)
+        logger.info("Deployment completed successfully.")
+
+
+@lookml_group.command(name="pull")
+def pull(
+    ctx: typer.Context,
+    folder_name: Annotated[
+        str, typer.Argument(help="Local folder name / Looker project ID to pull into")
+    ],
+    project_id_opt: Annotated[
+        Optional[str],
+        typer.Option(
+            "--project-id",
+            "--project",
+            help="Looker project ID to pull from (if different from folder name)",
+        ),
+    ] = None,
+    deploy: Annotated[
+        bool,
+        typer.Option(
+            "--deploy", help="Commit and deploy to production on Looker after pull"
+        ),
+    ] = False,
+    message: Annotated[
+        str, typer.Option("--message", help="Commit message when deploying")
+    ] = "pull from lkr cli then commit and deploy",
+):
+    """
+    Pull remote files from Looker to local disk, removing local files that aren't on the instance.
+    """
+    auth = get_auth(ctx)
+    sdk: ExtendedLooker40SDK = auth.get_current_sdk()
+    project_id = _resolve_project_id(folder_name, project_id_opt)
+
+    target_dir = os.path.abspath(folder_name)
+    os.makedirs(target_dir, exist_ok=True)
+
+    logger.info(
+        f"Retrieving remote files for project {project_id} to pull into {target_dir}..."
+    )
+    existing_remote = sdk.all_project_files(project_id=project_id) or []
+
+    remote_paths = set()
+    for rf in existing_remote:
+        rf_path = _get_file_id(rf)
+        if not any(rf_path.endswith(ext) for ext in VALID_EXTENSIONS):
+            logger.warning(
+                f"Remote file '{rf_path}' has an extension not supported by Looker."
+            )
+            continue
+        if rf_path.endswith(".gitkeep"):
+            continue
+
+        local_path = os.path.join(target_dir, rf_path)
+        resolved_local = os.path.abspath(local_path)
+        try:
+            if os.path.commonpath([target_dir, resolved_local]) != target_dir:
+                logger.warning(f"Path traversal detected and blocked: {rf_path}")
+                continue
+        except ValueError:
+            logger.warning(f"Path traversal detected and blocked: {rf_path}")
+            continue
+
+        try:
+            content = sdk.get_file_content(project_id=project_id, file_path=rf_path)
+        except Exception as e:
+            if "not found" in str(e).lower():
+                logger.debug(
+                    f"Remote file {rf_path} not found in dev workspace (likely a deleted ghost file in git tracking)."
+                )
+            else:
+                logger.error(f"Failed to fetch content for remote file {rf_path}: {e}")
+            continue
+
+        remote_paths.add(rf_path)
+
+        local_path = os.path.join(target_dir, rf_path)
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        with open(local_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        logger.info(f"Pulled file: {rf_path}")
+
+    logger.info("Cleaning up local orphans not present on the Looker instance...")
+    for root, _, files in os.walk(target_dir):
+        if ".git" in root.split(os.sep):
+            continue
+        for file in files:
+            if file in (".gitignore", ".DS_Store"):
+                continue
+            if any(file.endswith(ext) for ext in VALID_EXTENSIONS):
+                full_path = os.path.join(root, file)
+                rel_path = os.path.relpath(full_path, target_dir).replace("\\", "/")
+                if (
+                    rel_path not in remote_paths
+                    and not rel_path.endswith(".gitkeep")
+                    and rel_path != "manifest.lkml"
+                ):
+                    logger.info(f"Deleting local orphan file: {rel_path}")
+                    try:
+                        os.remove(full_path)
+                    except Exception as err:
+                        logger.debug(f"Local deletion notice for {rel_path}: {err}")
+            else:
+                logger.warning(
+                    f"Local file '{file}' has an extension not supported by Looker and will not be synchronized or deleted."
+                )
+
+    logger.info("Pull completed successfully.")
+
+    if deploy:
+        logger.info(
+            f"Committing and deploying project {project_id} to production on Looker..."
+        )
+        try:
+            commit_req = ProjectCommitRequest(message=message).model_dump(
+                exclude_none=True
+            )
+            sdk.commit(project_id=project_id, body=commit_req)
+        except Exception as commit_err:
+            logger.debug(f"Commit notice: {commit_err}")
+
+        sdk.deploy_to_production(project_id=project_id)
+        logger.info("Deployment completed successfully.")
+
+
+@lookml_group.command(name="deploy")
+def deploy_cmd(
+    ctx: typer.Context,
+    folder_name: Annotated[
+        Optional[str],
+        typer.Argument(help="Local folder name / Looker project ID to deploy"),
+    ] = None,
+    project_id: Annotated[
+        Optional[str],
+        typer.Option(
+            "--project-id",
+            "--project",
+            help="Looker project ID to deploy (if folder_name not specified)",
+        ),
+    ] = None,
+    message: Annotated[
+        str, typer.Option("--message", help="Commit message")
+    ] = "commit and deploy from lkr cli",
+):
+    """
+    Commit dev workspace and deploy Looker project to production.
+    """
+    auth = get_auth(ctx)
+    sdk: ExtendedLooker40SDK = auth.get_current_sdk()
+    resolved_project_id = _resolve_project_id(folder_name, project_id)
+
+    logger.info(
+        f"Committing and deploying project {resolved_project_id} to production..."
+    )
+    try:
+        commit_req = ProjectCommitRequest(message=message).model_dump(
+            exclude_none=True
+        )
+        sdk.commit(
+            project_id=resolved_project_id,
+            body=commit_req,
+        )
+    except Exception as commit_err:
+        logger.debug(f"Commit notice: {commit_err}")
+
+    sdk.deploy_to_production(project_id=resolved_project_id)
+    logger.info("Deployment completed successfully.")

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/lkr/tools/main.py

@@ -9,10 +9,13 @@ from fastapi import FastAPI, Request
 from lkr.logger import structured_logger as logger
 from lkr.tools.classes import AttributeUpdaterResponse, UserAttributeUpdater
 from lkr.tools.permission_deprecation import schedule_download_deprecation
+from lkr.tools.lookml import lookml_group
 
 __all__ = ["group"]
 
 group = typer.Typer()
+group.add_typer(lookml_group, name="lookml")
+
 
 if not logger:
     raise Exception("Logger is not available")

lkr_dev_cli-0.0.42/lkr_dev_cli/__init__.py

@@ -0,0 +1,5 @@
+from lkr.tools.classes import UserAttributeUpdater
+from lkr.extended_sdk_methods import ExtendedLooker40SDK
+from lkr.auth_service import init_sdk
+
+__all__ = ["UserAttributeUpdater", "ExtendedLooker40SDK", "init_sdk"]

{lkr_dev_cli-0.0.41 → lkr_dev_cli-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lkr-dev-cli"
-version = "0.0.41"
+version = "0.0.42"
 description = "lkr: a command line interface for looker"
 readme = "README.md"
 license = "MIT"
@@ -60,5 +60,5 @@ dev = [
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["lkr"]
+packages = ["lkr", "lkr_dev_cli"]
 

lkr_dev_cli-0.0.42/tests/test_init_sdk.py

@@ -0,0 +1,167 @@
+import sqlite3
+from unittest.mock import MagicMock, patch
+import pytest
+
+from lkr_dev_cli import init_sdk
+from lkr.auth_service import ApiKeyApiSettings, SqlLiteAuth
+from lkr.classes import LkrCtxObj, LookerApiKey
+
+
+def test_init_sdk_explicit_args(monkeypatch):
+    mock_sdk = MagicMock()
+    with patch("lkr.auth_service.init_api_key_sdk", return_value=mock_sdk) as mock_init:
+        sdk = init_sdk(
+            base_url="https://explicit.looker.com",
+            client_id="test_id",
+            client_secret="test_secret",
+            verify_ssl=False,
+        )
+        assert sdk == mock_sdk
+        mock_init.assert_called_once()
+        api_key, use_prod = (
+            mock_init.call_args[0][0],
+            mock_init.call_args[1]["use_production"],
+        )
+        assert api_key.base_url == "https://explicit.looker.com"
+        assert api_key.client_id == "test_id"
+        assert api_key.client_secret == "test_secret"
+        assert api_key.verify_ssl is False
+        assert use_prod is True
+
+
+def test_init_sdk_env_vars(monkeypatch):
+    monkeypatch.setenv("LOOKERSDK_BASE_URL", "https://env.looker.com")
+    monkeypatch.setenv("LOOKERSDK_CLIENT_ID", "env_id")
+    monkeypatch.setenv("LOOKERSDK_CLIENT_SECRET", "env_secret")
+    monkeypatch.setenv("LOOKERSDK_VERIFY_SSL", "false")
+
+    mock_sdk = MagicMock()
+    with patch("lkr.auth_service.init_api_key_sdk", return_value=mock_sdk) as mock_init:
+        sdk = init_sdk()
+        assert sdk == mock_sdk
+        mock_init.assert_called_once()
+        api_key = mock_init.call_args[0][0]
+        assert api_key.base_url == "https://env.looker.com"
+        assert api_key.client_id == "env_id"
+        assert api_key.client_secret == "env_secret"
+        assert api_key.verify_ssl is False
+
+
+def test_api_key_api_settings():
+    api_key = LookerApiKey(
+        client_id="my_id",
+        client_secret="my_secret",
+        base_url="https://settings.looker.com",
+        verify_ssl=False,
+    )
+    settings = ApiKeyApiSettings(api_key)
+    config = settings.read_config()
+    assert config["base_url"] == "https://settings.looker.com"
+    assert config["client_id"] == "my_id"
+    assert config["client_secret"] == "my_secret"
+    assert config["verify_ssl"] == "false"
+
+
+def test_init_sdk_db_auth_fallback(tmp_path, monkeypatch):
+    monkeypatch.delenv("LOOKERSDK_BASE_URL", raising=False)
+    monkeypatch.delenv("LOOKERSDK_CLIENT_ID", raising=False)
+    monkeypatch.delenv("LOOKERSDK_CLIENT_SECRET", raising=False)
+
+    db_path = tmp_path / "auth.db"
+
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS auth (
+            id INTEGER PRIMARY KEY AUTOINCREMENT, 
+            instance_name TEXT, 
+            access_token TEXT, 
+            refresh_token TEXT, 
+            refresh_expires_at TEXT, 
+            token_type TEXT, 
+            expires_at TEXT, 
+            current_instance BOOLEAN, 
+            base_url TEXT, 
+            use_production BOOLEAN
+        )
+        """
+    )
+    conn.execute(
+        """
+        INSERT INTO auth (instance_name, access_token, refresh_token, refresh_expires_at, token_type, expires_at, current_instance, base_url, use_production)
+        VALUES ('my_db_instance', 'acc_tok', 'ref_tok', '2030-01-01T00:00:00+00:00', 'Bearer', '2030-01-01T00:00:00+00:00', 1, 'https://db.looker.com', 1)
+        """
+    )
+    conn.commit()
+    conn.close()
+
+    mock_sdk = MagicMock()
+    with patch(
+        "lkr.auth_service.SqlLiteAuth.get_current_sdk", return_value=mock_sdk
+    ) as mock_get_sdk:
+        with patch("lkr.auth_service.os.path.expanduser", return_value=str(db_path)):
+            sdk = init_sdk(instance_name="my_db_instance")
+            assert sdk == mock_sdk
+            mock_get_sdk.assert_called_once()
+
+
+def test_sqlite_auth_match_instance_name(tmp_path, monkeypatch):
+    db_path = tmp_path / "auth.db"
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS auth (
+            id INTEGER PRIMARY KEY AUTOINCREMENT, 
+            instance_name TEXT, 
+            access_token TEXT, 
+            refresh_token TEXT, 
+            refresh_expires_at TEXT, 
+            token_type TEXT, 
+            expires_at TEXT, 
+            current_instance BOOLEAN, 
+            base_url TEXT, 
+            use_production BOOLEAN
+        )
+        """
+    )
+    conn.execute(
+        """
+        INSERT INTO auth (instance_name, access_token, refresh_token, refresh_expires_at, token_type, expires_at, current_instance, base_url, use_production)
+        VALUES ('matched_inst', 'acc_tok', 'ref_tok', '2030-01-01T00:00:00+00:00', 'Bearer', '2030-01-01T00:00:00+00:00', 0, 'https://matchme.looker.com', 1)
+        """
+    )
+    conn.commit()
+    conn.close()
+
+    ctx = LkrCtxObj(force_oauth=True, oauth_account="matched_inst")
+    with patch("lkr.auth_service.os.path.expanduser", return_value=str(db_path)):
+        sql_auth = SqlLiteAuth(ctx, db_path=str(db_path))
+        current_auth = sql_auth._get_current_auth()
+        assert current_auth is not None
+        assert current_auth.instance_name == "matched_inst"
+        assert current_auth.base_url == "https://matchme.looker.com"
+
+
+def test_init_sdk_incomplete_api_key(monkeypatch):
+    monkeypatch.delenv("LOOKERSDK_BASE_URL", raising=False)
+    monkeypatch.delenv("LOOKERSDK_CLIENT_ID", raising=False)
+    monkeypatch.delenv("LOOKERSDK_CLIENT_SECRET", raising=False)
+
+    with pytest.raises(
+        ValueError,
+        match="Incomplete API key configuration. Missing: client_id, client_secret",
+    ):
+        init_sdk(base_url="https://incomplete.looker.com")
+
+    with pytest.raises(
+        ValueError,
+        match="Incomplete API key configuration. Missing: base_url, client_secret",
+    ):
+        init_sdk(client_id="my_id")
+
+    with pytest.raises(
+        ValueError,
+        match="Incomplete API key configuration. Missing: base_url, client_id",
+    ):
+        init_sdk(client_secret="my_secret")
+

lkr_dev_cli-0.0.42/tests/test_lookml_tools.py

@@ -0,0 +1,268 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from lkr.main import app
+from lkr.extended_sdk_methods import ExtendedLooker40SDK, FileContent
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_sdk():
+    sdk = MagicMock(spec=ExtendedLooker40SDK)
+    return sdk
+
+
+@pytest.fixture
+def mock_auth(mock_sdk):
+    auth = MagicMock()
+    auth.get_current_sdk.return_value = mock_sdk
+    return auth
+
+
+def test_push_command(tmp_path, mock_sdk, mock_auth):
+    # Setup local folder and files
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    
+    models_dir = project_dir / "models"
+    models_dir.mkdir()
+    
+    model_file = models_dir / "test.model.lkml"
+    model_file.write_text('connection: "my_conn"\ninclude: "/views/**/*.view.lkml"')
+
+    # Mock remote inventory containing an orphan
+    mock_sdk.all_project_files.return_value = [
+        {"id": "models/test.model.lkml"},
+        {"id": "orphan_file.lkml"},
+    ]
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(
+            app, ["tools", "lookml", "push", str(project_dir), "--deploy"]
+        )
+        assert result.exit_code == 0
+
+    # Verify orphan deletion
+    mock_sdk.delete_file.assert_called_once_with(
+        project_id="test_project", file_path="orphan_file.lkml"
+    )
+
+    expected_content = 'connection: "my_conn"\ninclude: "/views/**/*.view.lkml"'
+    expected_fc = FileContent(
+        path="models/test.model.lkml", content=expected_content
+    )
+    mock_sdk.create_file.assert_not_called()
+    mock_sdk.update_file.assert_called_with(
+        project_id="test_project", file_content=expected_fc
+    )
+
+    # Verify deploy flags
+    mock_sdk.commit.assert_called_once()
+    mock_sdk.deploy_to_production.assert_called_once_with(
+        project_id="test_project"
+    )
+
+
+def test_pull_command(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    
+    # Create a local orphan that should be removed
+    local_orphan = project_dir / "local_orphan.lkml"
+    local_orphan.write_text("old content")
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "models/pulled.model.lkml"},
+    ]
+    mock_sdk.get_file_content.return_value = "pulled lookml content"
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(
+            app, ["tools", "lookml", "pull", str(project_dir), "--deploy"]
+        )
+        assert result.exit_code == 0
+
+    # Verify new file created locally
+    pulled_file = project_dir / "models" / "pulled.model.lkml"
+    assert pulled_file.exists()
+    assert pulled_file.read_text() == "pulled lookml content"
+
+    # Verify local orphan deleted
+    assert not local_orphan.exists()
+
+    # Verify commit and deploy
+    mock_sdk.commit.assert_called_once()
+    mock_sdk.deploy_to_production.assert_called_once_with(
+        project_id="test_project"
+    )
+
+
+def test_pull_ghost_file(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    
+    views_dir = project_dir / "views"
+    views_dir.mkdir()
+    
+    affinity_file = views_dir / "affinity.view.lkml"
+    affinity_file.write_text("old content")
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "views/affinity.view.lkml"},
+    ]
+    mock_sdk.get_file_content.side_effect = Exception("Not found")
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(app, ["tools", "lookml", "pull", str(project_dir)])
+        assert result.exit_code == 0
+
+    # Verify ghost file was deleted locally
+    assert not affinity_file.exists()
+
+
+def test_deploy_command(mock_sdk, mock_auth):
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(
+            app, ["tools", "lookml", "deploy", "my_deploy_project"]
+        )
+        assert result.exit_code == 0
+
+    mock_sdk.commit.assert_called_once()
+    mock_sdk.deploy_to_production.assert_called_once_with(
+        project_id="my_deploy_project"
+    )
+
+
+def test_push_warning(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    
+    # Create an unsupported file locally
+    unsupported_file = project_dir / "unsupported.xyz"
+    unsupported_file.write_text("random")
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "remote_unsupported.abc"},
+    ]
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth), patch("lkr.tools.lookml.logger.warning") as mock_warn:
+        result = runner.invoke(app, ["tools", "lookml", "push", str(project_dir)])
+        assert result.exit_code == 0
+        
+        # Check warnings called for both local and remote unsupported extensions
+        mock_warn.assert_any_call(
+            "Local file 'unsupported.xyz' has an extension not supported by Looker and will be skipped."
+        )
+        mock_warn.assert_any_call(
+            "Remote file 'remote_unsupported.abc' has an extension not supported by Looker."
+        )
+
+
+def test_pull_warning(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    
+    # Create an unsupported local orphan
+    unsupported_local = project_dir / "unsupported_local.py"
+    unsupported_local.write_text("print('hello')")
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "remote_unsupported.doc"},
+    ]
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth), patch("lkr.tools.lookml.logger.warning") as mock_warn:
+        result = runner.invoke(app, ["tools", "lookml", "pull", str(project_dir)])
+        assert result.exit_code == 0
+
+        # Check warnings called
+        mock_warn.assert_any_call(
+            "Remote file 'remote_unsupported.doc' has an extension not supported by Looker."
+        )
+        mock_warn.assert_any_call(
+            "Local file 'unsupported_local.py' has an extension not supported by Looker and will not be synchronized or deleted."
+        )
+        
+        # Verify unsupported local orphan was NOT deleted
+        assert unsupported_local.exists()
+
+
+def test_pull_path_traversal(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+    outside_dir = tmp_path / "outside"
+    outside_dir.mkdir()
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "../outside/traversal.lkml"},
+    ]
+    mock_sdk.get_file_content.return_value = "malicious content"
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth), patch(
+        "lkr.tools.lookml.logger.warning"
+    ) as mock_warn:
+        result = runner.invoke(app, ["tools", "lookml", "pull", str(project_dir)])
+        assert result.exit_code == 0
+
+        # Verify the file was not written outside
+        outside_file = outside_dir / "traversal.lkml"
+        assert not outside_file.exists()
+        mock_warn.assert_any_call(
+            "Path traversal detected and blocked: ../outside/traversal.lkml"
+        )
+
+
+def test_push_orphan_cleanup_after_upload(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+
+    views_dir = project_dir / "views"
+    views_dir.mkdir()
+
+    view_file = views_dir / "my_view.view.lkml"
+    view_file.write_text("view: my_view {}")
+
+    mock_sdk.all_project_files.return_value = [
+        {"id": "views/my_view.view.lkml"},
+        {"id": "my_view.view.lkml"},
+    ]
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(app, ["tools", "lookml", "push", str(project_dir)])
+        assert result.exit_code == 0
+
+    mock_sdk.delete_file.assert_called_once_with(
+        project_id="test_project", file_path="my_view.view.lkml"
+    )
+
+
+def test_push_create_directory_recursively_fallback(tmp_path, mock_sdk, mock_auth):
+    project_dir = tmp_path / "test_project"
+    project_dir.mkdir()
+
+    nested_dir = project_dir / "views2" / "subfolder"
+    nested_dir.mkdir(parents=True)
+
+    view_file = nested_dir / "my_view.view.lkml"
+    view_file.write_text("view: my_view {}")
+
+    mock_sdk.update_file.side_effect = Exception("File not found")
+    # First create_file fails (missing directory), second succeeds
+    mock_sdk.create_file.side_effect = [Exception("Directory not found"), None]
+
+    with patch("lkr.tools.lookml.get_auth", return_value=mock_auth):
+        result = runner.invoke(app, ["tools", "lookml", "push", str(project_dir)])
+        assert result.exit_code == 0
+
+    mock_sdk.create_project_directory.assert_any_call(
+        project_id="test_project", directory_path="views2"
+    )
+    mock_sdk.create_project_directory.assert_any_call(
+        project_id="test_project", directory_path="views2/subfolder"
+    )
+    assert mock_sdk.create_file.call_count == 2
+
+
+

lkr_dev_cli-0.0.41/lkr/__init__.py

@@ -1,3 +0,0 @@
-from lkr.tools.classes import UserAttributeUpdater
-
-__all__ = ["UserAttributeUpdater"]