squirrels 0.5.0b4__py3-none-any.whl → 0.5.1__py3-none-any.whl

squirrels/_request_context.py

@@ -0,0 +1,33 @@
+"""
+Request context management using ContextVars for request-scoped data.
+Provides thread-safe and async-safe access to request IDs throughout the request lifecycle.
+"""
+from contextvars import ContextVar
+import uuid
+import base64
+
+# ContextVar for storing the current request ID
+_request_id: ContextVar[str | None] = ContextVar("request_id", default=None)
+
+
+def get_request_id() -> str | None:
+    """
+    Get the current request ID from the context.
+    
+    Returns:
+        The request ID string if available, None otherwise (e.g., in background tasks).
+    """
+    return _request_id.get()
+
+
+def set_request_id() -> str:
+    """
+    Set a new request ID in the context.
+    Uses base64 URL-safe encoding of UUID bytes to create a shorter ID (22 chars vs 36).
+    
+    Returns:
+        The request ID that was set.
+    """
+    request_id = base64.urlsafe_b64encode(uuid.uuid4().bytes).decode().rstrip('=')
+    _request_id.set(request_id)
+    return request_id

squirrels/_schemas/auth_models.py

@@ -1,19 +1,37 @@
-from typing import Callable, Any
+from typing import Callable, Any, Literal
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
 
-class BaseUser(BaseModel):
+class CustomUserFields(BaseModel):
+    """
+    Extend this class to add custom user fields.
+    - Only the following types are supported: [str, int, float, bool, typing.Literal]
+    - Add "| None" after the type to make it nullable. 
+    - Always set a default value for the column (use None if default is null).
+    """
+    pass
+
+
+class AbstractUser(BaseModel):
     model_config = ConfigDict(from_attributes=True)
     username: str
-    is_admin: bool = False
-    
-    @classmethod
-    def dropped_columns(cls):
-        return []
+    access_level: Literal["admin", "member", "guest"]
+    custom_fields: CustomUserFields
     
     def __hash__(self):
         return hash(self.username)
+    
+    def __str__(self):
+        return self.username
+
+
+class GuestUser(AbstractUser):
+    access_level: Literal["guest"] = "guest"
+
+
+class RegisteredUser(AbstractUser):
+    access_level: Literal["admin", "member"] = "member"
 
 
 class ApiKey(BaseModel):
@@ -40,9 +58,14 @@ class UserField(BaseModel):
 class ProviderConfigs(BaseModel):
     client_id: str
     client_secret: str
-    server_metadata_url: str
+    server_url: str
+    server_metadata_path: str = Field(default="/.well-known/openid-configuration")
     client_kwargs: dict = Field(default_factory=dict)
-    get_user: Callable[[dict], BaseUser]
+    get_user: Callable[[dict], RegisteredUser]
+
+    @property
+    def server_metadata_url(self) -> str:
+        return f"{self.server_url}{self.server_metadata_path}"
 
 
 class AuthProvider(BaseModel):

squirrels/_schemas/query_param_models.py

@@ -40,7 +40,7 @@ def get_query_models_for_dataset(widget_parameters: list[str] | None, param_fiel
     predefined_params = [
         APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid for the dataset"),
         APIParamFieldInfo("x_orientation", str, default="records", description="The orientation of the data to return, one of: 'records', 'rows', or 'columns'"),
-        APIParamFieldInfo("x_select", list[str], examples=[[]], description="The columns to select from the dataset. All are returned if not specified"), 
+        APIParamFieldInfo("x_sql_query", str, description="Optional DuckDB SQL to transform the final dataset. Use table name 'result' to reference the dataset."),
         APIParamFieldInfo("x_offset", int, default=0, description="The number of rows to skip before returning data (applied after data caching)"),
         APIParamFieldInfo("x_limit", int, default=1000, description="The maximum number of rows to return (applied after data caching and offset)"),
     ]
@@ -65,3 +65,11 @@ def get_query_models_for_querying_models(param_fields: dict):
         APIParamFieldInfo("x_sql_query", str, description="The SQL query to execute on the data models"),
     ]
     return _get_query_models_helper(None, predefined_params, param_fields) 
