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

squirrels/_package_data/base_project/pyconfigs/parameters.py

@@ -1,55 +1,75 @@
-from squirrels import arguments as args, parameters as p, parameter_options as po, data_sources as ds
+from squirrels import parameters as p, parameter_options as po, data_sources as ds
 
 
 ## 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"
+    name="group_by", label="Group By", 
+    description="Dimension(s) to aggregate by", 
+    user_attribute="access_level"
 )
 def group_by_options():
     return [
         po.SelectParameterOption(
-            "trans", "Transaction",  
+            id="trans", label="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
-            user_groups=["manager"]
+            aliases=["_id","date","category","subcategory","description"], # in context.py, any alias starting with "_" will not be selected
+            user_groups=["admin"]
+        ),
+        po.SelectParameterOption(
+            id="day", label="Day", 
+            columns=["date"], 
+            aliases=["day"], 
+            user_groups=["admin","member"]
+        ),
+        po.SelectParameterOption(
+            id="month", label="Month", 
+            columns=["month"], 
+            user_groups=["admin","member","guest"]
+        ),
+        po.SelectParameterOption(
+            id="cat", label="Category", 
+            columns=["category"], 
+            user_groups=["admin","member","guest"]
+        ),
+        po.SelectParameterOption(
+            id="subcat", label="Subcategory", 
+            columns=["category","subcategory"], 
+            user_groups=["admin","member","guest"]
         ),
-        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"]),
     ]
 
 
-## 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"
+    name="start_date", label="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"
+        table_or_query="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",
     )
 
 
 ## 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"
+    name="end_date", label="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")]
+    return [
+        po.DateParameterOption(
+            default_date="2024-12-31", min_date="2024-01-01", max_date="2024-12-31"
+        )
+    ]
 
 
 ## 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",
+    name="date_range", label="Date Range", 
+    default_start_date="2024-01-01", default_end_date="2024-12-31", 
+    min_date="2024-01-01", max_date="2024-12-31",
     description="Date range to filter transactions by"
 )
 def date_range_options():
@@ -58,27 +78,38 @@ def date_range_options():
 
 ## Example of creating MultiSelectParameter from lookup query/table
 @p.MultiSelectParameter.create_from_source(
-    "category", "Category Filter", 
+    name="category", label="Category Filter", 
     description="The expense categories to filter transactions by"
 )
 def category_source():
-    return ds.SelectDataSource("seed_categories", "category_id", "category", from_seeds=True)
+    return ds.SelectDataSource(
+        table_or_query="seed_categories", 
+        id_col="category_id", 
+        options_col="category", 
+        source=ds.SourceEnum.SEEDS
+    )
 
 
 ## 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')"
