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

squirrels/_api_routes/project.py

@@ -8,16 +8,17 @@ from fastapi.security import HTTPBearer
 from mcp.server.fastmcp import FastMCP, Context
 from dataclasses import asdict
 from cachetools import TTLCache
+from textwrap import dedent
 import time
 
 from .. import _utils as u, _constants as c
 from .._schemas import response_models as rm
 from .._parameter_sets import ParameterSet
 from .._exceptions import ConfigurationError, InvalidInputError
-from .._manifest import PermissionScope
+from .._manifest import PermissionScope, AuthenticationEnforcement
 from .._version import __version__
 from .._schemas.query_param_models import get_query_models_for_parameters
-from .._auth import BaseUser
+from .._schemas.auth_models import AbstractUser
 from .base import RouteBase
 
 
@@ -34,13 +35,13 @@ class ProjectRoutes(RouteBase):
 
     async def _get_parameters_helper(
         self, parameters_tuple: tuple[str, ...] | None, entity_type: str, entity_name: str, entity_scope: PermissionScope,
-        user: BaseUser | None, selections: tuple[tuple[str, Any], ...]
+        user: AbstractUser, selections: tuple[tuple[str, Any], ...]
     ) -> ParameterSet:
         """Helper for getting parameters"""
         selections_dict = dict(selections)
         if "x_parent_param" not in selections_dict:
             if len(selections_dict) > 1:
-                raise InvalidInputError(400, "Invalid input for cascading parameters", f"The parameters endpoint takes at most 1 widget parameter selection (unless x_parent_param is provided). Got {selections_dict}")
+                raise InvalidInputError(400, "invalid_input_for_cascading_parameters", f"The parameters endpoint takes at most 1 widget parameter selection (unless x_parent_param is provided). Got {selections_dict}")
             elif len(selections_dict) == 1:
                 parent_param = next(iter(selections_dict))
                 selections_dict["x_parent_param"] = parent_param
@@ -58,7 +59,7 @@ class ProjectRoutes(RouteBase):
 
     async def _get_parameters_cachable(
         self, parameters_tuple: tuple[str, ...] | None, entity_type: str, entity_name: str, entity_scope: PermissionScope,
-        user: BaseUser | None, selections: tuple[tuple[str, Any], ...]
+        user: AbstractUser, selections: tuple[tuple[str, Any], ...]
     ) -> ParameterSet:
         """Cachable version of parameters helper"""
         return await self.do_cachable_action(
@@ -66,9 +67,13 @@ class ProjectRoutes(RouteBase):
         )
         
     def setup_routes(
-        self, app: FastAPI, mcp: FastMCP, project_metadata_path: str, project_name: str, project_version: str, param_fields: dict
+        self, app: FastAPI, mcp: FastMCP, project_metadata_path: str, project_name: str, project_version: str, project_label: str, param_fields: dict
     ):
         """Setup project metadata routes"""
+
+        elevated_access_level = self.project._elevated_access_level
+        if elevated_access_level != "admin":
+            self.logger.warning(f"{c.SQRL_PERMISSIONS_ELEVATED_ACCESS_LEVEL} has been set to a non-admin access level. For security reasons, DO NOT expose the APIs for this app publicly!")
         
         # Project metadata endpoint
         @app.get(project_metadata_path, tags=["Project Metadata"], response_class=JSONResponse)
@@ -78,37 +83,54 @@ class ProjectRoutes(RouteBase):
                 version=project_version,
                 label=self.manifest_cfg.project_variables.label,
                 description=self.manifest_cfg.project_variables.description,
+                elevated_access_level=elevated_access_level,
+                redoc_path=project_metadata_path + "/redoc",
+                swagger_path=project_metadata_path + "/docs",
+                mcp_server_path=project_metadata_path + "/mcp",
                 squirrels_version=__version__
             )
         
         # Data catalog endpoint
         data_catalog_path = project_metadata_path + '/data-catalog'
         