+
+
+def get_query_models_for_compiled_models(param_fields: dict):
+    """Generate query models for fetching compiled model SQL"""
+    predefined_params = [
+        APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid for the model"),
+    ]
+    return _get_query_models_helper(None, predefined_params, param_fields)

squirrels/_schemas/response_models.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Literal
+from typing import Annotated, Literal, Any
 from pydantic import BaseModel, Field
 from datetime import date
 
@@ -99,6 +99,14 @@ parameters_path_description = "The API path to the parameters for the dataset /
 metadata_path_description = "The API path to the metadata (i.e., description and schema) for the dataset"
 result_path_description = "The API path to the results for the dataset / dashboard"
 
+class ConfigurableDefaultModel(BaseModel):
+    name: str
+    default: str
+
+class ConfigurableItemModel(ConfigurableDefaultModel):
+    label: str
+    description: str
+
 class ColumnModel(BaseModel):
     name: Annotated[str, Field(examples=["mycol"], description="Name of column")]
     type: Annotated[str, Field(examples=["string", "integer", "boolean", "datetime"], description='Column type (such as "string", "integer", "boolean", "datetime", etc.)')]
@@ -118,18 +126,19 @@ class DatasetItemModel(BaseModel):
     name: Annotated[str, Field(examples=["mydataset"], description=name_description)]
     label: Annotated[str, Field(examples=["My Dataset"], description=label_description)]
     description: Annotated[str, Field(examples=[""], description=description_description)]
-    parameters: Annotated[list[str], Field(examples=["myparam1", "myparam2"], description="The list of parameter names used by the dataset")]
+    configurables: Annotated[list[ConfigurableDefaultModel], Field(default_factory=list, description="The list of configurables with their default values")]
+    parameters: Annotated[list[str], Field(examples=["myparam1", "myparam2"], description="The list of parameter names used by the dataset. If the list is empty, the dataset does not accept any parameters.")]
     data_schema: Annotated[SchemaWithConditionModel, Field(alias="schema", description="JSON object describing the schema of the dataset")]
-    parameters_path: Annotated[str, Field(examples=["/squirrels-v0/myproject/v1/dataset/mydataset/parameters"], description=parameters_path_description)]
-    result_path: Annotated[str, Field(examples=["/squirrels-v0/myproject/v1/dataset/mydataset"], description=result_path_description)]
-
+    parameters_path: Annotated[str, Field(examples=["/squirrels/v0/myproject/v1/dataset/mydataset/parameters"], description=parameters_path_description)]
+    result_path: Annotated[str, Field(examples=["/squirrels/v0/myproject/v1/dataset/mydataset"], description=result_path_description)]
+    
 class DashboardItemModel(ParametersModel):
     name: Annotated[str, Field(examples=["mydashboard"], description=name_description)]
     label: Annotated[str, Field(examples=["My Dashboard"], description=label_description)]
     description: Annotated[str, Field(examples=[""], description=description_description)]
     parameters: Annotated[list[str], Field(examples=["myparam1", "myparam2"], description="The list of parameter names used by the dashboard")]
-    parameters_path: Annotated[str, Field(examples=["/squirrels-v0/myproject/v1/dashboard/mydashboard/parameters"], description=parameters_path_description)]
-    result_path: Annotated[str, Field(examples=["/squirrels-v0/myproject/v1/dashboard/mydashboard"], description=result_path_description)]
+    parameters_path: Annotated[str, Field(examples=["/squirrels/v0/myproject/v1/dashboard/mydashboard/parameters"], description=parameters_path_description)]
+    result_path: Annotated[str, Field(examples=["/squirrels/v0/myproject/v1/dashboard/mydashboard"], description=result_path_description)]
     result_format: Annotated[str, Field(examples=["png", "html"], description="The format of the dashboard's result API response (one of 'png' or 'html')")]
 
 ModelConfigType = mc.ModelConfig | s.Source | mc.SeedConfig | mc.BuildModelConfig | mc.DbviewModelConfig | mc.FederateModelConfig
@@ -155,13 +164,16 @@ class LineageRelation(BaseModel):
     source: LineageNode
     target: LineageNode
 
