lkr-dev-cli 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

lkr/__init__.py

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

lkr/logger.py

@@ -8,6 +8,13 @@ from rich.theme import Theme
 
 from lkr.custom_types import LogLevel
 
+structlog.configure(
+    processors=[
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.JSONRenderer(),
+    ]
+)
+
 # Define a custom theme for our logging
 theme = Theme(
     {
@@ -50,6 +57,7 @@ logging.basicConfig(
 logger = logging.getLogger("lkr")
 structured_logger = structlog.get_logger("lkr.structured")
 
+
 # Configure the requests_transport logger to only show debug messages when LOG_LEVEL is DEBUG
 requests_logger = logging.getLogger("looker_sdk.rtl.requests_transport")
 if log_level != "DEBUG":

lkr/main.py

@@ -9,6 +9,7 @@ from lkr.custom_types import LogLevel
 from lkr.logger import logger
 from lkr.mcp.main import group as mcp_group
 from lkr.observability.main import group as observability_group
+from lkr.tools.main import group as tools_group
 
 app = typer.Typer(
     name="lkr", help="LookML Repository CLI", add_completion=True, no_args_is_help=True
@@ -17,6 +18,7 @@ app = typer.Typer(
 app.add_typer(auth_group, name="auth")
 app.add_typer(mcp_group, name="mcp")
 app.add_typer(observability_group, name="observability")
+app.add_typer(tools_group, name="tools")
 
 
 @app.callback()

lkr/mcp/classes.py

@@ -0,0 +1,99 @@
+# server.py
+from datetime import datetime
+from typing import Annotated, Any, List
+
+import duckdb
+from pydantic import BaseModel, Field, computed_field
+
+from lkr.mcp.utils import get_database_search_file
+from lkr.observability.classes import now
+
+
+class SpectaclesResponse(BaseModel):
+    success: bool
+    result: Any | None = None
+    error: str | None = None
+    sql: str | None = None
+    share_url: str | None = None
+
+
+class SpectaclesRequest(BaseModel):
+    model: Annotated[
+        str,
+        Field(
+            description="the model to run a test query against, you can find this by the filenames in the repository, they will end with .model.lkml. You should not pass in the .model.lkml extension.",
+            default="",
+        ),
+    ]
+    explore: Annotated[
+        str,
+        Field(
+            description="the explore to run a test query against, you can find this by finding explore: <name> {} in any file in the repository",
+            default="",
+        ),
+    ]
+    fields: Annotated[
+        List[str],
+        Field(
+            description="this should be the list of fields you want to return from the test query. If the user does not provide them, use all that have changed in your current context",
+            default=[],
+        ),
+    ]
+
+
+class Connection(BaseModel):
+    connection: str
+    updated_at: datetime = Field(default_factory=now)
+
+    @computed_field(return_type=str)
+    @property
+    def fully_qualified_name(self) -> str:
+        return self.connection
+
+
+class Database(Connection):
+    database: str
+
+    @computed_field(return_type=str)
+    @property
+    def fully_qualified_name(self) -> str:
+        return f"{self.connection}.{self.database}"
+
+
+class Schema(Database):
+    database_schema_name: str
+
+    @computed_field(return_type=str)
+    @property
+    def fully_qualified_name(self) -> str:
+        return f"{self.connection}.{self.database}.{self.database_schema_name}"
+
+
+class Table(Schema):
+    database_table_name: str
+
+    @computed_field(return_type=str)
+    @property
+    def fully_qualified_name(self) -> str:
+        return f"{self.connection}.{self.database}.{self.database_schema_name}.{self.database_table_name}"
+
+
+class Row(Table):
+    database_column_name: str
+    data_type_database: str
+    data_type_looker: str
+
+    @computed_field(return_type=str)
+    @property
+    def fully_qualified_name(self) -> str:
+        return f"{self.connection}.{self.database}.{self.database_schema_name}.{self.database_table_name}.{self.database_column_name}"
+
+    def append(self, base_url: str) -> None:
+        with open(get_database_search_file(base_url), "a") as f:
+            f.write(self.model_dump_json() + "\n")
+
+    def exists(self, conn: duckdb.DuckDBPyConnection, *, base_url: str) -> bool:
+        columns = conn.execute(
+            f"SELECT * FROM read_json_auto('{get_database_search_file(base_url)}') WHERE fully_qualified_name = '{self.fully_qualified_name}'"
+        ).fetchall()
+        return len(columns) > 0

lkr/mcp/main.py

@@ -1,23 +1,37 @@
 # server.py
-import os
 import threading
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
-from typing import Annotated, Any, Callable, List, Literal, Self, Set
+from typing import Annotated, List, Literal, Self, Set
 
 import duckdb
 import typer
-from fastmcp import FastMCP
 from looker_sdk.sdk.api40.models import (
     SqlQueryCreate,
     WriteQuery,
 )
-from pydantic import BaseModel, Field, computed_field
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel, Field
 from pydash import get
 
 from lkr.auth_service import get_auth
 from lkr.classes import LkrCtxObj
 from lkr.logger import logger
+from lkr.mcp.classes import (
+    Connection,
+    Database,
+    Row,
+    Schema,
+    SpectaclesRequest,
+    SpectaclesResponse,
+    Table,
+)
+from lkr.mcp.utils import (
+    conn_registry_path,
+    get_connection_registry_file,
+    get_database_search_file,
+    ok,
+)
 
 __all__ = ["group"]
 
@@ -28,34 +42,7 @@ ctx_lkr: LkrCtxObj | None = None
 # Create an MCP server
 mcp = FastMCP("lkr:mcp")
 
-group = typer.Typer(name="spectacles")
-
-db_loc: Path | None = None
-
-
-def get_db_loc() -> Path:
-    global db_loc
-    if db_loc is None:
-        db_path = os.path.expanduser("~/.lkr")
-        db_loc = Path(db_path) / "mcp_search_db"
-        db_loc.mkdir(exist_ok=True, parents=True)
-    return db_loc
-
-
-def get_database_search_file(prefix: str = "") -> Path:
-    p = get_db_loc() / f"{prefix + '.' if prefix else ''}looker_connection_search.jsonl"
-    if not p.exists():
-        p.touch()
-    return p
-
-
-def get_connection_registry_file(
-    type: Literal["connection", "database", "schema", "table"], prefix: str = ""
-) -> Path:
-    return (
-        get_db_loc()
-        / f"{prefix + '.' if prefix else ''}looker_connection_registry.{type}.jsonl"
-    )
+group = typer.Typer()
 
 
 # Initialize DuckDB connection
@@ -68,38 +55,6 @@ conn.execute("INSTALL 'json'")
 conn.execute("LOAD 'json'")
 
 
-class SpectaclesResponse(BaseModel):
-    success: bool
-    result: Any | None = None
-    error: str | None = None
-    sql: str | None = None
-    share_url: str | None = None
-
-
-class SpectaclesRequest(BaseModel):
-    model: Annotated[
-        str,
-        Field(
-            description="the model to run a test query against, you can find this by the filenames in the repository, they will end with .model.lkml. You should not pass in the .model.lkml extension.",
-            default="",
-        ),
-    ]
-    explore: Annotated[
-        str,
-        Field(
-            description="the explore to run a test query against, you can find this by finding explore: <name> {} in any file in the repository",
-            default="",
-        ),
-    ]
-    fields: Annotated[
-        List[str],
-        Field(
-            description="this should be the list of fields you want to return from the test query. If the user does not provide them, use all that have changed in your current context",
-            default=[],
-        ),
-    ]
-
-
 def get_mcp_sdk(ctx: LkrCtxObj | typer.Context):
     sdk = get_auth(ctx).get_current_sdk(prompt_refresh_invalid_token=False)
     sdk.auth.settings.agent_tag += "-mcp"
@@ -179,85 +134,6 @@ SELECT * FROM (
         )
 
 
-def now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-class Connection(BaseModel):
-    connection: str
-    updated_at: datetime = Field(default_factory=now)
-
-    @computed_field(return_type=str)
-    @property
-    def fully_qualified_name(self) -> str:
-        return self.connection
-
-
-class Database(Connection):
-    database: str
-
-    @computed_field(return_type=str)
-    @property
-    def fully_qualified_name(self) -> str:
-        return f"{self.connection}.{self.database}"
-
-
-class Schema(Database):
-    database_schema_name: str
-
-    @computed_field(return_type=str)
-    @property
-    def fully_qualified_name(self) -> str:
-        return f"{self.connection}.{self.database}.{self.database_schema_name}"
-
-
-class Table(Schema):
-    database_table_name: str
-
-    @computed_field(return_type=str)
-    @property
-    def fully_qualified_name(self) -> str:
-        return f"{self.connection}.{self.database}.{self.database_schema_name}.{self.database_table_name}"
-
-
-class Row(Table):
-    database_column_name: str
-    data_type_database: str
-    data_type_looker: str
-
-    @computed_field(return_type=str)
-    @property
-    def fully_qualified_name(self) -> str:
-        return f"{self.connection}.{self.database}.{self.database_schema_name}.{self.database_table_name}.{self.database_column_name}"
-
-    def append(self, base_url: str) -> None:
-        with open(get_database_search_file(base_url), "a") as f:
-            f.write(self.model_dump_json() + "\n")
-
-    def exists(self, base_url: str) -> bool:
-        columns = conn.execute(
-            f"SELECT * FROM read_json_auto('{get_database_search_file(base_url)}') WHERE fully_qualified_name = '{self.fully_qualified_name}'"
-        ).fetchall()
-        return len(columns) > 0
-
-
-def ok[T](func: Callable[[], T], default: T) -> T:
-    try:
-        return func()
-    except Exception:
-        # logger.error(f"Error in {func.__name__}: {str(e)}")
-        return default
-
-
-def conn_registry_path(
-    type: Literal["connection", "database", "schema", "table"], prefix: str = ""
-) -> Path:
-    file_loc = get_connection_registry_file(type, prefix)
-    if not file_loc.exists():
-        file_loc.touch()
-    return file_loc
-
-
 class ConnectionRegistry(BaseModel):
     connections: Set[str]
     databases: Set[str]
@@ -301,7 +177,7 @@ class ConnectionRegistry(BaseModel):
 
     def load_connections(self, dt_filter: datetime | None = None) -> None:
         file = conn_registry_path("connection", self.prefix)
-        # logger.debug(f"Loading connections from {file}")
+        logger.debug(f"Loading connections from {file}")
         sql = f"SELECT connection FROM read_json_auto('{file}')"
         if dt_filter:
             sql += f" WHERE updated_at > '{dt_filter.isoformat()}'"
@@ -310,8 +186,8 @@ class ConnectionRegistry(BaseModel):
             for row in results:
                 connection = Connection(connection=row[0])
                 self.connections.add(connection.fully_qualified_name)
-        except Exception:
-            # logger.error(f"Error loading connections from {file}: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error loading connections from {file}: {str(e)}")
             return
 
     def load_databases(self, dt_filter: datetime | None = None) -> None:
@@ -324,8 +200,8 @@ class ConnectionRegistry(BaseModel):
             for row in results:
                 database = Database(connection=row[0], database=row[1])
                 self.databases.add(database.fully_qualified_name)
-        except Exception:
-            # logger.error(f"Error loading databases from {file}: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error loading databases from {file}: {str(e)}")
             return
 
     def load_schemas(self, dt_filter: datetime | None = None) -> None:
@@ -340,8 +216,8 @@ class ConnectionRegistry(BaseModel):
                     connection=row[0], database=row[1], database_schema_name=row[2]
                 )
                 self.schemas.add(schema.fully_qualified_name)
-        except Exception:
-            # logger.error(f"Error loading schemas from {file}: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error loading schemas from {file}: {str(e)}")
             return
 
     def load_tables(self, dt_filter: datetime | None = None) -> None:
@@ -359,8 +235,8 @@ class ConnectionRegistry(BaseModel):
                     database_table_name=row[3],
                 )
                 self.tables.add(table.fully_qualified_name)
-        except Exception:
-            # logger.error(f"Error loading tables from {file}: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error loading tables from {file}: {str(e)}")
             return
 
     @classmethod
@@ -387,27 +263,31 @@ def populate_looker_connection_search_on_startup(ctx: typer.Context) -> None:
     # logger.debug("Populating looker connection search")
     sdk = get_mcp_sdk(ctx)
     if not current_instance:
-        # logger.error("No current instance found")
-        raise typer.Abort()
-    registry = ConnectionRegistry.initialize(prefix=current_instance)
+        logger.error("No current instance found")
+        return
+    url_from_instance = sdk.auth.settings.base_url
+    logger.debug(
+        f"Populating looker connection search for {url_from_instance} from {current_instance}"
+    )
+    registry = ConnectionRegistry.initialize(prefix=url_from_instance)
     connections = ok(lambda: sdk.all_connections(), [])
     for connection in connections:
         if not connection.name:
             continue
         elif registry.check("connection", connection.name):
-            # logger.debug(
-            #     f"Skipping {connection.name} because it already exists in the registry"
-            # )
+            logger.debug(
+                f"Skipping {connection.name} because it already exists in the registry"
+            )
             continue
-        # logger.debug(f"Populating looker connection search for {connection.name}")
+        logger.debug(f"Populating looker connection search for {connection.name}")
         databases = ok(lambda: sdk.connection_databases(connection.name or ""), [])
         for database in databases:
             if registry.check("database", database):
-                # logger.debug(
-                #     f"Skipping {database} because it already exists in the registry"
-                # )
+                logger.debug(
+                    f"Skipping {database} because it already exists in the registry"
+                )
                 continue
-            # logger.debug(f"Populating looker connection search for {database}")
+            logger.debug(f"Populating looker connection search for {database}")
             schemas = ok(
                 lambda: sdk.connection_schemas(
                     connection.name or "", database, cache=True, fields="name"
@@ -559,22 +439,48 @@ def load_database_search_file(file_loc: Path) -> None:
     )
 
 
-class SearchFullyQualifiedNamesRequest(BaseModel):
-    search_term: str = Field(
-        description="The search term to search for within the fully qualified column name. It will be converted to lowercase before searching. The fully quallified column name incluses database, schema, table, and column names."
-    )
-
-
 # Add a dynamic greeting resource
 @mcp.tool()
-def search_fully_qualified_names(req: SearchFullyQualifiedNamesRequest) -> List[dict]:
+def search_fully_qualified_names(
+    search_term: Annotated[
+        str,
+        Field(
+            description="The search term to search for within the fully qualified column name. It will be converted to lowercase before searching. The fully quallified column name incluses database, schema, table, and column names.",
+            min_length=1,
+        ),
+    ],
+    database_filter: Annotated[
+        str | None,
+        Field(
+            description="The database to search for within the fully qualified column name. It will be converted to lowercase before searching. The fully quallified column name incluses database, schema, table, and column names. If not provided, all databases will be searched. This is synonymous with BigQuery's projects.",
+        ),
+    ],
+    schema_filter: Annotated[
+        str | None,
+        Field(
+            description="The schema to search for within the fully qualified column name. It will be converted to lowercase before searching. The fully quallified column name incluses database, schema, table, and column names. If not provided, all schemas will be searched. This is synonymous with BigQuery's datasets",
+        ),
+    ],
+    table_filter: Annotated[
+        str | None,
+        Field(
+            description="The table to search for within the fully qualified column name. It will be converted to lowercase before searching. The fully quallified column name incluses database, schema, table, and column names. If not provided, all tables will be searched.",
+        ),
+    ],
+    limit: Annotated[
+        int,
+        Field(
+            description="The number of results to return. If not provided, the default is 10000.",
+            default=100,
+        ),
+    ],
+) -> List[Row]:
     """
     Use lkr to search fully qualified columns which include connection, database, schema, table, column names, and data types
-    Returns a list of matching rows with their BM25 scores
+    Returns a list of matching rows with their BM25 scores. If no database, schema, or table is provided, all will be searched. When specified together, databsae, scema and table are filtered together using an AND.
     """
-    result = conn.execute(
-        """
-        SELECT 
+    sql = """
+    SELECT 
           connection, 
           database, 
           database_schema_name, 
@@ -584,15 +490,30 @@ def search_fully_qualified_names(req: SearchFullyQualifiedNamesRequest) -> List[
           data_type_looker, 
           fts_main_looker_connection_search.match_bm25(
             fully_qualified_name,
-            ?
+            $search_term
           ) AS score
         FROM looker_connection_search
         WHERE score IS NOT NULL
-        ORDER BY score DESC
-        LIMIT 10000
-        """,
-        [req.search_term.lower()],
-        # [search_term, connections, databases, schemas, tables],
+    """
+    params = dict(
+        search_term=search_term.lower(),
+        limit=limit,
+    )
+    if database:
+        sql += " AND database = $database"
+        params["database"] = database
+    if schema:
+        sql += " AND database_schema_name = $schema"
+        params["schema"] = schema
+    if table:
+        sql += " AND database_table_name = $table"
+        params["table"] = table
+    sql += " ORDER BY score DESC LIMIT $limit"
+    logger.debug(f"Executing SQL: {sql}")
+    logger.debug(f"Params: {params}")
+    result = conn.execute(
+        sql,
+        params,
     ).fetchall()
     return [
         Row(
@@ -603,20 +524,31 @@ def search_fully_qualified_names(req: SearchFullyQualifiedNamesRequest) -> List[
             database_column_name=row[4],
             data_type_database=row[5],
             data_type_looker=row[6],
-        ).model_dump()
+        )
         for row in result
     ]
 
 
-@group.callback()
-def main(ctx: typer.Context):
+@group.command(name="run")
+def run(
+    ctx: typer.Context,
+    debug: bool = typer.Option(False, help="Debug mode"),
+):
+    from lkr.logger import LogLevel, set_log_level
+
     global ctx_lkr
-    ctx_lkr = LkrCtxObj(force_oauth=False)
-    validate_current_instance_database_search_file(ctx)
 
+    ctx_lkr = LkrCtxObj(force_oauth=False)
+    validate_current_instance_database_search_file(ctx, debug)
+    sdk = get_mcp_sdk(ctx_lkr)
+    if not sdk.auth.settings.base_url:
+        logger.error("No current instance found")
+        raise typer.Exit(1)
 
-@group.command(name="run")
-def run():
+    if debug:
+        set_log_level(LogLevel.DEBUG)
+    else:
+        set_log_level(LogLevel.ERROR)
     mcp.run()
 
 
@@ -631,18 +563,25 @@ def check_for_database_search_file(ctx: typer.Context) -> None:
         raise typer.Abort()
 
 
-def validate_current_instance_database_search_file(ctx: typer.Context) -> None:
+def validate_current_instance_database_search_file(
+    ctx: typer.Context, debug: bool
+) -> None:
     global current_instance
     check = get_auth(ctx).get_current_instance()
+    if not check:
+        logger.error("No current instance found")
     if not current_instance:
         current_instance = check
-        thread = threading.Thread(target=check_for_database_search_file, args=(ctx,))
-        # thread.daemon = True
+        thread = threading.Thread(
+            target=check_for_database_search_file, args=(ctx,), daemon=not debug
+        )
         thread.start()
     elif current_instance != check:
         current_instance = check
-        thread = threading.Thread(target=check_for_database_search_file, args=(ctx,))
-        # thread.daemon = True
+        thread = threading.Thread(
+            target=check_for_database_search_file, args=(ctx,), daemon=not debug
+        )
+        thread.daemon = True if not debug else False
         thread.start()
     else:
         pass

lkr/mcp/utils.py

@@ -0,0 +1,55 @@
+# server.py
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable, Literal
+
+from lkr.logger import logger
+
+db_loc: Path | None = None
+
+
+def get_db_loc() -> Path:
+    global db_loc
+    if db_loc is None:
+        db_path = os.path.expanduser("~/.lkr")
+        db_loc = Path(db_path) / "mcp_search_db"
+        db_loc.mkdir(exist_ok=True, parents=True)
+    return db_loc
+
+
+def get_database_search_file(prefix: str = "") -> Path:
+    p = get_db_loc() / f"{prefix + '.' if prefix else ''}looker_connection_search.jsonl"
+    if not p.exists():
+        p.touch()
+    return p
+
+
+def get_connection_registry_file(
+    type: Literal["connection", "database", "schema", "table"], prefix: str = ""
+) -> Path:
+    return (
+        get_db_loc()
+        / f"{prefix + '.' if prefix else ''}looker_connection_registry.{type}.jsonl"
+    )
+
+
+def now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ok[T](func: Callable[[], T], default: T) -> T:
+    try:
+        return func()
+    except Exception as e:
+        logger.error(f"Error in {func.__name__}: {str(e)}")
+        return default
+
+
+def conn_registry_path(
+    type: Literal["connection", "database", "schema", "table"], prefix: str = ""
+) -> Path:
+    file_loc = get_connection_registry_file(type, prefix)
+    if not file_loc.exists():
+        file_loc.touch()
+    return file_loc

lkr/tools/classes.py

@@ -0,0 +1,206 @@
+from typing import Literal, Optional, Self, cast
+
+from fastapi import Request
+from looker_sdk.sdk.api40.methods import Looker40SDK
+from looker_sdk.sdk.api40.models import (
+    UserAttributeGroupValue,
+    WriteUserAttribute,
+    WriteUserAttributeWithValue,
+)
+from pydantic import BaseModel, model_validator
+
+from lkr.auth_service import init_api_key_sdk
+from lkr.classes import LookerApiKey
+from lkr.logger import logger
+
+
+class UserAttributeUpdater(BaseModel):
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    base_url: Optional[str] = None
+    value: Optional[str] = None
+    user_attribute: Optional[str]
+    user_attribute_id: Optional[str] = None
+    update_type: Literal["group", "default", "user"]
+    group_name: Optional[str] = None
+    group_id: Optional[str] = None
+    looker_user_id: Optional[str] = None
+    external_user_id: Optional[str] = None
+    email: Optional[str] = None
+
+    @model_validator(mode="after")
+    def check_variables(self) -> Self:
+        if not (bool(self.user_attribute) or bool(self.user_attribute_id)):
+            raise ValueError("Either user_attribute or user_attribute_id must be set")
+        if self.update_type == "group":
+            if not (bool(self.group_name) or bool(self.group_id)):
+                raise ValueError("Either group_name or group_id must be set")
+        if self.update_type == "user":
+            if not (
+                bool(self.looker_user_id)
+                or bool(self.external_user_id)
+                or bool(self.email)
+            ):
+                raise ValueError(
+                    "Either looker_user_id, external_user_id, or email must be set"
+                )
+        return self
+
+    def get_request_authorization_for_value(self, request: Request):
+        authorization_token = request.headers.get("Authorization")
+        if authorization_token:
+            self.value = authorization_token
+        else:
+            logger.error("No authorization token found")
+
+    def _get_sdk(self):
+        api_key: LookerApiKey | None = None
+        if self.client_id and self.client_secret and self.base_url:
+            api_key = LookerApiKey(
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+                base_url=self.base_url,
+            )
+        else:
+            api_key = LookerApiKey.from_env()
+        if not api_key:
+            logger.error("No API key found")
+            return None
+        return init_api_key_sdk(api_key, True)
+
+    def _get_group_id(self, sdk: Looker40SDK) -> str | None:
+        if self.group_id:
+            return self.group_id
+        elif self.group_name:
+            groups = sdk.search_groups(name=self.group_name, fields="id")
+            if groups:
+                return groups[0].id
+        return None
+
+    def _get_user_attribute_id(self, sdk: Looker40SDK) -> str | None:
+        if self.user_attribute_id:
+            return self.user_attribute_id
+        elif self.user_attribute:
+            user_attributes = cast(
+                list[dict], sdk.get("/user_attributes", structure=list[dict])
+            )
+            for user_attribute in user_attributes or []:
+                if user_attribute["name"] == self.user_attribute:
+                    return user_attribute["id"]
+        return None
+
+    def delete_user_attribute_value(self):
+        sdk = self._get_sdk()
+        if not sdk:
+            raise ValueError("No SDK found")
+        user_attribute_id = self._get_user_attribute_id(sdk)
+        if not user_attribute_id:
+            raise ValueError("User attribute not found")
+
+        if self.update_type == "group":
+            group_id = self._get_group_id(sdk)
+            if group_id:
+                sdk.delete_user_attribute_group_value(
+                    group_id=group_id,
+                    user_attribute_id=user_attribute_id,
+                )
+            else:
+                raise ValueError("Group not found")
+        elif self.update_type == "default":
+            sdk.delete_user_attribute(user_attribute_id)
+        elif self.update_type == "user":
+            if self.looker_user_id:
+                sdk.delete_user_attribute_user_value(
+                    user_id=self.looker_user_id,
+                    user_attribute_id=user_attribute_id,
+                )
+            elif self.external_user_id:
+                sdk.delete_user_attribute_user_value(
+                    user_id=self.external_user_id,
+                    user_attribute_id=user_attribute_id,
+                )
+            elif self.email:
+                sdk.delete_user_attribute_user_value(
+                    user_id=self.email,
+                    user_attribute_id=user_attribute_id,
+                )
+            else:
+                raise ValueError("User not found")
+
+    def update_user_attribute_value(self):
+        if not self.value:
+            raise ValueError("Value is required to update user attribute")
+
+        sdk = self._get_sdk()
+        if not sdk:
+            raise ValueError("No SDK found")
+        user_attribute_id = self._get_user_attribute_id(sdk)
+
+        if not user_attribute_id:
+            raise ValueError("User attribute not found")
+        user_attribute = sdk.user_attribute(user_attribute_id)
+        if not user_attribute:
+            raise ValueError("User attribute not found")
+
+        if user_attribute.type != "string":
+            raise ValueError("User attribute is not a string")
+
+        if self.update_type == "group":
+            group_id = self._get_group_id(sdk)
+            if group_id:
+                sdk.update_user_attribute_group_value(
+                    group_id=group_id,
+                    user_attribute_id=user_attribute_id,
+                    body=UserAttributeGroupValue(
+                        group_id=group_id,
+                        user_attribute_id=user_attribute_id,
+                        value=self.value,
+                    ),
+                )
+            else:
+                raise ValueError("Group not found")
+        elif self.update_type == "default":
+            sdk.update_user_attribute(
+                user_attribute_id,
+                WriteUserAttribute(
+                    name=user_attribute.name,
+                    label=user_attribute.label,
+                    type=user_attribute.type,
+                    default_value=self.value,
+                ),
+            )
+        elif self.update_type == "user":
+
+            def set_user_attribute_user_value(user_id: str):
+                sdk.set_user_attribute_user_value(
+                    user_id=user_id,
+                    user_attribute_id=user_attribute_id,
+                    body=WriteUserAttributeWithValue(
+                        value=self.value,
+                    ),
+                )
+
+            if self.looker_user_id:
+                set_user_attribute_user_value(self.looker_user_id)
+
+            elif self.external_user_id:
+                user = sdk.user_for_credential("embed", self.external_user_id)
+                if not (user and user.id):
+                    raise ValueError("User not found")
+                set_user_attribute_user_value(user.id)
+
+            elif self.email:
+                user = sdk.user_for_credential("email", self.email)
+                if not (user and user.id):
+                    raise ValueError("User not found")
+                set_user_attribute_user_value(user.id)
+
+            else:
+                raise ValueError("User not found")
+        else:
+            raise ValueError("Invalid update_type")
+
+
+class AttributeUpdaterResponse(BaseModel):
+    success: bool = False
+    message: str

lkr/tools/main.py

@@ -0,0 +1,55 @@
+import typer
+import uvicorn
+from fastapi import FastAPI, Request
+
+from lkr.tools.classes import AttributeUpdaterResponse, UserAttributeUpdater
+
+__all__ = ["group"]
+
+group = typer.Typer()
+
+
+@group.command()
+def user_attribute_updater(
+    ctx: typer.Context,
+    host: str = typer.Option(default="127.0.0.1", envvar="HOST"),
+    port: int = typer.Option(default=8080, envvar="PORT"),
+):
+    api = FastAPI()
+
+    @api.post("/identity_token")
+    def identity_token(request: Request, body: UserAttributeUpdater):
+        try:
+            body.get_request_authorization_for_value(request)
+            body.update_user_attribute_value()
+            return AttributeUpdaterResponse(
+                success=True, message="User attribute updated"
+            )
+        except Exception as e:
+            return AttributeUpdaterResponse(success=False, message=str(e))
+
+    @api.delete("/value")
+    def delete_user_attribute_value(request: Request, body: UserAttributeUpdater):
+        try:
+            body.delete_user_attribute_value()
+            return AttributeUpdaterResponse(
+                success=True, message="User attribute value deleted"
+            )
+        except Exception as e:
+            return AttributeUpdaterResponse(success=False, message=str(e))
+
+    @api.post("/value")
+    def update_user_attribute_value(request: Request, body: UserAttributeUpdater):
+        try:
+            body.update_user_attribute_value()
+            return AttributeUpdaterResponse(
+                success=True, message="User attribute value updated"
+            )
+        except Exception as e:
+            return AttributeUpdaterResponse(success=False, message=str(e))
+
+    uvicorn.run(api, host=host, port=port)
+
+
+if __name__ == "__main__":
+    group()

{lkr_dev_cli-0.0.24.dist-info → lkr_dev_cli-0.0.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lkr-dev-cli
-Version: 0.0.24
+Version: 0.0.26
 Summary: lkr: a command line interface for looker
 Author: bwebs
 License-Expression: MIT
@@ -9,8 +9,8 @@ Requires-Python: >=3.12
 Requires-Dist: cryptography>=42.0.0
 Requires-Dist: duckdb>=1.2.2
 Requires-Dist: fastapi>=0.115.12
-Requires-Dist: fastmcp>=2.3.5
 Requires-Dist: looker-sdk>=25.4.0
+Requires-Dist: mcp[cli]>=1.9.2
 Requires-Dist: pydantic>=2.11.4
 Requires-Dist: pydash>=8.0.5
 Requires-Dist: questionary>=2.1.0
@@ -178,26 +178,33 @@ For example:
 
 ### Cloud Run + GCP Health Check example
 
-One of the simplest ways to launch the health check is the `lkr-cli` public docker image, Cloud Run, and the GCP health check service. Here's an example; make sure to change your region, models, user_attributes, and external_user_id.
+One of the simplest ways to launch the health check is the `lkr-cli` public docker image, Cloud Run, and the GCP health check service. Here's an example; make sure to change your region and project. HEALTH_URL is an example of how to structure the query parameters for the health check.
 
 ```bash
 export REGION=<your region>
 export PROJECT=<your project id>
 
-export HEALTH_URL="/health?dashboard_id=1&external_user_id=embed-user-abc&models=thelook&user_attributes={\"store_id\":\"1\"}"
+export HEALTH_URL="/health?dashboard_id=1&external_user_id=observability-embed-user&models=thelook&user_attributes={\"store_id\":\"1\"}"
 
 gcloud run deploy lkr-observability \
   --image us-central1-docker.pkg.dev/lkr-dev-production/lkr-cli/cli:latest \
   --command lkr \
   --args observability,embed \
   --platform managed \
-  --region $REGION \ 
+  --region $REGION \
   --project $PROJECT \
   --cpu 2 \
   --memory 4Gi \
-  --liveness-probe httpGet.path=$HEALTH_URL,timeoutSeconds=20,periodSeconds=20 \
   --set-env-vars LOOKERSDK_CLIENT_ID=<your client id>,LOOKERSDK_CLIENT_SECRET=<your client secret>,LOOKERSDK_BASE_URL=<your instance url> 
 
+gcloud monitoring uptime create lkr-observability-health-check \
+  --protocol https \
+  --project $PROJECT \
+  --resource-type="cloud-run-revision" \
+  --resource-labels="project_id=${PROJECT},service_name=lkr-observability,location=${REGION}" \
+  --path="${HEALTH_URL}" \
+  --period="15" \
+  --timeout="60"
 
 ```
 

{lkr_dev_cli-0.0.24.dist-info → lkr_dev_cli-0.0.26.dist-info}/RECORD

@@ -1,21 +1,25 @@
-lkr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lkr/__init__.py,sha256=IooxWuZJ0XeK6dTc0PTRy3pVhofSoepOVJHBMuBWByI,87
 lkr/auth_service.py,sha256=NIGlSVtzS3ajpWYx2gTJVDknuF_KxwYsJEj88Hc05dQ,19887
 lkr/classes.py,sha256=f2TJOXFta0s8LJLEXOqPdWPLg-EIIntUSDS6gDOon7M,1163
 lkr/constants.py,sha256=DdCfsV6q8wgs2iHpIQeb6oDP_2XejusEHyPvCbaM3yY,108
 lkr/custom_types.py,sha256=feJ-W2U61PJTiotMLuZJqxrotA53er95kO1O30mooy4,323
 lkr/exceptions.py,sha256=M_aR4YaCZtY4wyxhcoqJCVkxVu9z3Wwo5KgSDyOoEnI,210
-lkr/logger.py,sha256=wLEVluF-2lVMPJ228D7O4-shHaydEGXmn47j567nUgw,1887
-lkr/main.py,sha256=wpnSiCpIScEi-jmrLuwcSJrMX3tMkuaYNwlvNkVf5N8,2375
+lkr/logger.py,sha256=vKlJZqiMzJbYBzmiiD0HzJp-J-rHd4nWX-7P4ZKgh78,2033
+lkr/main.py,sha256=pTVibYNb7Wh-dKVbqAozUGWPbeofqIo0gQceZSXoySQ,2464
 lkr/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lkr/auth/main.py,sha256=7tWGPWokzbBnrX1enZ9YP4rdDJqYBlGfuYe0Wg-fXT4,7532
 lkr/auth/oauth.py,sha256=n2yAcccdBZaloGVtFRTwCPBfh1cvVYNbXLsFCxmWc5M,7207
-lkr/mcp/main.py,sha256=fz7Bvbkj1CTD185lGwNdMYP7bOTDadWL1xdD4JZW8qQ,22886
+lkr/mcp/classes.py,sha256=dqtZxivftufQpQNXmlzzhx1lw3nN7DwTvFc6pZUF_bA,2992
+lkr/mcp/main.py,sha256=JRMfdNk5_tqxWz8caqKBmcxP2ieNXAE4-1HjEgC4jl4,21693
+lkr/mcp/utils.py,sha256=lXkXmoD-a7WkJYI4qqzh-n1wE4T5YajOkALZtjJxYWg,1378
 lkr/observability/classes.py,sha256=LgGuUnY-J1csPrlAKnw4PPOqOfbvaOx2cxENlQgJYcE,5816
 lkr/observability/embed_container.html,sha256=IcDG-QVsYYNGQGrkDrx9OMZ2Pmo4C8oAjRHddFQ7Tlw,2939
 lkr/observability/main.py,sha256=XbejIdqhNNUMqHVezb5EnLaJ32dO9-Bt0o5d8lc0kyw,9544
 lkr/observability/utils.py,sha256=UpaBrp_ufaXLoz4p3xG3K6lHKBpP9wBhvP8rDmeGoWg,2148
-lkr_dev_cli-0.0.24.dist-info/METADATA,sha256=PKOjKBiQqRlg4nfYzcFjbjYHSzaRNCslIlBiBGaaZPw,10663
-lkr_dev_cli-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lkr_dev_cli-0.0.24.dist-info/entry_points.txt,sha256=nn2sFMGDpwUVE61ZUpbDPnQZkW7Gc08nV-tyLGo8q34,37
-lkr_dev_cli-0.0.24.dist-info/licenses/LICENSE,sha256=hKnCOORW1JRE_M2vStz8dblS5u1iR-2VpqS9xagKNa0,1063
-lkr_dev_cli-0.0.24.dist-info/RECORD,,
+lkr/tools/classes.py,sha256=tXOFLdahjEHlpr0dgR3miwDeb98Qw1X7bUA-26Hzhkg,7635
+lkr/tools/main.py,sha256=zHBZWjCp_pYw_dPKQg_rLZTHLbnKYAoPPFBuHSqtEc0,1751
+lkr_dev_cli-0.0.26.dist-info/METADATA,sha256=fTj56Vl0lcKtV9gruaG0haOjqJYmvXzBeCsN2JpRLaY,10953
+lkr_dev_cli-0.0.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lkr_dev_cli-0.0.26.dist-info/entry_points.txt,sha256=nn2sFMGDpwUVE61ZUpbDPnQZkW7Gc08nV-tyLGo8q34,37
+lkr_dev_cli-0.0.26.dist-info/licenses/LICENSE,sha256=hKnCOORW1JRE_M2vStz8dblS5u1iR-2VpqS9xagKNa0,1063
+lkr_dev_cli-0.0.26.dist-info/RECORD,,