-        async def get_data_catalog0(user: BaseUser | None) -> rm.CatalogModel:
+        async def get_data_catalog0(user: AbstractUser) -> rm.CatalogModel:
             parameters = self.param_cfg_set.apply_selections(None, {}, user)
             parameters_model = parameters.to_api_response_model0()
             full_parameters_list = [p.name for p in parameters_model.parameters]
+            user_has_elevated_privileges = u.user_has_elevated_privileges(user.access_level, elevated_access_level)
 
             dataset_items: list[rm.DatasetItemModel] = []
             for name, config in self.manifest_cfg.datasets.items():
                 if self.authenticator.can_user_access_scope(user, config.scope):
-                    name_normalized = u.normalize_name_for_api(name)
+                    name_for_api = u.normalize_name_for_api(name)
                     metadata = self.project.dataset_metadata(name).to_json()
                     parameters = config.parameters if config.parameters is not None else full_parameters_list
+                    
+                    # Build dataset-specific configurables list
+                    if user_has_elevated_privileges:
+                        dataset_configurables_defaults = self.manifest_cfg.get_default_configurables(name)
+                        dataset_configurables_list = [
+                            rm.ConfigurableDefaultModel(name=name, default=default)
+                            for name, default in dataset_configurables_defaults.items()
+                        ]
+                    else:
+                        dataset_configurables_list = []
+                    
                     dataset_items.append(rm.DatasetItemModel(
-                        name=name_normalized, label=config.label, 
+                        name=name, label=config.label, 
                         description=config.description,
                         schema=metadata["schema"], # type: ignore
+                        configurables=dataset_configurables_list,
                         parameters=parameters,
-                        parameters_path=f"{project_metadata_path}/dataset/{name_normalized}/parameters",
-                        result_path=f"{project_metadata_path}/dataset/{name_normalized}"
+                        parameters_path=f"{project_metadata_path}/dataset/{name_for_api}/parameters",
+                        result_path=f"{project_metadata_path}/dataset/{name_for_api}"
                     ))
             
             dashboard_items: list[rm.DashboardItemModel] = []
             for name, dashboard in self.project._dashboards.items():
                 config = dashboard.config
                 if self.authenticator.can_user_access_scope(user, config.scope):
-                    name_normalized = u.normalize_name_for_api(name)
+                    name_for_api = u.normalize_name_for_api(name)
 
                     try:
                         dashboard_format = self.project._dashboards[name].get_dashboard_format()
@@ -121,19 +143,24 @@ class ProjectRoutes(RouteBase):
                         description=config.description, 
                         result_format=dashboard_format,
                         parameters=parameters,
-                        parameters_path=f"{project_metadata_path}/dashboard/{name_normalized}/parameters",
-                        result_path=f"{project_metadata_path}/dashboard/{name_normalized}"
+                        parameters_path=f"{project_metadata_path}/dashboard/{name_for_api}/parameters",
+                        result_path=f"{project_metadata_path}/dashboard/{name_for_api}"
                     ))
             
-            if user and user.is_admin:
-                compiled_dag = await self.project._get_compiled_dag(user=user)
+            if user_has_elevated_privileges:
+                compiled_dag = await self.project._get_compiled_dag(user)
                 connections_items = self.project._get_all_connections()
                 data_models = self.project._get_all_data_models(compiled_dag)
                 lineage_items = self.project._get_all_data_lineage(compiled_dag)
+                configurables_list = [
+                    rm.ConfigurableItemModel(name=name, label=cfg.label, default=cfg.default, description=cfg.description)
+                    for name, cfg in self.manifest_cfg.configurables.items()
+                ]
             else:
                 connections_items = []
                 data_models = []
                 lineage_items = []
+                configurables_list = []
 
             return rm.CatalogModel(
                 parameters=parameters_model.parameters, 
@@ -142,29 +169,40 @@ class ProjectRoutes(RouteBase):
                 connections=connections_items,
                 models=data_models,
                 lineage=lineage_items,
+                configurables=configurables_list,
             )
         
         @app.get(data_catalog_path, tags=["Project Metadata"], summary="Get catalog of datasets and dashboards available for user")