-class CatalogModel(BaseModel):
-    parameters: Annotated[ParametersListType, Field(description="The list of all parameters in the project")]
+class CatalogModelForTool(BaseModel):
+    parameters: Annotated[ParametersListType, Field(description="The list of all parameters in the project. It is possible that not all parameters are used by a dataset.")]
     datasets: Annotated[list[DatasetItemModel], Field(description="The list of accessible datasets")]
+    
+class CatalogModel(CatalogModelForTool):
     dashboards: Annotated[list[DashboardItemModel], Field(description="The list of accessible dashboards")]
     connections: Annotated[list[ConnectionItemModel], Field(description="The list of connections in the project (only provided for admin users)")]
     models: Annotated[list[DataModelItem], Field(description="The list of data models in the project (only provided for admin users)")]
     lineage: Annotated[list[LineageRelation], Field(description="The lineage information between data assets (only provided for admin users)")]
+    configurables: Annotated[list[ConfigurableItemModel], Field(description="The list of configurables (only provided for admin users)")]
 
 
 ## Dataset Results Response Models
@@ -180,15 +192,29 @@ class DatasetResultModel(BaseModel):
     )]
 
 
+## Compiled Query Response Model
+
+class CompiledQueryModel(BaseModel):
+    language: Annotated[Literal["sql", "python"], Field(examples=["sql"], description="The language of the data model query: 'sql' or 'python'")]
+    definition: Annotated[str, Field("", description="The compiled SQL or Python definition of the data model.")]
+    placeholders: Annotated[dict[str, Any], Field({}, description="The placeholders for the data model.")]
+
+
 ## Project Metadata Response Models
 
 class ProjectVersionModel(BaseModel):
     major_version: Annotated[int, Field(examples=[1])]
-    data_catalog_path: Annotated[str, Field(examples=["/squirrels-v0/project/myproject/v1/data-catalog"])]
+    data_catalog_path: Annotated[str, Field(examples=["/squirrels/v0/project/myproject/v1/data-catalog"])]
 
 class ProjectModel(BaseModel):
     name: Annotated[str, Field(examples=["myproject"])]
     version: Annotated[str, Field(examples=["v1"])]
     label: Annotated[str, Field(examples=["My Project"])]
     description: Annotated[str, Field(examples=["My project description"])]
+    elevated_access_level: Annotated[Literal["admin", "member", "guest"], Field(
+        examples=["admin"], description="The access level required to access elevated features (such as configurables and data lineage)"
+    )]
+    redoc_path: Annotated[str, Field(examples=["/squirrels/v0/project/myproject/v1/redoc"])]
+    swagger_path: Annotated[str, Field(examples=["/squirrels/v0/project/myproject/v1/docs"])]
+    mcp_server_path: Annotated[str, Field(examples=["/squirrels/v0/project/myproject/v1/mcp"])]
     squirrels_version: Annotated[str, Field(examples=["0.1.0"])]

squirrels/_seeds.py

@@ -37,7 +37,7 @@ class SeedsIO:
     @classmethod
     def load_files(cls, logger: u.Logger, base_path: str, env_vars: dict[str, str]) -> Seeds:
         start = time.time()
-        infer_schema_setting: bool = (env_vars.get(c.SQRL_SEEDS_INFER_SCHEMA, "true").lower() == "true")
+        infer_schema_setting: bool = u.to_bool(env_vars.get(c.SQRL_SEEDS_INFER_SCHEMA, "true"))
         na_values_setting: list[str] = json.loads(env_vars.get(c.SQRL_SEEDS_NA_VALUES, "[]"))
         
         seeds_dict = {}

squirrels/_sources.py

@@ -1,19 +1,19 @@
 from typing import Any
 from pydantic import BaseModel, Field, model_validator
-import time, sqlglot
+import time, sqlglot, yaml
 
 from . import _utils as u, _constants as c, _model_configs as mc
 
 
 class UpdateHints(BaseModel):
     increasing_column: str | None = Field(default=None)
-    strictly_increasing: bool = Field(default=True, description="Delete the max value of the increasing column, ignored if value is set")
-    selective_overwrite_value: Any = Field(default=None)
+    strictly_increasing: bool = Field(default=True, description="Delete the max value of the increasing column, ignored if selective_overwrite_value is set")
+    selective_overwrite_value: Any = Field(default=None, description="Delete all values of the increasing column greater than or equal to this value")
 
 
 class Source(mc.ConnectionInterface, mc.ModelConfig):
     table: str | None = Field(default=None)