+    name="subcategory", label="Subcategory Filter",
+    description="The expense subcategories to filter transactions by (available options are based on selected value(s) of 'Category Filter')", 
+    parent_name="category"
 )
 def subcategory_source():
     return ds.SelectDataSource(
-        "seed_subcategories", "subcategory_id", "subcategory", from_seeds=True, parent_id_col="category_id"
+        table_or_query="seed_subcategories", 
+        id_col="subcategory_id", 
+        options_col="subcategory", 
+        source=ds.SourceEnum.SEEDS, 
+        parent_id_col="category_id"
     )
 
 
 ## Example of creating NumberParameter
 @p.NumberParameter.create_simple(
-    "min_filter", "Amounts Greater Than", min_value=0, max_value=300, increment=10,
+    name="min_filter", label="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():
@@ -87,19 +118,23 @@ def min_filter_options():
 
 ## Example of creating NumberParameter from lookup query/table
 @p.NumberParameter.create_from_source(
-    "max_filter", "Amounts Less Than",
+    name="max_filter", label="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"
     return ds.NumberDataSource(
-        query, "min_value", "max_value", increment_col="increment", default_value_col="max_value"
+        table_or_query="SELECT 0 as min_value, 300 as max_value, 10 as increment",
+        min_value_col="min_value", max_value_col="max_value", 
+        increment_col="increment", 
+        default_value_col="max_value"
     )
 
 
 ## 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,
+    name="between_filter", label="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():

squirrels/_package_data/base_project/pyconfigs/user.py

@@ -2,25 +2,17 @@ from typing import Literal
 from squirrels import auth, arguments as args
 
 
-class User(auth.BaseUser):
+class CustomUserFields(auth.CustomUserFields):
     """
-    Extend the BaseUser class with custom attributes. The attributes defined here will be added as columns to the users table. 
+    Extend the CustomUserFields class to add custom user attributes. 
     - Only the following types are supported: [str, int, float, bool, typing.Literal]
-    - For str, int, and float types, add "| None" after the type to make it nullable. 
-    - Always set a default value for the column (use None if default is null).
+    - Add "| None" after the type to make it nullable. 
+    - Always set a default value for the field (use None if default is null).
     
     Example:
         organization: str | None = None
     """
-    role: Literal["manager", "employee"] = "employee"
-
-    @classmethod
-    def dropped_columns(cls) -> list[str]:
-        """
-        The fields defined above cannot be modified once added to the database. 
-        However, you can choose to drop columns by adding them to this list.
-        """
-        return []
+    role: Literal["manager", "staff", "customer"] = "staff"
 
 
 # @auth.provider(name="google", label="Google", icon="https://www.google.com/favicon.ico")
@@ -31,11 +23,12 @@ def google_auth_provider(sqrl: args.AuthProviderArgs) -> auth.ProviderConfigs:
     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(
+    def get_sqrl_user(claims: dict) -> auth.RegisteredUser:
+        custom_fields = CustomUserFields(role="customer")
+        return auth.RegisteredUser(
             username=claims["email"],
-            is_admin=False,
-            role="employee"
+            access_level="member",
+            custom_fields=custom_fields
         )
 
     # TODO: Add GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET to the .env file
@@ -43,7 +36,7 @@ def google_auth_provider(sqrl: args.AuthProviderArgs) -> auth.ProviderConfigs:
     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",
+        server_url="https://accounts.google.com",
         client_kwargs={"scope": "openid email profile"},
         get_user=get_sqrl_user
     )

squirrels/_package_data/base_project/seeds/seed_categories.yml

@@ -1,7 +1,7 @@
 description: |
   Lookup table for the category IDs and names of transactions.
 
-cast_column_types: true  # optional, default is false - setting SQRL_SEEDS__INFER_SCHEMA is ignored for this seed if this is set to true
+cast_column_types: true  # optional, default is false - if set to true, then SQRL_SEEDS__INFER_SCHEMA is ignored for this seed
 
 columns:
   - name: category_id

squirrels/_package_data/base_project/seeds/seed_subcategories.yml

@@ -1,7 +1,7 @@
 description: |
   Lookup table for the subcategory IDs and names of transactions.
 
-cast_column_types: true  # optional, default is false - setting SQRL_SEEDS__INFER_SCHEMA is ignored for this seed if this is set to true
+cast_column_types: true  # optional, default is false - if set to true, then SQRL_SEEDS__INFER_SCHEMA is ignored for this seed
 
 columns:
   - name: subcategory_id

squirrels/_package_data/base_project/squirrels.yml.j2

@@ -1,6 +1,6 @@
 project_variables:
-  name: sample
-  label: Sample Project - Expenses
+  name: sample_expenses
+  label: "Sample Expenses"
   description: This is a sample squirrels project for analyzing expense transactions
   major_version: 1
 
@@ -21,51 +21,41 @@ packages: []
 
 
 datasets:
-  - name: dbview_dataset_example          ## model name uses same name unless "model" field is specified
-    label: Example Dataset from DBView Model
-    description: Aggregated expense transactions by month using dbview_example model
+  - name: expense_transactions           ## model name uses same name unless "model" field is specified
+    label: Expense Transactions - DBView Example
+    description: All expense transactions
     model: dbview_example 
-    scope: public                         ## optional - one of 'public' (default), 'protected', or 'private'
+    scope: private                        ## optional - one of 'public' (default), 'protected', or 'private'
     parameters:                           ## optional - if not specified, then all parameters are used
       - start_date
       - end_date
       - min_filter
       - max_filter
-    traits: {}                            ## optional - defaults to empty object
   
-  - name: federate_dataset_example
-    label: Example Dataset from Federate Model
+  - name: grouped_expenses
+    label: Grouped Expenses - Federate Example
     description: Aggregated expense transactions by custom dimension using federate_example model
     model: federate_example 
-    scope: protected                      ## using an auth.py file is suggested for protected or private datasets
+    scope: public                         ## using an auth.py file is suggested for protected or private datasets
     parameters:
       - group_by
-      - limit
       - date_range
       - category
       - subcategory
       - between_filter
-    default_test_set: auth_test1          ## optional - if not specified, uses setting 'selection_test_sets.default_name_used'
 
 
 selection_test_sets:
-  - name: no_auth_test1
-    datasets:                             ## optional section - if not provided, then test set is applicable for any dataset
-      - dbview_dataset_example
-    parameters:                           ## optional section - if not provided, then assumes no parameters. For unspecified parameters, default value is used
-      start_date: 2024-07-01              ## this parameter only exists for dataset 'dataset_example'
+  - name: set_start_date
+    parameters:                           ## optional section - if not provided, then default value is used for all parameters
+      start_date: 2024-07-01              ## this parameter is only used by model "dbview_example"
   
-  - name: auth_test1
-    datasets:
-      - federate_dataset_example
-    user_attributes:                      ## optional section - required if using test set on non-public datasets
-      role: employee
+  - name: set_date_range
     parameters:
-      date_range: [2024-02-01,2024-12-01] ## this parameter only exists for dataset 'protected_dataset_example'
+      date_range: [2024-02-01,2024-11-30] ## this parameter is only used by model "federate_example"
     
-  - name: auth_test2
-    user_attributes:
-      is_internal: True                   ## optional - defaults to False
-      role: manager
+  - name: use_admin_privileged_group_by
+    user:
+      access_level: admin
     parameters:
-      group_by: g3                        ## this parameter exists for all datasets. "g3" is the id for option "subcategory"
+      group_by: trans

squirrels/_package_data/templates/squirrels_studio.html

@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link id="favicon" rel="icon" type="image/x-icon" href="{{ sqrl_studio_base_url }}/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Squirrels Studio</title>
+    <script>
+      // Optional: Set global defaults for project parameters
+      window.DEFAULT_HOSTNAME = '';
+      window.DEFAULT_PROJECT_NAME = '{{ project_name }}';
+      window.DEFAULT_PROJECT_VERSION = '{{ project_version }}';
+    </script>
+    <script type="module" crossorigin src="{{ sqrl_studio_base_url }}/assets/index.js"></script>
+    <link rel="stylesheet" crossorigin href="{{ sqrl_studio_base_url }}/assets/index.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

squirrels/_parameter_configs.py

@@ -11,7 +11,7 @@ import polars as pl, re
 
 from . import _data_sources as d, _parameter_options as po, _parameters as p, _utils as u, _constants as c
 from ._exceptions import InvalidInputError
-from ._auth import BaseUser
+from ._schemas.auth_models import AbstractUser
 from ._connection_set import ConnectionSet
 from ._seeds import Seeds
 
@@ -56,12 +56,20 @@ class ParameterConfigBase(metaclass=ABCMeta):
     user_attribute: str | None = field(default=None, kw_only=True)
     parent_name: str | None = field(default=None, kw_only=True)
 
-    def _get_user_group(self, user: BaseUser | None) -> Any:
-        if self.user_attribute is not None:
-            if user is None:
-                raise u.ConfigurationError(f"Public datasets (accessible without authentication) cannot use parameter " +
-                                           f"'{self.name}' because 'user_attribute' is defined on this parameter.")
-            return getattr(user, self.user_attribute)
+    def _get_user_group(self, user: AbstractUser) -> Any:
+        if self.user_attribute is None:
+            return None
+        
+        final_object = user
+        attribute = self.user_attribute
+        try:
+            if "." in attribute:
+                parts = attribute.split(".", 1)
+                final_object = getattr(final_object, parts[0])
+                attribute = parts[1]
+            return getattr(final_object, attribute)
+        except AttributeError:
+            raise u.ConfigurationError(f"User attribute '{self.user_attribute}' is not valid")
         
     def copy(self):
         """
@@ -108,16 +116,16 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
         pass
     
     def _invalid_input_error(self, selection: str, more_details: str = '') -> InvalidInputError:
-        return InvalidInputError(400, "Invalid parameter selection", f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details)
+        return InvalidInputError(400, "invalid_parameter_selection", f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details)
     
     @abstractmethod
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.Parameter:
         pass
     
     def _get_options_iterator(
-        self, all_options: Sequence[ParamOptionType], user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, all_options: Sequence[ParamOptionType], user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> Iterator[ParamOptionType]:
         user_group = self._get_user_group(user)
         selected_parent_option_ids = frozenset(parent_param._get_selected_ids_as_list()) if parent_param else None
@@ -153,7 +161,7 @@ class SelectionParameterConfig(ParameterConfig[po.SelectParameterOption]):
         self.children[child.name] = child
         self.trigger_refresh = True
     
-    def _get_options(self, user: BaseUser | None, parent_param: p._SelectionParameter | None) -> Sequence[po.SelectParameterOption]:
+    def _get_options(self, user: AbstractUser, parent_param: p._SelectionParameter | None) -> Sequence[po.SelectParameterOption]:
         return tuple(self._get_options_iterator(self.all_options, user, parent_param))
     
     def _get_default_ids_iterator(self, options: Sequence[po.SelectParameterOption]) -> Iterator[str]:
@@ -189,7 +197,7 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.SingleSelectParameter:
         options = self._get_options(user, parent_param)
         if selection is None:
@@ -237,7 +245,7 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.MultiSelectParameter:
         options = self._get_options(user, parent_param)
         if selection is None:
@@ -293,7 +301,7 @@ class DateParameterConfig(_DateTypeParameterConfig[po.DateParameterOption]):
         return d.DateDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.DateParameter:
         curr_option: po.DateParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         selected_date = curr_option._default_date if selection is None and curr_option is not None else selection
@@ -332,7 +340,7 @@ class DateRangeParameterConfig(_DateTypeParameterConfig[po.DateRangeParameterOpt
         return d.DateRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.DateRangeParameter:
         curr_option: po.DateRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
@@ -395,7 +403,7 @@ class NumberParameterConfig(_NumericParameterConfig[po.NumberParameterOption]):
         return d.NumberDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.NumberParameter:
         curr_option: po.NumberParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         selected_value = curr_option._default_value if selection is None and curr_option is not None else selection
@@ -434,7 +442,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig[po.NumberRangeParameter
         return d.NumberRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.NumberRangeParameter:
         curr_option: po.NumberRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
@@ -524,7 +532,7 @@ class TextParameterConfig(ParameterConfig[po.TextParameterOption]):
         return d.TextDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
+        self, selection: str | None, user: AbstractUser, parent_param: p._SelectionParameter | None
     ) -> p.TextParameter:
         curr_option: po.TextParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         entered_text = curr_option._default_text if selection is None and curr_option is not None else selection
@@ -550,6 +558,8 @@ class DataSourceParameterConfig(Generic[ParamConfigType], ParameterConfigBase):
         super().__init__(name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
         self.parameter_type = parameter_type
         if isinstance(data_source, dict):
+            if "source" in data_source:
+                data_source["source"] = d.SourceEnum(data_source["source"])
             data_source = parameter_type.DataSource(**data_source)
         self.data_source = data_source
         self.extra_args = extra_args
@@ -557,15 +567,26 @@ class DataSourceParameterConfig(Generic[ParamConfigType], ParameterConfigBase):
     def convert(self, df: pl.DataFrame) -> ParamConfigType:
         return self.data_source._convert(self, df)
     
-    def get_dataframe(self, default_conn_name: str, conn_set: ConnectionSet, seeds: Seeds) -> pl.DataFrame:
+    def get_dataframe(self, default_conn_name: str, conn_set: ConnectionSet, seeds: Seeds, datalake_db_path: str = "") -> pl.DataFrame:
         datasource = self.data_source
         query = datasource._get_query()
-        if datasource._is_from_seeds:
+        if datasource._source == d.SourceEnum.SEEDS:
             df = seeds.run_query(query)
-        else:
+        elif datasource._source == d.SourceEnum.VDL:
+            vdl_conn = u.create_duckdb_connection(datalake_db_path)
+            try:
+                # Query the VDL database
+                df = vdl_conn.sql(query).pl()
+            except Exception as e:
+                raise u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}" from VDL') from e
+            finally:
+                vdl_conn.close()
+        else:  # source == "connection"
+            conn_name = None
             try:
                 conn_name = datasource._get_connection_name(default_conn_name)
                 df = conn_set.run_sql_query_from_conn_name(query, conn_name)
             except RuntimeError as e:
-                raise u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}"') from e
+                ending = f' "{conn_name}"' if conn_name is not None else ""
+                raise u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}" from connection{ending}') from e
         return df

squirrels/_parameter_options.py

@@ -35,7 +35,7 @@ class ParameterOption(metaclass=ABCMeta):
         
         Arguments:
             user_group: The value of the user's "user group attribute". Only None when "user_attribute" is not specified
-                for the Parameter factory. Note that when user is None but "user_attribute" is specified, an error is thrown
+                for the Parameter factory.
             selected_parent_option_ids: List of selected option ids from the parent parameter. Only None when the Parameter
                 object has no parent parameter.
         

squirrels/_parameter_sets.py

@@ -10,7 +10,7 @@ from ._arguments.init_time_args import ParametersArgs
 from ._manifest import ParametersConfig, ManifestConfig
 from ._connection_set import ConnectionSet
 from ._seeds import Seeds
-from ._auth import BaseUser
+from ._schemas.auth_models import AbstractUser
 
 
 @dataclass
@@ -104,13 +104,10 @@ class ParameterConfigsSet:
         self.__validate_param_relationships()
     
     def apply_selections(
-        self, dataset_params: Optional[Sequence[str]], selections: dict[str, Any], user: BaseUser | None, *, parent_param: str | None = None
+        self, dataset_params: Optional[Sequence[str]], selections: dict[str, Any], user: AbstractUser, *, parent_param: str | None = None
     ) -> ParameterSet:
         if dataset_params is None:
-            if user is None:
-                dataset_params = [k for k, v in self._data.items() if v.user_attribute is None]
-            else:
-                dataset_params = list(self._data.keys())
+            dataset_params = list(self._data.keys())
         
         parameters_by_name: dict[str, p.Parameter] = {}
         params_to_process = [parent_param] if parent_param else dataset_params
@@ -158,11 +155,11 @@ class ParameterConfigsSetIO:
     
     @classmethod
     def _get_df_dict_from_data_sources(
-        cls, param_configs_set: ParameterConfigsSet, default_conn_name: str, seeds: Seeds, conn_set: ConnectionSet
+        cls, param_configs_set: ParameterConfigsSet, default_conn_name: str, seeds: Seeds, conn_set: ConnectionSet, datalake_db_path: str
     ) -> dict[str, pl.DataFrame]:
         
         def get_dataframe(ds_param_config: pc.DataSourceParameterConfig) -> tuple[str, pl.DataFrame]:
-            return ds_param_config.name, ds_param_config.get_dataframe(default_conn_name, conn_set, seeds)
+            return ds_param_config.name, ds_param_config.get_dataframe(default_conn_name, conn_set, seeds, datalake_db_path)
         
         ds_param_configs = param_configs_set._get_all_ds_param_configs()
         with concurrent.futures.ThreadPoolExecutor() as executor:
@@ -179,7 +176,8 @@ class ParameterConfigsSetIO:
     
     @classmethod
     def load_from_file(
-        cls, logger: u.Logger, base_path: str, manifest_cfg: ManifestConfig, seeds: Seeds, conn_set: ConnectionSet, param_args: ParametersArgs
+        cls, logger: u.Logger, base_path: str, manifest_cfg: ManifestConfig, seeds: Seeds, conn_set: ConnectionSet, param_args: ParametersArgs, 
+        datalake_db_path: str
     ) -> ParameterConfigsSet:
         start = time.time()
         param_configs_set = ParameterConfigsSet()
@@ -199,7 +197,7 @@ class ParameterConfigsSetIO:
                 param_configs_set.add(param_config)
         
         default_conn_name = manifest_cfg.env_vars.get(c.SQRL_CONNECTIONS_DEFAULT_NAME_USED, "default")
-        df_dict = cls._get_df_dict_from_data_sources(param_configs_set, default_conn_name, seeds, conn_set)
+        df_dict = cls._get_df_dict_from_data_sources(param_configs_set, default_conn_name, seeds, conn_set, datalake_db_path)
         param_configs_set._post_process_params(df_dict)
         
         logger.log_activity_time("loading parameters", start)