-        async def get_data_catalog(request: Request, user: BaseUser | None = Depends(self.get_current_user)) -> rm.CatalogModel:
+        async def get_data_catalog(request: Request, user: AbstractUser = Depends(self.get_current_user)) -> rm.CatalogModel:
             """
             Get catalog of datasets and dashboards available for the authenticated user.
             
             For admin users, this endpoint will also return detailed information about all models and their lineage in the project.
             """
-            return await get_data_catalog0(user)
+            start = time.time()
+
+            # If authentication is required, require user to be authenticated to access catalog
+            if self.manifest_cfg.authentication.enforcement == AuthenticationEnforcement.REQUIRED and user.access_level == "guest":
+                raise InvalidInputError(401, "user_required", "Authentication is required to access the data catalog")
+            data_catalog = await get_data_catalog0(user)
+            
+            self.logger.log_activity_time("GET REQUEST for DATA CATALOG", start)
+            return data_catalog
         
         @mcp.tool(
-            name=f"get_data_catalog_for_{project_name}_{project_version}", 
-            description=f"Use this tool to get the details of all datasets and parameters you can access in the Squirrels project '{project_name}'."
+            name=f"get_data_catalog_from_{project_name}", 
+            title=f"Get Data Catalog (Project: {project_label})",
+            description=dedent(f"""
+            Use this tool to get the details of all datasets and parameters you can access in the Squirrels project '{project_name}'.
+            
+            Unless the data catalog for this project has already been provided, use this tool at the start of each conversation.
+            """).strip()
         )
-        async def get_data_catalog_tool(ctx: Context):
-            user = self.get_user_from_tool_ctx(ctx)
+        async def get_data_catalog_tool(ctx: Context) -> rm.CatalogModelForTool:
+            headers = self.get_headers_from_tool_ctx(ctx)
+            user = self.get_user_from_tool_headers(headers)
             data_catalog = await get_data_catalog0(user)
-            restricted_data_catalog = {
-                "parameters": data_catalog.parameters,
-                "datasets": data_catalog.datasets,
-            }
-            return restricted_data_catalog
+            return rm.CatalogModelForTool(parameters=data_catalog.parameters, datasets=data_catalog.datasets)
         
         # Project-level parameters endpoints
         project_level_parameters_path = project_metadata_path + '/parameters'
@@ -177,9 +215,9 @@ class ProjectRoutes(RouteBase):
 
         async def get_parameters_definition(
             parameters_list: list[str] | None, entity_type: str, entity_name: str, entity_scope: PermissionScope,
-            user, all_request_params: dict, params: dict
+            user: AbstractUser, all_request_params: dict, params: dict, *, headers: dict[str, str]
         ) -> rm.ParametersModel:
-            self._validate_request_params(all_request_params, params)
+            self._validate_request_params(all_request_params, params, headers)
 
             get_parameters_function = self._get_parameters_helper if self.no_cache else self._get_parameters_cachable
             selections = self.get_selections_as_immutable(params, uncached_keys={"x_verify_params"})
@@ -193,9 +231,9 @@ class ProjectRoutes(RouteBase):
         ) -> rm.ParametersModel:
             start = time.time()
             result = await get_parameters_definition(
-                None, "project", "", PermissionScope.PUBLIC, user, dict(request.query_params), asdict(params)
+                None, "project", "", PermissionScope.PUBLIC, user, dict(request.query_params), asdict(params), headers=dict(request.headers)
             )
-            self.log_activity_time("GET REQUEST for PROJECT PARAMETERS", start, request)
+            self.logger.log_activity_time("GET REQUEST for PROJECT PARAMETERS", start)
             return result
 
         @app.post(project_level_parameters_path, tags=["Project Metadata"], description=parameters_description)