-    load_to_duckdb: bool = Field(default=False, description="Whether to load the data to DuckDB")
+    load_to_vdl: bool = Field(default=False, description="Whether to load the data to the 'virtual data lake' (VDL)")
     primary_key: list[str] = Field(default_factory=list)
     update_hints: UpdateHints = Field(default_factory=UpdateHints)
 
@@ -28,34 +28,28 @@ class Source(mc.ConnectionInterface, mc.ModelConfig):
     
     def get_cols_for_create_table_stmt(self) -> str:
         cols_clause = ", ".join([f"{col.name} {col.type}" for col in self.columns])
-        primary_key_clause = f", PRIMARY KEY ({', '.join(self.primary_key)})" if self.primary_key else ""
-        return f"{cols_clause}{primary_key_clause}"
-    
-    def get_cols_for_insert_stmt(self) -> str:
-        return ", ".join([col.name for col in self.columns])
+        return cols_clause
     
     def get_max_incr_col_query(self, source_name: str) -> str:
         return f"SELECT max({self.update_hints.increasing_column}) FROM {source_name}"
     
-    def get_query_for_insert(self, dialect: str, conn_name: str, table_name: str, max_value_of_increasing_col: Any | None, *, full_refresh: bool = True) -> str:
-        select_cols = self.get_cols_for_insert_stmt()
+    def get_query_for_upsert(self, dialect: str, conn_name: str, table_name: str, max_value_of_increasing_col: Any | None, *, full_refresh: bool = True) -> str:
+        select_cols = ", ".join([col.name for col in self.columns])
         if full_refresh or max_value_of_increasing_col is None:
             return f"SELECT {select_cols} FROM db_{conn_name}.{table_name}"
         
         increasing_col = self.update_hints.increasing_column
         increasing_col_type = next(col.type for col in self.columns if col.name == increasing_col)
         where_cond = f"{increasing_col}::{increasing_col_type} > '{max_value_of_increasing_col}'::{increasing_col_type}"
-        pushdown_query = f"SELECT {select_cols} FROM {table_name} WHERE {where_cond}"
         
-        if dialect in ['postgres', 'mysql']:
-            transpiled_query = sqlglot.transpile(pushdown_query, read='duckdb', write=dialect)[0].replace("'", "''")
-            return f"FROM {dialect}_query('db_{conn_name}', '{transpiled_query}')"
+        # TODO: figure out if using pushdown query is worth it
+        # if dialect in ['postgres', 'mysql']:
+        #     pushdown_query = f"SELECT {select_cols} FROM {table_name} WHERE {where_cond}"
+        #     transpiled_query = sqlglot.transpile(pushdown_query, read='duckdb', write=dialect)[0].replace("'", "''")
+        #     return f"FROM {dialect}_query('db_{conn_name}', '{transpiled_query}')"
         
         return f"SELECT {select_cols} FROM db_{conn_name}.{table_name} WHERE {where_cond}"
     
-    def get_insert_replace_clause(self) -> str:
-        return "" if len(self.primary_key) == 0 else "OR REPLACE"
-
 
 class Sources(BaseModel):
     sources: dict[str, Source] = Field(default_factory=dict)
@@ -98,7 +92,17 @@ class SourcesIO:
         start = time.time()
         
         sources_path = u.Path(base_path, c.MODELS_FOLDER, c.SOURCES_FILE)
-        sources_data = u.load_yaml_config(sources_path) if sources_path.exists() else {}
+        if sources_path.exists():
+            raw_content = u.read_file(sources_path)
+            rendered = u.render_string(raw_content, base_path=base_path, env_vars=env_vars)
+            sources_data = yaml.safe_load(rendered) or {}
+        else:
+            sources_data = {}
+        
+        if not isinstance(sources_data, dict):
+            raise u.ConfigurationError(
+                f"Parsed content from YAML file must be a dictionary. Got: {sources_data}"
+            )
         
         sources = Sources(**sources_data).finalize_null_fields(env_vars)
         

squirrels/_utils.py

