squirrels 0.5.0b3__py3-none-any.whl → 0.5.0b4__py3-none-any.whl

squirrels/_connection_set.py

@@ -4,7 +4,7 @@ from sqlalchemy import Engine
 import time, polars as pl
 
 from . import _utils as u, _constants as c, _py_module as pm
-from ._arguments._init_time_args import ConnectionsArgs
+from ._arguments.init_time_args import ConnectionsArgs
 from ._manifest import ManifestConfig, ConnectionProperties, ConnectionTypeEnum
 
 

squirrels/_constants.py

@@ -13,6 +13,7 @@ SQRL_SECRET_ADMIN_PASSWORD = 'SQRL_SECRET__ADMIN_PASSWORD'
 
 SQRL_AUTH_DB_FILE_PATH = 'SQRL_AUTH__DB_FILE_PATH'
 SQRL_AUTH_TOKEN_EXPIRE_MINUTES = 'SQRL_AUTH__TOKEN_EXPIRE_MINUTES'
+SQRL_AUTH_CREDENTIAL_ORIGINS = 'SQRL_AUTH__ALLOWED_ORIGINS_FOR_COOKIES'
 
 SQRL_PARAMETERS_CACHE_SIZE = 'SQRL_PARAMETERS__CACHE_SIZE'
 SQRL_PARAMETERS_CACHE_TTL_MINUTES = 'SQRL_PARAMETERS__CACHE_TTL_MINUTES'
@@ -114,3 +115,8 @@ MAIN_FUNC = "main"
 # Regex
 DATE_REGEX = r"^\d{4}\-\d{2}\-\d{2}$"
 COLOR_REGEX = r"^#[0-9a-fA-F]{6}$"
+
+# OAuth2
+SUPPORTED_SCOPES = ['read']
+SUPPORTED_GRANT_TYPES = ['authorization_code', 'refresh_token']
+SUPPORTED_RESPONSE_TYPES = ['code']

squirrels/{_dashboards_io.py → _dashboards.py}

@@ -2,15 +2,96 @@ from typing import Type, TypeVar, Callable, Coroutine, Any
 from enum import Enum
 from dataclasses import dataclass
 from pydantic import BaseModel, Field
-import os, time
+import matplotlib.figure as figure
+import os, time, io, abc, typing
 
-from ._arguments._run_time_args import DashboardArgs
+from ._arguments.run_time_args import DashboardArgs
 from ._py_module import PyModule
 from ._manifest import AnalyticsOutputConfig
 from ._exceptions import InvalidInputError, ConfigurationError, FileExecutionError
-from . import _constants as c, _dashboard_types as d, _utils as u
+from . import _constants as c, _utils as u
 
-T = TypeVar('T', bound=d.Dashboard)
+
+class Dashboard(metaclass=abc.ABCMeta):
+    """
+    Abstract parent class for all Dashboard classes.
+    """
+    
+    @property
+    @abc.abstractmethod
+    def _content(self) -> bytes | str:
+        pass
+    
+    @property
+    @abc.abstractmethod
+    def _format(self) -> str:
+        pass
+
+
+class PngDashboard(Dashboard):
+    """
+    Instantiate a Dashboard in PNG format from a matplotlib figure or bytes
+    """
+    
+    def __init__(self, content: figure.Figure | io.BytesIO | bytes) -> None:
+        """
+        Constructor for PngDashboard
+
+        Arguments:
+            content: The content of the dashboard as a matplotlib.figure.Figure or bytes
+        """
+        if isinstance(content, figure.Figure):
+            buffer = io.BytesIO()
+            content.savefig(buffer, format=c.PNG)
+            content = buffer.getvalue()
+        
+        if isinstance(content, io.BytesIO):
+            content = content.getvalue()
+        
+        self.__content = content
+
+    @property
+    def _content(self) -> bytes:
+        return self.__content
+    
+    @property
+    def _format(self) -> typing.Literal['png']:
+        return c.PNG
+    
+    def _repr_png_(self):
+        return self._content
+    
+
+class HtmlDashboard(Dashboard):
+    """
+    Instantiate a Dashboard from an HTML string
+    """
+
+    def __init__(self, content: io.StringIO | str) -> None:
+        """
+        Constructor for HtmlDashboard
+
+        Arguments:
+            content: The content of the dashboard as HTML string
+        """
+        if isinstance(content, io.StringIO):
+            content = content.getvalue()
+        
+        self.__content = content
+
+    @property
+    def _content(self) -> str:
+        return self.__content
+    
+    @property
+    def _format(self) -> typing.Literal['html']:
+        return c.HTML
+    
+    def _repr_html_(self):
+        return self._content
+
+
+T = TypeVar('T', bound=Dashboard)
 
 
 class DashboardFormat(Enum):