@@ -205,9 +243,9 @@ class ProjectRoutes(RouteBase):
             start = time.time()
             payload: dict = await request.json()
             result = await get_parameters_definition(
-                None, "project", "", PermissionScope.PUBLIC, user, payload, params.model_dump()
+                None, "project", "", PermissionScope.PUBLIC, user, payload, params.model_dump(), headers=dict(request.headers)
             )
-            self.log_activity_time("POST REQUEST for PROJECT PARAMETERS", start, request)
+            self.logger.log_activity_time("POST REQUEST for PROJECT PARAMETERS", start)
             return result
         
         return get_parameters_definition

squirrels/_api_server.py

@@ -1,6 +1,8 @@
 from fastapi import FastAPI, Request, status
-from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.responses import JSONResponse, HTMLResponse, RedirectResponse
 from fastapi.security import HTTPBearer
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response as StarletteResponse
 from contextlib import asynccontextmanager
@@ -8,12 +10,13 @@ from argparse import Namespace
 from pathlib import Path
 from starlette.middleware.sessions import SessionMiddleware
 from mcp.server.fastmcp import FastMCP
-import io, time, mimetypes, traceback, uuid, asyncio, urllib.parse, contextlib
+import io, time, mimetypes, traceback, uuid, asyncio, contextlib
 
-from . import _constants as c, _utils as u
+from . import _constants as c, _utils as u, _parameter_sets as ps
 from ._exceptions import InvalidInputError, ConfigurationError, FileExecutionError
 from ._version import __version__, sq_major_version
 from ._project import SquirrelsProject
+from ._request_context import set_request_id
 
 # Import route modules
 from ._api_routes.auth import AuthRoutes
@@ -21,7 +24,9 @@ from ._api_routes.project import ProjectRoutes
 from ._api_routes.datasets import DatasetRoutes
 from ._api_routes.dashboards import DashboardRoutes
 from ._api_routes.data_management import DataManagementRoutes
-from ._api_routes.oauth2 import OAuth2Routes
+
+# # Disabled for now, a 'bring your own OAuth2 server' approach will be provided in the future
+# from ._api_routes.oauth2 import OAuth2Routes 
 
 mimetypes.add_type('application/javascript', '.js')
 