@@ -1,7 +1,6 @@
-from typing import Sequence, Optional, Union, TypeVar, Callable, Any, Iterable
+from typing import Sequence, Optional, Union, TypeVar, Callable, Iterable, Literal, Any
 from datetime import datetime
 from pathlib import Path
-from functools import lru_cache
 import os, time, logging, json, duckdb, polars as pl, yaml
 import jinja2 as j2, jinja2.nodes as j2_nodes
 import sqlglot, sqlglot.expressions, asyncio, hashlib, inspect, base64
@@ -34,12 +33,20 @@ sqrl_dtypes_to_polars_dtypes: dict[str, type[pl.DataType]] = {sqrl_type: k for k
 ## Other utility classes
 
 class Logger(logging.Logger):
-    def log_activity_time(self, activity: str, start_timestamp: float, *, request_id: str | None = None) -> None:
+    def info(self, msg: str, *, data: dict[str, Any] = {}, **kwargs) -> None:
+        super().info(msg, extra={"data": data}, **kwargs)
+
+    def log_activity_time(self, activity: str, start_timestamp: float, *, additional_data: dict[str, Any] = {}) -> None:
         end_timestamp = time.time()
         time_taken = round((end_timestamp-start_timestamp) * 10**3, 3)
-        data = { "activity": activity, "start_timestamp": start_timestamp, "end_timestamp": end_timestamp, "time_taken_ms": time_taken }
-        info = { "request_id": request_id } if request_id else {}
-        self.info(f'Time taken for "{activity}": {time_taken}ms', extra={"data": data, "info": info})
+        data = {
+            "activity": activity,
+            "start_timestamp": start_timestamp, 
+            "end_timestamp": end_timestamp, 
+            "time_taken_ms": time_taken,
+            **additional_data
+        }
+        self.info(f'Time taken for "{activity}": {time_taken}ms', data=data)
 
 
 class EnvironmentWithMacros(j2.Environment):
@@ -84,14 +91,6 @@ class EnvironmentWithMacros(j2.Environment):
 
 ## Utility functions/variables
 
-def log_activity_time(logger: logging.Logger, activity: str, start_timestamp: float, *, request_id: str | None = None) -> None:
-    end_timestamp = time.time()
-    time_taken = round((end_timestamp-start_timestamp) * 10**3, 3)
-    data = { "activity": activity, "start_timestamp": start_timestamp, "end_timestamp": end_timestamp, "time_taken_ms": time_taken }
-    info = { "request_id": request_id } if request_id else {}
-    logger.debug(f'Time taken for "{activity}": {time_taken}ms', extra={"data": data, "info": info})
-
-
 def render_string(raw_str: str, *, base_path: str = ".", **kwargs) -> str:
     """
     Given a template string, render it with the given keyword arguments
@@ -127,7 +126,7 @@ def read_file(filepath: FilePath) -> str:
 
 def normalize_name(name: str) -> str:
     """
-    Normalizes names to the convention of the squirrels manifest file.
+    Normalizes names to the convention of the squirrels manifest file (with underscores instead of dashes).
 
     Arguments:
         name: The name to normalize.
@@ -140,7 +139,7 @@ def normalize_name(name: str) -> str:
 
 def normalize_name_for_api(name: str) -> str:
     """
-    Normalizes names to the REST API convention.
+    Normalizes names to the REST API convention (with dashes instead of underscores).
 
     Arguments:
         name: The name to normalize.
@@ -195,8 +194,10 @@ def process_if_not_none(input_val: Optional[X], processor: Callable[[X], Y]) ->
     return processor(input_val)
 
 
-@lru_cache(maxsize=1)
-def _read_duckdb_init_sql() -> tuple[str, Path | None]:
+def _read_duckdb_init_sql(
+    *,
+    datalake_db_path: str | None = None,
+) -> str:
     """
     Reads and caches the duckdb init file content.
     Returns None if file doesn't exist or is empty.
@@ -211,35 +212,38 @@ def _read_duckdb_init_sql() -> tuple[str, Path | None]:
         if Path(c.DUCKDB_INIT_FILE).exists():
             with open(c.DUCKDB_INIT_FILE, 'r') as f:
                 init_contents.append(f.read())
-        
-        init_sql = "\n".join(init_contents).strip()
-        target_init_path = None
-        if init_sql:
-            target_init_path = Path(c.TARGET_FOLDER, c.DUCKDB_INIT_FILE)
-            target_init_path.parent.mkdir(parents=True, exist_ok=True)
-            target_init_path.write_text(init_sql)
-        
-        return init_sql, target_init_path
+
+        if datalake_db_path:
+            attach_stmt = f"ATTACH '{datalake_db_path}' AS vdl (READ_ONLY);"
+            init_contents.append(attach_stmt)
+            use_stmt = f"USE vdl;"
+            init_contents.append(use_stmt)
+                
+        init_sql = "\n\n".join(init_contents).strip()
+        return init_sql
     except Exception as e:
         raise ConfigurationError(f"Failed to read {c.DUCKDB_INIT_FILE}: {str(e)}") from e
 
-def create_duckdb_connection(filepath: str | Path = ":memory:", *, read_only: bool = False) -> duckdb.DuckDBPyConnection:
+def create_duckdb_connection(
+    db_path: str | Path = ":memory:", 
+    *, 
+    datalake_db_path: str | None = None
+) -> duckdb.DuckDBPyConnection:
     """
     Creates a DuckDB connection and initializes it with statements from duckdb init file
 
     Arguments:
         filepath: Path to the DuckDB database file. Defaults to in-memory database.
-        read_only: Whether to open the database in read-only mode. Defaults to False.
+        datalake_db_path: The path to the VDL catalog database if applicable. If exists, this is attached as 'vdl' (READ_ONLY). Default is None.
     
     Returns:
         A DuckDB connection (which must be closed after use)
     """
-    conn = duckdb.connect(filepath, read_only=read_only)
+    conn = duckdb.connect(db_path)
     
     try:
-        init_sql, _ = _read_duckdb_init_sql()
-        if init_sql:
-            conn.execute(init_sql)
+        init_sql = _read_duckdb_init_sql(datalake_db_path=datalake_db_path)
+        conn.execute(init_sql)
     except Exception as e:
         conn.close()
         raise ConfigurationError(f"Failed to execute {c.DUCKDB_INIT_FILE}: {str(e)}") from e
@@ -283,7 +287,13 @@ def load_yaml_config(filepath: FilePath) -> dict:
     """
     try:
         with open(filepath, 'r') as f:
-            return yaml.safe_load(f)
+            content = yaml.safe_load(f)
+            content = content if content else {}
+        
+        if not isinstance(content, dict):
+            raise yaml.YAMLError(f"Parsed content from YAML file must be a dictionary. Got: {content}")
+        
+        return content
     except yaml.YAMLError as e:
         raise ConfigurationError(f"Failed to parse yaml file: {filepath}") from e
 
@@ -307,7 +317,7 @@ def run_duckdb_stmt(
         redacted_stmt = redacted_stmt.replace(value, "[REDACTED]")
     
     for_model_name = f" for model '{model_name}'" if model_name is not None else ""
-    logger.info(f"Running SQL statement{for_model_name}:\n{redacted_stmt}", extra={"data": {"params": params}})
+    logger.debug(f"Running SQL statement{for_model_name}:\n{redacted_stmt}")
     try:
         return duckdb_conn.execute(stmt, params)
     except duckdb.ParserException as e:
@@ -391,3 +401,41 @@ def validate_pkce_challenge(code_verifier: str, code_challenge: str) -> bool:
     # Generate expected challenge
     expected_challenge = generate_pkce_challenge(code_verifier)
     return expected_challenge == code_challenge
+
+
+def get_scheme(hostname: str | None) -> str:
+    """Get the scheme of the request"""
+    return "http" if hostname in ("localhost", "127.0.0.1") else "https"
+
+
+def to_title_case(input_str: str) -> str:
+    """Convert a string to title case"""
+    spaced_str = input_str.replace('_', ' ').replace('-', ' ')
+    return spaced_str.title()
+
+
+def to_bool(val: object) -> bool:
+    """Convert common truthy/falsey representations to a boolean.
+
+    Accepted truthy values (case-insensitive): "1", "true", "t", "yes", "y", "on".
+    All other values are considered falsey. None is falsey.
+    """
+    if isinstance(val, bool):
+        return val
+    if val is None:
+        return False
+    s = str(val).strip().lower()
+    return s in ("1", "true", "t", "yes", "y", "on")
+
+
+ACCESS_LEVEL = Literal["admin", "member", "guest"]
+
+def get_access_level_rank(access_level: ACCESS_LEVEL) -> int:
+    """Get the rank of an access level. Lower ranks have more privileges."""
+    return { "admin": 1, "member": 2, "guest": 3 }.get(access_level.lower(), 1)
+
+def user_has_elevated_privileges(user_access_level: ACCESS_LEVEL, required_access_level: ACCESS_LEVEL) -> bool:
+    """Check if a user has privilege to access a resource"""
+    user_access_level_rank = get_access_level_rank(user_access_level)
+    required_access_level_rank = get_access_level_rank(required_access_level)
+    return user_access_level_rank <= required_access_level_rank

squirrels/_version.py

@@ -1,3 +1,3 @@
-__version__ = '0.5.0'
+__version__ = '0.5.1'
 
 sq_major_version, sq_minor_version, sq_patch_version = __version__.split('.')[:3]

squirrels/arguments.py

@@ -1,2 +1,7 @@
 from ._arguments.init_time_args import ConnectionsArgs, AuthProviderArgs, ParametersArgs, BuildModelArgs
 from ._arguments.run_time_args import ContextArgs, ModelArgs, DashboardArgs
+
+__all__ = [
+    "ConnectionsArgs", "AuthProviderArgs", "ParametersArgs", "BuildModelArgs", 
+    "ContextArgs", "ModelArgs", "DashboardArgs"
+]

squirrels/auth.py

@@ -1 +1,4 @@
-from ._auth import BaseUser, ProviderConfigs, provider
+from ._schemas.auth_models import CustomUserFields, RegisteredUser
+from ._auth import ProviderConfigs, provider
+
+__all__ = ["CustomUserFields", "RegisteredUser", "ProviderConfigs", "provider"]

squirrels/connections.py

@@ -1 +1,3 @@
 from ._manifest import ConnectionProperties, ConnectionTypeEnum
+
+__all__ = ["ConnectionProperties", "ConnectionTypeEnum"]

squirrels/dashboards.py

@@ -1 +1,3 @@
-from ._dashboards import PngDashboard, HtmlDashboard
+from ._dashboards import PngDashboard, HtmlDashboard
+
+__all__ = ["PngDashboard", "HtmlDashboard"]

squirrels/data_sources.py

@@ -1,4 +1,5 @@
 from ._data_sources import (
+    SourceEnum,
     SelectDataSource, 
     DateDataSource, 
     DateRangeDataSource,
@@ -6,3 +7,8 @@ from ._data_sources import (
     NumberRangeDataSource, 
     TextDataSource
 )
+
+__all__ = [
+    "SourceEnum", "SelectDataSource", "DateDataSource", "DateRangeDataSource", 
+    "NumberDataSource", "NumberRangeDataSource", "TextDataSource"
+]

squirrels/parameter_options.py

@@ -6,3 +6,8 @@ from ._parameter_options import (
     NumberRangeParameterOption, 
     TextParameterOption
 )
+
+__all__ = [
+    "SelectParameterOption", "DateParameterOption", "DateRangeParameterOption", 
+    "NumberParameterOption", "NumberRangeParameterOption", "TextParameterOption"
+]

squirrels/parameters.py

@@ -7,3 +7,8 @@ from ._parameters import (
     NumberRangeParameter, 
     TextParameter
 )
+
+__all__ = [
+    "SingleSelectParameter", "MultiSelectParameter", "DateParameter", "DateRangeParameter", 
+    "NumberParameter", "NumberRangeParameter", "TextParameter"
+]

squirrels/types.py

@@ -8,4 +8,9 @@ from ._dataset_types import DatasetMetadata, DatasetResult
 
 from ._dashboards import Dashboard
 
-from ._parameter_configs import ParameterConfigBase
+from ._parameter_configs import ParameterConfigBase
+
+__all__ = [
+    "DataSource", "ParameterOption", "Parameter", "TextValue", 
+    "DatasetMetadata", "DatasetResult", "Dashboard", "ParameterConfigBase"
+]