@@ -34,7 +115,7 @@ class DashboardDefinition:
     config: DashboardConfig
 
     @property
-    def dashboard_func(self) -> Callable[[DashboardArgs], Coroutine[Any, Any, d.Dashboard]]:
+    def dashboard_func(self) -> Callable[[DashboardArgs], Coroutine[Any, Any, Dashboard]]:
         if not hasattr(self, '_dashboard_func'):
             module = PyModule(self.filepath)
             self._dashboard_func = module.get_func_or_class(c.MAIN_FUNC)
@@ -43,7 +124,7 @@ class DashboardDefinition:
     def get_dashboard_format(self) -> str:
         return self.config.format.value
     
-    async def get_dashboard(self, args: DashboardArgs, *, dashboard_type: Type[T] = d.Dashboard) -> T:
+    async def get_dashboard(self, args: DashboardArgs, *, dashboard_type: Type[T] = Dashboard) -> T:
         try:
             dashboard = await self.dashboard_func(args)
             assert isinstance(dashboard, dashboard_type), f"Function does not return expected Dashboard type: {dashboard_type}"

squirrels/_exceptions.py

@@ -2,44 +2,16 @@ class InvalidInputError(Exception):
     """
     Use this exception when the error is due to providing invalid inputs to the REST API
 
-    Specific error code ranges are reserved for specific categories of errors.
-    0-19: 401 unauthorized errors
-    20-39: 403 forbidden errors
-    40-59: 404 not found errors
-    60-69: 409 conflict errors
-    70-99: Reserved for future use
-    100-199: 400 bad request errors related to authentication
-    200-299: 400 bad request errors related to data analytics
-
-    Error code definitions:
-    0 - Incorrect username or password
-    1 - Invalid authorization token
-    2 - Username not found for password change
-    3 - Incorrect password for password change
-    20 - Authorized user is forbidden to add or update users
-    21 - Authorized user is forbidden to delete users
-    22 - Cannot delete your own user
-    23 - Cannot delete the admin user
-    24 - Setting the admin user to non-admin is not permitted
-    25 - User does not have permission to access the dataset / dashboard
-    26 - User does not have permission to build the virtual data environment
-    27 - User does not have permission to query data models
-    40 - No token found for token_id
-    41 - No user found for username
-    60 - An existing build process is already running and a concurrent build is not allowed
-    61 - Model depends on static data models that cannot be found
-    100 - Missing required field 'username' or 'password' when adding a new user
-    101 - Username already exists when adding a new user
-    102 - Invalid user data when adding a new user
-    200 - Invalid value for dataset parameter
-    201 - Invalid query parameter provided
-    202 - Could not determine parent parameter for parameter refresh
-    203 - SQL query must be provided
-    204 - Failed to run provided SQL query
+    Attributes:
+        status_code: The HTTP status code to return
+        error: A short error message that should never change in the future
+        error_description: A detailed error message (that is allowed to change in the future)
     """
-    def __init__(self, error_code: int, message: str, *args) -> None:
-        self.error_code = error_code
-        super().__init__(message, *args)
+    def __init__(self, status_code: int, error: str, error_description: str, *args) -> None:
+        self.status_code = status_code
+        self.error = error
+        self.error_description = error_description
+        super().__init__(error_description, *args)
 
 
 class ConfigurationError(Exception):

squirrels/_model_builder.py