@@ -32,10 +37,13 @@ class SmartCORSMiddleware(BaseHTTPMiddleware):
     while still allowing all other origins without credentials.
     """
     
-    def __init__(self, app, allowed_credential_origins: list[str] | None = None):
+    def __init__(self, app, allowed_credential_origins: list[str], configurables_as_headers: list[str]):
         super().__init__(app)
-        # Origins that are allowed to send credentials (cookies, auth headers)
-        self.allowed_credential_origins = allowed_credential_origins or []
+
+        allowed_predefined_headers = ["Authorization", "Content-Type", "x-api-key", "x-orientation", "x-verify-params"]
+        
+        self.allowed_credential_origins = allowed_credential_origins
+        self.allowed_request_headers = ",".join(allowed_predefined_headers + configurables_as_headers)
     
     async def dispatch(self, request: Request, call_next):
         origin = request.headers.get("origin")
@@ -44,7 +52,7 @@ class SmartCORSMiddleware(BaseHTTPMiddleware):
         if request.method == "OPTIONS":
             response = StarletteResponse(status_code=200) 
             response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
-            response.headers["Access-Control-Allow-Headers"] = "Authorization, Content-Type"
+            response.headers["Access-Control-Allow-Headers"] = self.allowed_request_headers
         
         else:
             # Call the next middleware/route
@@ -54,7 +62,7 @@ class SmartCORSMiddleware(BaseHTTPMiddleware):
             response.headers["Access-Control-Expose-Headers"] = "Applied-Username"
         
         if origin:
-            scheme = "http" if request.url.hostname in ["localhost", "127.0.0.1"] else "https"
+            scheme = u.get_scheme(request.url.hostname)
             request_origin = f"{scheme}://{request.url.netloc}"
             # Check if this origin is in the whitelist or if origin matches the host origin
             if origin == request_origin or origin in self.allowed_credential_origins:
@@ -93,11 +101,14 @@ class ApiServer:
         self.context_func = project._context_func
         self.dashboards = project._dashboards
         
-        self.mcp = FastMCP(name="Squirrels", stateless_http=True)
+        self.mcp = FastMCP(
+            name="Squirrels",
+            stateless_http=True
+        )
 
         # Initialize route modules
         get_bearer_token = HTTPBearer(auto_error=False)
-        self.oauth2_routes = OAuth2Routes(get_bearer_token, project, no_cache)
+        # self.oauth2_routes = OAuth2Routes(get_bearer_token, project, no_cache)
         self.auth_routes = AuthRoutes(get_bearer_token, project, no_cache)
         self.project_routes = ProjectRoutes(get_bearer_token, project, no_cache)
         self.dataset_routes = DatasetRoutes(get_bearer_token, project, no_cache)
@@ -105,37 +116,63 @@ class ApiServer:
         self.data_management_routes = DataManagementRoutes(get_bearer_token, project, no_cache)
     
     
-    async def _monitor_for_staging_file(self) -> None:
-        """Background task that monitors for staging file and renames it when present"""
-        duckdb_venv_path = self.project._duckdb_venv_path
-        staging_file = Path(duckdb_venv_path + ".stg")
-        target_file = Path(duckdb_venv_path)
-                
+    async def _refresh_datasource_params(self) -> None:
+        """
+        Background task to periodically refresh datasource parameter options.
+        Runs every N minutes as configured by SQRL_PARAMETERS__DATASOURCE_REFRESH_MINUTES (default: 60).
+        """
+        refresh_minutes_str = self.env_vars.get(c.SQRL_PARAMETERS_DATASOURCE_REFRESH_MINUTES, "60")
+        try:
+            refresh_minutes = int(refresh_minutes_str)
+            if refresh_minutes <= 0:
+                self.logger.info(f"The value of {c.SQRL_PARAMETERS_DATASOURCE_REFRESH_MINUTES} is: {refresh_minutes_str} minutes")
+                self.logger.info(f"Datasource parameter refresh is disabled since the refresh interval is not positive.")
+                return
+        except ValueError:
+            self.logger.warning(f"Invalid value for {c.SQRL_PARAMETERS_DATASOURCE_REFRESH_MINUTES}: {refresh_minutes_str}. Must be an integer. Disabling datasource parameter refresh.")
+            return
+        
+        refresh_seconds = refresh_minutes * 60
+        self.logger.info(f"Starting datasource parameter refresh background task (every {refresh_minutes} minutes)")
+        
         while True:
             try:
-                if staging_file.exists():
-                    try:
-                        staging_file.replace(target_file)
-                        self.logger.info("Successfully renamed staging database to virtual environment database")
-                    except OSError:
-                        # Silently continue if file cannot be renamed (will retry next iteration)
-                        pass
+                await asyncio.sleep(refresh_seconds)
+                self.logger.info("Refreshing datasource parameter options...")
+                
+                # Fetch fresh dataframes from datasources in a thread pool to avoid blocking
+                loop = asyncio.get_running_loop()
+                default_conn_name = self.manifest_cfg.env_vars.get(c.SQRL_CONNECTIONS_DEFAULT_NAME_USED, "default")
+                df_dict = await loop.run_in_executor(
+                    None,
+                    ps.ParameterConfigsSetIO._get_df_dict_from_data_sources,
+                    self.param_cfg_set,
+                    default_conn_name,
+                    self.seeds,
+                    self.conn_set,
+                    self.project._datalake_db_path
+                )
                 
+                # Re-convert datasource parameters with fresh data
+                self.param_cfg_set._post_process_params(df_dict)
+                
+                self.logger.info("Successfully refreshed datasource parameter options")
+            except asyncio.CancelledError:
+                self.logger.info("Datasource parameter refresh task cancelled")
+                break
             except Exception as e:
-                # Log any unexpected errors but keep running
-                self.logger.error(f"Error in monitoring {c.DUCKDB_VENV_FILE + '.stg'}: {str(e)}")
-            
-            await asyncio.sleep(1)  # Check every second
+                self.logger.error(f"Error refreshing datasource parameter options: {e}", exc_info=True)
+                # Continue the loop even if there's an error
     
     @asynccontextmanager
     async def _run_background_tasks(self, app: FastAPI):
-        task = asyncio.create_task(self._monitor_for_staging_file())
+        refresh_datasource_task = asyncio.create_task(self._refresh_datasource_params())
         
         async with contextlib.AsyncExitStack() as stack:
             await stack.enter_async_context(self.mcp.session_manager.run())
             yield
         
-        task.cancel()
+        refresh_datasource_task.cancel()
 
 
     def _get_tags_metadata(self) -> list[dict]:
@@ -171,10 +208,10 @@ class ApiServer:
                 "name": "User Management",
                 "description": "Manage users and their attributes",
             },
-            {
-                "name": "OAuth2",
-                "description": "Authorize and get token using the OAuth2 protocol",
-            },
+            # {
+            #     "name": "OAuth2",
+            #     "description": "Authorize and get token using the OAuth2 protocol",
+            # },
         ])
         return tags_metadata
     
@@ -188,17 +225,19 @@ class ApiServer:
         """
         start = time.time()
         