@@ -68,7 +68,7 @@ class ModelBuilder:
         # If the development copy is already in use, a concurrent build is not allowed
         duckdb_dev_lock_path = u.Path(self._duckdb_venv_path + ".dev.lock")
         if duckdb_dev_lock_path.exists():
-            raise InvalidInputError(60, "An existing build process is already running and a concurrent build is not allowed")
+            raise InvalidInputError(409, "Concurrent build not allowed", "An existing build process is already running and a concurrent build is not allowed")
         duckdb_dev_lock_path.touch(exist_ok=False)
         
         # Ensure the lock file is deleted even if an exception is raised

squirrels/_model_queries.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
 from typing import Callable, Generic, TypeVar, Any
 import polars as pl, pandas as pd
 
-from ._arguments._run_time_args import BuildModelArgs
+from ._arguments.run_time_args import BuildModelArgs
 from ._model_configs import ModelConfig
 
 

squirrels/_models.py

@@ -7,9 +7,10 @@ from pathlib import Path
 import asyncio, os, re, time, duckdb, sqlglot
 import polars as pl, pandas as pd, networkx as nx
 
-from . import _constants as c, _utils as u, _py_module as pm, _model_queries as mq, _model_configs as mc, _sources as src, _api_response_models as arm
+from . import _constants as c, _utils as u, _py_module as pm, _model_queries as mq, _model_configs as mc, _sources as src
+from ._schemas import response_models as rm
 from ._exceptions import FileExecutionError, InvalidInputError
-from ._arguments._run_time_args import ContextArgs, ModelArgs, BuildModelArgs
+from ._arguments.run_time_args import ContextArgs, ModelArgs, BuildModelArgs
 from ._auth import BaseUser
 from ._connection_set import ConnectionsArgs, ConnectionSet, ConnectionProperties
 from ._manifest import DatasetConfig
@@ -173,7 +174,7 @@ class StaticModel(DataModel):
         try:
             return self._load_duckdb_view_to_python_df(local_conn, use_venv=True)
         except Exception as e:
-            raise InvalidInputError(61, f'Model "{self.name}" depends on static data models that cannot be found.')
+            raise InvalidInputError(409, f'Dependent data model not found.', f'Model "{self.name}" depends on static data models that cannot be found. Trying building the virtual data environment first.')
         finally:
             local_conn.close()
     
@@ -531,7 +532,7 @@ class DbviewModel(QueryModel):
                         self.logger.info(f"Running dbview '{self.name}' on duckdb")
                         return local_conn.sql(query, params=placeholders).pl()
                     except duckdb.CatalogException as e:
-                        raise InvalidInputError(61, f'Model "{self.name}" depends on static data models that cannot be found.')
+                        raise InvalidInputError(409, f'Dependent data model not found.', f'Model "{self.name}" depends on static data models that cannot be found. Trying building the virtual data environment first.')
                     except Exception as e:
                         raise RuntimeError(e)
                     finally:
@@ -657,10 +658,10 @@ class FederateModel(QueryModel):
                 try:
                     return local_conn.execute(create_query, existing_placeholders)
                 except duckdb.CatalogException as e:
-                    raise InvalidInputError(61, f'Model "{self.name}" depends on static data models that cannot be found.')
+                    raise InvalidInputError(409, f'Dependent data model not found.', f'Model "{self.name}" depends on static data models that cannot be found. Trying building the virtual data environment first.')
                 except Exception as e:
                     if self.name == "__fake_target":
-                        raise InvalidInputError(204, f"Failed to run provided SQL query")
+                        raise InvalidInputError(400, "Invalid SQL query", f"Failed to run provided SQL query")
                     else:
                         raise FileExecutionError(f'Failed to run federate sql model "{self.name}"', e) from e
             
@@ -960,24 +961,24 @@ class DAG:
         
         return G
     
-    def get_all_data_models(self) -> list[arm.DataModelItem]:
+    def get_all_data_models(self) -> list[rm.DataModelItem]:
         data_models = []
         for model_name, model in self.models_dict.items():
             is_queryable = model.is_queryable
-            data_model = arm.DataModelItem(name=model_name, model_type=model.model_type.value, config=model.model_config, is_queryable=is_queryable)
+            data_model = rm.DataModelItem(name=model_name, model_type=model.model_type.value, config=model.model_config, is_queryable=is_queryable)
             data_models.append(data_model)
         return data_models
     
-    def get_all_model_lineage(self) -> list[arm.LineageRelation]:
+    def get_all_model_lineage(self) -> list[rm.LineageRelation]:
         model_lineage = []
         for model_name, model in self.models_dict.items():
             if not isinstance(model, QueryModel):
                 continue
             for dep_model_name in model.model_config.depends_on:
                 edge_type = "buildtime" if isinstance(model, BuildModel) else "runtime"
-                source_model = arm.LineageNode(name=dep_model_name, type="model")
-                target_model = arm.LineageNode(name=model_name, type="model")
-                model_lineage.append(arm.LineageRelation(type=edge_type, source=source_model, target=target_model))
+                source_model = rm.LineageNode(name=dep_model_name, type="model")
+                target_model = rm.LineageNode(name=model_name, type="model")
+                model_lineage.append(rm.LineageRelation(type=edge_type, source=source_model, target=target_model))
         return model_lineage
 
 

squirrels/_package_data/base_project/.env

@@ -10,6 +10,7 @@ SQRL_SECRET__ADMIN_PASSWORD="{{ random_admin_password }}"
 # (default values are shown below)
 SQRL_AUTH__DB_FILE_PATH="target/auth.sqlite"
 SQRL_AUTH__TOKEN_EXPIRE_MINUTES="30"
+SQRL_AUTH__ALLOWED_ORIGINS_FOR_COOKIES="https://squirrels-analytics.github.io"
 
 SQRL_PARAMETERS__CACHE_SIZE="1024"
 SQRL_PARAMETERS__CACHE_TTL_MINUTES="60"

squirrels/_package_data/base_project/.env.example

@@ -10,6 +10,7 @@ SQRL_SECRET__ADMIN_PASSWORD=""
 # (default values are shown below)
 SQRL_AUTH__DB_FILE_PATH="target/auth.sqlite"
 SQRL_AUTH__TOKEN_EXPIRE_MINUTES="30"
+SQRL_AUTH__ALLOWED_ORIGINS_FOR_COOKIES="https://squirrels-analytics.github.io"
 
 SQRL_PARAMETERS__CACHE_SIZE="1024"
 SQRL_PARAMETERS__CACHE_TTL_MINUTES="60"

squirrels/_package_data/base_project/pyconfigs/parameters.py