-        squirrels_version_path = f'/api/squirrels-v{sq_major_version}'
-        project_name = u.normalize_name_for_api(self.manifest_cfg.project_variables.name)
+        squirrels_version_path = f'/api/squirrels/v{sq_major_version}'
+        project_name = self.manifest_cfg.project_variables.name
+        project_name_for_api = u.normalize_name_for_api(project_name)
+        project_label = self.manifest_cfg.project_variables.label
         project_version = f"v{self.manifest_cfg.project_variables.major_version}"
-        project_metadata_path = squirrels_version_path + f"/project/{project_name}/{project_version}"
+        project_metadata_path = squirrels_version_path + f"/project/{project_name_for_api}/{project_version}"
         
         param_fields = self.param_cfg_set.get_all_api_field_info()
 
         tags_metadata = self._get_tags_metadata()
         
         app = FastAPI(
-            title=f"Squirrels APIs for '{self.manifest_cfg.project_variables.label}'", openapi_tags=tags_metadata,
+            title=f"Squirrels APIs for '{project_label}'", openapi_tags=tags_metadata,
             description="For specifying parameter selections to dataset APIs, you can choose between using query parameters with the GET method or using request body with the POST method",
             lifespan=self._run_background_tasks,
             openapi_url=project_metadata_path+"/openapi.json",
@@ -209,29 +248,30 @@ class ApiServer:
         app.add_middleware(SessionMiddleware, secret_key=self.env_vars.get(c.SQRL_SECRET_KEY, ""), max_age=None, same_site="none", https_only=True)
 
         async def _log_request_run(request: Request) -> None:
-            headers = dict(request.scope["headers"])
-            request_id = uuid.uuid4().hex
-            headers[b"x-request-id"] = request_id.encode()
-            request.scope["headers"] = list(headers.items())
-
             try:
                 body = await request.json()
             except Exception:
-                body = None
+                body = None  # Non-JSON payloads may contain sensitive information, so we don't log them
+
+            partial_headers: dict[str, str] = {}
+            for header in request.headers.keys():
+                if header.startswith("x-") and header not in ["x-api-key"]:
+                    partial_headers[header] = request.headers[header]
             
-            headers_dict = dict(request.headers)
             path, params = request.url.path, dict(request.query_params)
             path_with_params = f"{path}?{request.query_params}" if len(params) > 0 else path
-            data = {"request_method": request.method, "request_path": path, "request_params": params, "request_headers": headers_dict, "request_body": body}
-            info = {"request_id": request_id}
-            self.logger.info(f'Running request: {request.method} {path_with_params}', extra={"data": data, "info": info})
+            data = {"request_method": request.method, "request_path": path, "request_params": params, "request_body": body, "partial_headers": partial_headers}
+            self.logger.info(f'Running request: {request.method} {path_with_params}', data=data)
 
         @app.middleware("http")
         async def catch_exceptions_middleware(request: Request, call_next):
+            # Generate and set request ID for this request
+            request_id = set_request_id()
+            
             buffer = io.StringIO()
             try:
                 await _log_request_run(request)
-                return await call_next(request)
+                response = await call_next(request)
             except InvalidInputError as exc:
                 message = str(exc)
                 self.logger.error(message)
@@ -258,7 +298,10 @@ class ApiServer:
             err_msg = buffer.getvalue()
             if err_msg:
                 self.logger.error(err_msg)
-                print(err_msg)
+            
+            # Add request ID to response header
+            response.headers["X-Request-ID"] = request_id
+            
             return response
 
         # Configure CORS with smart credential handling
@@ -266,36 +309,60 @@ class ApiServer:
         credential_origins_env = self.env_vars.get(c.SQRL_AUTH_CREDENTIAL_ORIGINS, "https://squirrels-analytics.github.io")
         allowed_credential_origins = [origin.strip() for origin in credential_origins_env.split(",") if origin.strip()]
         
-        app.add_middleware(SmartCORSMiddleware, allowed_credential_origins=allowed_credential_origins)
+        # Allow both underscore and dash versions of configurable headers
+        configurables_as_headers = []
+        for name in self.manifest_cfg.configurables.keys():
+            configurables_as_headers.append(f"x-config-{name}")  # underscore version
+            configurables_as_headers.append(f"x-config-{u.normalize_name_for_api(name)}")  # dash version
+        
+        app.add_middleware(SmartCORSMiddleware, allowed_credential_origins=allowed_credential_origins, configurables_as_headers=configurables_as_headers)
         
         # Setup route modules
-        self.oauth2_routes.setup_routes(app)
-        self.auth_routes.setup_routes(app)
-        get_parameters_definition = self.project_routes.setup_routes(app, self.mcp, project_metadata_path, project_name, project_version, param_fields)
+        # self.oauth2_routes.setup_routes(app, squirrels_version_path)
+        self.auth_routes.setup_routes(app, squirrels_version_path)
+        get_parameters_definition = self.project_routes.setup_routes(app, self.mcp, project_metadata_path, project_name, project_version, project_label, param_fields)
         self.data_management_routes.setup_routes(app, project_metadata_path, param_fields)
-        self.dataset_routes.setup_routes(app, self.mcp, project_metadata_path, project_name, project_version, param_fields, get_parameters_definition)
+        self.dataset_routes.setup_routes(app, self.mcp, project_metadata_path, project_name, project_label, param_fields, get_parameters_definition)
         self.dashboard_routes.setup_routes(app, project_metadata_path, param_fields, get_parameters_definition)
         app.mount(project_metadata_path, self.mcp.streamable_http_app())
     
+        # Mount static files from public directory if it exists
+        # This allows users to serve static assets (images, CSS, JS, etc.) from {project_path}/public/
+        public_dir = Path(self.project._filepath) / c.PUBLIC_FOLDER
+        if public_dir.exists() and public_dir.is_dir():
+            app.mount("/public", StaticFiles(directory=str(public_dir)), name="public")
+            self.logger.info(f"Mounted static files from: {public_dir}")
+    
         # Add Root Path Redirection to Squirrels Studio
         full_hostname = f"http://{uvicorn_args.host}:{uvicorn_args.port}"
-        encoded_hostname = urllib.parse.quote(full_hostname, safe="")
-        squirrels_studio_params = f"host={encoded_hostname}&projectName={project_name}&projectVersion={project_version}"
-        squirrels_studio_url = f"https://squirrels-analytics.github.io/squirrels-studio-v1/#/login?{squirrels_studio_params}"
+        squirrels_studio_path = f"/project/{project_name_for_api}/{project_version}/studio"
+        templates = Jinja2Templates(directory=str(Path(__file__).parent / "_package_data" / "templates"))
+
+        @app.get(squirrels_studio_path, include_in_schema=False)
+        async def squirrels_studio():
+            default_studio_path = "https://squirrels-analytics.github.io/squirrels-studio-v1"
+            sqrl_studio_base_url = self.env_vars.get(c.SQRL_STUDIO_BASE_URL, default_studio_path)
+            context = {
+                "sqrl_studio_base_url": sqrl_studio_base_url,
+                "project_name": project_name_for_api,
+                "project_version": project_version,
+            }
+            return HTMLResponse(content=templates.get_template("squirrels_studio.html").render(context))
         
         @app.get("/", include_in_schema=False)
         async def redirect_to_studio():
-            return RedirectResponse(url=squirrels_studio_url)
+            return RedirectResponse(url=squirrels_studio_path)
+
+        self.logger.log_activity_time("creating app server", start)
 
         # Run the API Server
         import uvicorn
         
         print("\nWelcome to the Squirrels Data Application!\n")
-        print(f"- Application UI: {squirrels_studio_url}")
+        print(f"- Application UI (Squirrels Studio): {full_hostname}{squirrels_studio_path}")
         print(f"- API Docs (with ReDoc): {full_hostname}{project_metadata_path}/redoc")
         print(f"- API Docs (with Swagger UI): {full_hostname}{project_metadata_path}/docs")
+        print(f"- MCP Server URL: {full_hostname}{project_metadata_path}/mcp")
         print()
         
-        self.logger.log_activity_time("creating app server", start)
-        uvicorn.run(app, host=uvicorn_args.host, port=uvicorn_args.port)
-    
+        uvicorn.run(app, host=uvicorn_args.host, port=uvicorn_args.port, proxy_headers=True, forwarded_allow_ips="*")

squirrels/_arguments/run_time_args.py

@@ -2,7 +2,7 @@ from typing import Callable, Any, Coroutine
 import polars as pl
 
 from .init_time_args import ParametersArgs, BuildModelArgs
-from .._auth import BaseUser
+from .._schemas.auth_models import AbstractUser
 from .._parameters import Parameter, TextValue
 
 
@@ -10,14 +10,14 @@ class ContextArgs(ParametersArgs):
 
     def __init__(
         self, param_args: ParametersArgs, 
-        user: BaseUser | None, 
-        prms: dict[str, Parameter], 
-        traits: dict[str, Any]
+        user: AbstractUser, 
+        prms: dict[str, Parameter],
+        configurables: dict[str, str]
     ):
         super().__init__(param_args.project_path, param_args.proj_vars, param_args.env_vars)
         self.user = user
         self._prms = prms
-        self._traits = traits
+        self._configurables = configurables
         self._placeholders = {}
 
     @property
@@ -28,11 +28,11 @@ class ContextArgs(ParametersArgs):
         return self._prms.copy()
     
     @property
-    def traits(self) -> dict[str, Any]:
+    def configurables(self) -> dict[str, str]:
         """
-        A dictionary of dataset trait name to value
+        A dictionary of configurable name to value (set by application)
         """
-        return self._traits.copy()
+        return self._configurables.copy()
 
     @property
     def _placeholders_copy(self) -> dict[str, Any]:
@@ -80,7 +80,7 @@ class ModelArgs(BuildModelArgs, ContextArgs):
         self._env_vars = ctx_args.env_vars
         self.user = ctx_args.user
         self._prms = ctx_args.prms
-        self._traits = ctx_args.traits
+        self._configurables = ctx_args.configurables
         self._placeholders = ctx_args._placeholders_copy
         self._connections = build_model_args.connections
         self._dependencies = build_model_args.dependencies