@@ -1,98 +1,106 @@
-from squirrels import arguments as args, data_sources as ds, parameter_options as po, parameters as p
+from squirrels import arguments as args, parameters as p, parameter_options as po, data_sources as ds
 
 
-def main(sqrl: args.ParametersArgs) -> None:
-    """
-    Create all widget parameters in this file. If two or more datasets use a different set of parameters, define them all
-    here, and specify the subset of parameters used for each dataset in the "squirrels.yml" file.
-
-    Parameters are created by a factory method associated to the parameter class. For example, "CreateWithOptions" is the factory method used here:
-    > p.SingleSelectParameter.CreateWithOptions(...)
-
-    The parameter classes available are:
-    - SingleSelectParameter, MultiSelectParameter, DateParameter, DateRangeParameter, NumberParameter, NumberRangeParameter, TextParameter
-    
-    The factory methods available are:
-    - CreateSimple, CreateWithOptions, CreateFromSource
-    """
-
-    ## Example of creating SingleSelectParameter and specifying each option by code
-    user_attribute = "role"
-    group_by_options = [
+## Example of creating SingleSelectParameter and specifying each option by code
+@p.SingleSelectParameter.create_with_options(
+    "group_by", "Group By", description="Dimension(s) to aggregate by", user_attribute="role"
+)
+def group_by_options():
+    return [
         po.SelectParameterOption(
             "trans", "Transaction",  
-            columns=["id", "date", "category", "subcategory", "description"],
-            aliases=["_id", "date", "category", "subcategory", "description"], # any alias starting with "_" will not be selected - see context.py for implementation
+            columns=["id","date","category","subcategory","description"],
+            aliases=["_id","date","category","subcategory","description"], # any alias starting with "_" will not be selected - see context.py for implementation
             user_groups=["manager"]
         ),
-        po.SelectParameterOption("day", "Day",            columns=["date"], aliases=["day"],   user_groups=["manager", "employee"]),
-        po.SelectParameterOption("month", "Month",        columns=["month"],                   user_groups=["manager", "employee"]),
-        po.SelectParameterOption("cat", "Category",       columns=["category"],                user_groups=["manager", "employee"]),
-        po.SelectParameterOption("subcat", "Subcategory", columns=["category", "subcategory"], user_groups=["manager", "employee"]),
+        po.SelectParameterOption("day"    , "Day"         , columns=["date"], aliases=["day"]   , user_groups=["manager","employee"]),
+        po.SelectParameterOption("month"  , "Month"       , columns=["month"]                   , user_groups=["manager","employee"]),
+        po.SelectParameterOption("cat"    , "Category"    , columns=["category"]                , user_groups=["manager","employee"]),
+        po.SelectParameterOption("subcat" , "Subcategory" , columns=["category","subcategory"]  , user_groups=["manager","employee"]),
     ]
-    p.SingleSelectParameter.CreateWithOptions(
-        "group_by", "Group By", group_by_options, description="Dimension(s) to aggregate by", user_attribute=user_attribute
-    )
 
-    ## Example of creating NumberParameter with options
-    parent = "group_by"
-    limit_options = [po.NumberParameterOption(0, 1000, increment=10, default_value=1000, parent_option_ids="trans")]
-    p.NumberParameter.CreateWithOptions(
-        "limit", "Max Number of Rows", limit_options, parent_name=parent, description="Maximum number of rows to return"
-    )
 
-    ## Example of creating DateParameter
-    start_date_source = ds.DateDataSource(
+## Example of creating NumberParameter with options
+@p.NumberParameter.create_with_options(
+    "limit", "Max Number of Rows", description="Maximum number of rows to return", parent_name="group_by"
+)
+def limit_options():
+    return [po.NumberParameterOption(0, 1000, increment=10, default_value=1000, parent_option_ids="trans")]
+
+
+## Example of creating DateParameter
+@p.DateParameter.create_from_source(
+    "start_date", "Start Date", description="Start date to filter transactions by"
+)
+def start_date_source():
+    return ds.DateDataSource(
         "SELECT min(date) AS min_date, max(date) AS max_date FROM expenses",
         default_date_col="min_date", min_date_col="min_date", max_date_col="max_date"
     )
-    p.DateParameter.CreateFromSource(
-        "start_date", "Start Date", start_date_source, description="Start date to filter transactions by"
-    )
 
-    ## Example of creating DateParameter from list of DateParameterOption's
-    end_date_option = [po.DateParameterOption("2024-12-31", min_date="2024-01-01", max_date="2024-12-31")]
-    p.DateParameter.CreateWithOptions(
-        "end_date", "End Date", end_date_option, description="End date to filter transactions by"
-    )
 
-    ## Example of creating DateRangeParameter
-    p.DateRangeParameter.CreateSimple(
-        "date_range", "Date Range", "2024-01-01", "2024-12-31", min_date="2024-01-01", max_date="2024-12-31",
-        description="Date range to filter transactions by"
-    )
+## Example of creating DateParameter from list of DateParameterOption's
+@p.DateParameter.create_with_options(
+    "end_date", "End Date", description="End date to filter transactions by"
+)
+def end_date_options():
+    return [po.DateParameterOption("2024-12-31", min_date="2024-01-01", max_date="2024-12-31")]
 
-    ## Example of creating MultiSelectParameter from lookup query/table
-    category_ds = ds.SelectDataSource("seed_categories", "category_id", "category", from_seeds=True)
-    p.MultiSelectParameter.CreateFromSource(
-        "category", "Category Filter", category_ds, description="The expense categories to filter transactions by"
-    )
 
-    ## Example of creating MultiSelectParameter with parent from lookup query/table
-    parent_name = "category"
-    subcategory_ds = ds.SelectDataSource(
+## Example of creating DateRangeParameter
+@p.DateRangeParameter.create_simple(
+    "date_range", "Date Range", "2024-01-01", "2024-12-31", min_date="2024-01-01", max_date="2024-12-31",
+    description="Date range to filter transactions by"
+)
+def date_range_options():
+    pass
+
+
+## Example of creating MultiSelectParameter from lookup query/table
+@p.MultiSelectParameter.create_from_source(
+    "category", "Category Filter", 
+    description="The expense categories to filter transactions by"
+)
+def category_source():
+    return ds.SelectDataSource("seed_categories", "category_id", "category", from_seeds=True)
+
+
+## Example of creating MultiSelectParameter with parent from lookup query/table
+@p.MultiSelectParameter.create_from_source(
+    "subcategory", "Subcategory Filter", parent_name="category",
+    description="The expense subcategories to filter transactions by (available options are based on selected value(s) of 'Category Filter')"
+)
+def subcategory_source():
+    return ds.SelectDataSource(
         "seed_subcategories", "subcategory_id", "subcategory", from_seeds=True, parent_id_col="category_id"
     )
-    p.MultiSelectParameter.CreateFromSource(
-        "subcategory", "Subcategory Filter", subcategory_ds, parent_name=parent_name,
-        description="The expense subcategories to filter transactions by (available options are based on selected value(s) of 'Category Filter')"
-    )
 
-    ## Example of creating NumberParameter
-    p.NumberParameter.CreateSimple(
-        "min_filter", "Amounts Greater Than", min_value=0, max_value=300, increment=10,
-        description="Number to filter on transactions with an amount greater than this value"
-    )
-    
-    ## Example of creating NumberParameter from lookup query/table
+
+## Example of creating NumberParameter
+@p.NumberParameter.create_simple(
+    "min_filter", "Amounts Greater Than", min_value=0, max_value=300, increment=10,
+    description="Number to filter on transactions with an amount greater than this value"
+)
+def min_filter_options():
+    pass
+
+
+## Example of creating NumberParameter from lookup query/table
+@p.NumberParameter.create_from_source(
+    "max_filter", "Amounts Less Than",
+    description="Number to filter on transactions with an amount less than this value"
+)
+def max_filter_source():
     query = "SELECT 0 as min_value, 300 as max_value, 10 as increment"
-    max_amount_ds = ds.NumberDataSource(query, "min_value", "max_value", increment_col="increment", default_value_col="max_value")
-    p.NumberParameter.CreateFromSource(
-        "max_filter", "Amounts Less Than", max_amount_ds, description="Number to filter on transactions with an amount less than this value"
+    return ds.NumberDataSource(
+        query, "min_value", "max_value", increment_col="increment", default_value_col="max_value"
     )
 
-    ## Example of creating NumberRangeParameter
-    p.NumberRangeParameter.CreateSimple(
-        "between_filter", "Amounts Between", 0, 300, default_lower_value=0, default_upper_value=300,
-        description="Number range to filter on transactions with an amount within this range"
-    )
+
+## Example of creating NumberRangeParameter
+@p.NumberRangeParameter.create_simple(
+    "between_filter", "Amounts Between", min_value=0, max_value=300, default_lower_value=0, default_upper_value=300,
+    description="Number range to filter on transactions with an amount within this range"
+)
+def between_filter_options():
+    pass

squirrels/_package_data/base_project/pyconfigs/user.py

@@ -1,8 +1,8 @@
 from typing import Literal
-from squirrels import types as t
+from squirrels import auth, arguments as args
 
 
-class User(t.BaseUser):
+class User(auth.BaseUser):
     """
     Extend the BaseUser class with custom attributes. The attributes defined here will be added as columns to the users table. 
     - Only the following types are supported: [str, int, float, bool, typing.Literal]
@@ -21,3 +21,31 @@ class User(t.BaseUser):
         However, you can choose to drop columns by adding them to this list.
         """
         return []
+
+
+# @auth.provider(name="google", label="Google", icon="https://www.google.com/favicon.ico")
+def google_auth_provider(sqrl: args.AuthProviderArgs) -> auth.ProviderConfigs:
+    """
+    Provider configs for authenticating a user using Google credentials.
+
+    See the following page for setting up the CLIENT_ID and CLIENT_SECRET for Google specifically: 
+    https://support.google.com/googleapi/answer/6158849?hl=en
+    """
+    def get_sqrl_user(claims: dict) -> User:
+        return User(
+            username=claims["email"],
+            is_admin=False,
+            role="employee"
+        )
+
+    # TODO: Add GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to the .env file
+    # Then, uncomment the @auth.provider decorator above and set the client_id and client_secret below
+    provider_configs = auth.ProviderConfigs(
+        client_id="", # sqrl.env_vars["GOOGLE_CLIENT_ID"],
+        client_secret="", # sqrl.env_vars["GOOGLE_CLIENT_SECRET"],
+        server_metadata_url="https://accounts.google.com/.well-known/openid-configuration",
+        client_kwargs={"scope": "openid email profile"},
+        get_user=get_sqrl_user
+    )
+
+    return provider_configs

squirrels/_package_data/templates/dataset_results.html

@@ -0,0 +1,112 @@
+<style>
+    .dataset-results {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+        background: white;
+        border-radius: 8px;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+        overflow: hidden;
+        max-width: 100%;
+    }
+
+    .dataset-results .table-container {
+        overflow: auto;
+        max-height: 400px;
+        background: white;
+    }
+
+    .dataset-results .data-table {
+        width: 100%;
+        border-collapse: collapse;
+        font-size: 13px;
+    }
+
+    .dataset-results .data-table thead {
+        background: #f8f9fa;
+        position: sticky;
+        top: 0;
+        z-index: 10;
+    }
+
+    .dataset-results .data-table th {
+        padding: 8px 12px;
+        text-align: left;
+        font-weight: 600;
+        color: #374151;
+        border-bottom: 2px solid #e1e5e9;
+        white-space: nowrap;
+        font-size: 12px;
+    }
+
+    .dataset-results .data-table th .column-type {
+        display: block;
+        font-size: 10px;
+        color: #6b7280;
+        font-weight: 400;
+        margin-top: 1px;
+    }
+
+    .dataset-results .data-table td {
+        padding: 8px 12px;
+        border-bottom: 1px solid #f3f4f6;
+        color: #374151;
+        vertical-align: top;
+        font-size: 12px;
+    }
+
+    .dataset-results .data-table tbody tr:hover {
+        background: #f8f9fa;
+    }
+
+    .dataset-results .data-table tbody tr:nth-child(even) {
+        background: #fafbfc;
+    }
+
+    .dataset-results .data-table tbody tr:nth-child(even):hover {
+        background: #f1f3f4;
+    }
+
+    .dataset-results .empty-state {
+        text-align: center;
+        padding: 40px 20px;
+        color: #6b7280;
+    }
+
+    .dataset-results .empty-state h3 {
+        font-size: 16px;
+        margin-bottom: 6px;
+        color: #374151;
+    }
+</style>
+
+<div class="dataset-results">
+    {% if schema.fields and data %}
+    <div class="table-container">
+        <table class="data-table">
+            <thead>
+                <tr>
+                    {% for field in schema.fields %}
+                    <th>
+                        {{ field.name }}
+                        <span class="column-type">{{ field.type | upper }}</span>
+                    </th>
+                    {% endfor %}
+                </tr>
+            </thead>
+            <tbody>
+                {% for row in data %}
+                <tr>
+                    {% for cell in row %}
+                    <td>{{ cell if cell is not none else '' }}</td>
+                    {% endfor %}
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+    {% else %}
+    <div class="empty-state">
+        <h3>No Data Available</h3>
+        <p>This dataset returned no results.</p>
+    </div>
+    {% endif %}
+</div>