squirrels 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

squirrels/_parameter_configs.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Generic, TypeVar, Annotated, Type, Sequence, Iterator, Any
+from typing import Generic, TypeVar, Annotated, Sequence, Iterator, Any
 from typing_extensions import Self
 from datetime import datetime
 from dataclasses import dataclass, field
@@ -7,14 +7,15 @@ from abc import ABCMeta, abstractmethod
 from copy import copy
 from fastapi import Query
 from pydantic.fields import Field
-import pandas as pd, re
+import polars as pl, re
 
-from . import parameter_options as _po, parameters as p, data_sources as d, _utils as _u, _constants as c
-from .user_base import User
+from . import _data_sources as d, _parameter_options as po, _parameters as p, _utils as u, _constants as c
+from ._exceptions import InvalidInputError
+from ._schemas.auth_models import AbstractUser
 from ._connection_set import ConnectionSet
 from ._seeds import Seeds
 
-ParamOptionType = TypeVar("ParamOptionType", bound=_po.ParameterOption)
+ParamOptionType = TypeVar("ParamOptionType", bound=po.ParameterOption)
 
 
 @dataclass
@@ -27,16 +28,17 @@ class APIParamFieldInfo:
     pattern: str | None = None
     min_length: int | None = None
     max_length: int | None = None
+    default: Any = None
     
     def as_query_info(self):
         query_info = Query(
             title=self.title, description=self.description, examples=self.examples, pattern=self.pattern,
             min_length=self.min_length, max_length=self.max_length
         )
-        return (self.name, Annotated[self.type, query_info], None)
+        return (self.name, Annotated[self.type, query_info], self.default)
     
     def as_body_info(self):
-        field_info = Field(None,
+        field_info = Field(self.default,
             title=self.title, description=self.description, examples=self.examples, pattern=self.pattern,
             min_length=self.min_length, max_length=self.max_length
         )
@@ -50,28 +52,24 @@ class ParameterConfigBase(metaclass=ABCMeta):
     """
     name: str
     label: str
-    description: str # = field(default="", kw_only=True)
-    user_attribute: str | None # = field(default=None, kw_only=True)
-    parent_name: str | None # = field(default=None, kw_only=True)
+    description: str = field(default="", kw_only=True)
+    user_attribute: str | None = field(default=None, kw_only=True)
+    parent_name: str | None = field(default=None, kw_only=True)
 
-    @abstractmethod
-    def __init__(
-        self, widget_type: str, name: str, label: str, *, description: str = "", user_attribute: str | None = None, 
-        parent_name: str | None = None
-    ) -> None:
-        self.widget_type = widget_type
-        self.name = name
-        self.label = label
-        self.description = description
-        self.user_attribute = user_attribute
-        self.parent_name = parent_name
-
-    def _get_user_group(self, user: User | None) -> Any:
-        if self.user_attribute is not None:
-            if user is None:
-                raise _u.ConfigurationError(f"Non-authenticated users (only allowed for public datasets) 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):
         """
@@ -92,7 +90,7 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
         self, name: str, label: str, all_options: Sequence[ParamOptionType | dict], *, description: str = "", 
         user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
-        super().__init__(self.widget_type(), name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
+        super().__init__(name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
         self._all_options = tuple(self._to_param_option(x) for x in all_options)
 
     def _to_param_option(self, option: ParamOptionType | dict) -> ParamOptionType:
@@ -117,18 +115,17 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
     def DataSource(*args, **kwargs) -> d.DataSource:
         pass
     
-    def _invalid_input_error(self, selection: str, more_details: str = '') -> _u.InvalidInputError:
-        return _u.InvalidInputError(f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details)
+    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)
     
     @abstractmethod
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None, 
-        *, request_version: int | None = 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: User | 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
@@ -140,7 +137,7 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
 
 
 @dataclass
-class SelectionParameterConfig(ParameterConfig[_po.SelectParameterOption]):
+class SelectionParameterConfig(ParameterConfig[po.SelectParameterOption]):
     """
     Abstract class for select parameter classes (single-select, multi-select, etc)
     """
@@ -149,7 +146,7 @@ class SelectionParameterConfig(ParameterConfig[_po.SelectParameterOption]):
 
     @abstractmethod
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.SelectParameterOption | dict], *,
+        self, name: str, label: str, all_options: Sequence[po.SelectParameterOption | dict], *,
         description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -158,16 +155,16 @@ class SelectionParameterConfig(ParameterConfig[_po.SelectParameterOption]):
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.SelectParameterOption(*args, **kwargs)
+        return po.SelectParameterOption(*args, **kwargs)
     
     def _add_child_mutate(self, child: ParameterConfigBase):
         self.children[child.name] = child
         self.trigger_refresh = True
     
-    def _get_options(self, user: User | 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]:
+    def _get_default_ids_iterator(self, options: Sequence[po.SelectParameterOption]) -> Iterator[str]:
         return (x._identifier for x in options if x._is_default)
     
     def copy(self) -> Self:
@@ -186,7 +183,7 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
     """
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.SelectParameterOption | dict], *, description: str = "", 
+        self, name: str, label: str, all_options: Sequence[po.SelectParameterOption | dict], *, description: str = "", 
         user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -200,8 +197,7 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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:
@@ -224,12 +220,12 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     """
     Class to define configurations for multi-select parameter widgets.
     """
-    show_select_all: bool # = field(default=True, kw_only=True)
-    order_matters: bool # = field(default=False, kw_only=True)
-    none_is_all: bool # = field(default=True, kw_only=True)
+    show_select_all: bool = field(default=True, kw_only=True)
+    order_matters: bool = field(default=False, kw_only=True)
+    none_is_all: bool = field(default=True, kw_only=True)
 
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.SelectParameterOption | dict], *, description: str = "", 
+        self, name: str, label: str, all_options: Sequence[po.SelectParameterOption | dict], *, description: str = "", 
         show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True,
         user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
@@ -249,14 +245,13 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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:
             selected_ids = tuple(self._get_default_ids_iterator(options))
         else:
-            selected_ids = _u.load_json_or_comma_delimited_str_as_list(selection)
+            selected_ids = u.load_json_or_comma_delimited_str_as_list(selection)
         return p.MultiSelectParameter(self, options, selected_ids)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -281,14 +276,14 @@ class _DateTypeParameterConfig(ParameterConfig[ParamOptionType]):
 
 
 @dataclass
-class DateParameterConfig(_DateTypeParameterConfig[_po.DateParameterOption]):
+class DateParameterConfig(_DateTypeParameterConfig[po.DateParameterOption]):
     """
     Class to define configurations for date parameter widgets.
     """
-    _all_options: Sequence[_po.DateParameterOption] = field(repr=False)
+    _all_options: Sequence[po.DateParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.DateParameterOption | dict], *, 
+        self, name: str, label: str, all_options: Sequence[po.DateParameterOption | dict], *, 
         description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -299,36 +294,35 @@ class DateParameterConfig(_DateTypeParameterConfig[_po.DateParameterOption]):
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.DateParameterOption(*args, **kwargs)
+        return po.DateParameterOption(*args, **kwargs)
     
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.DateDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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)
+        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
         return p.DateParameter(self, curr_option, selected_date)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
         examples = [str(x._default_date) for x in self.all_options]
         return APIParamFieldInfo(
-            self.name, str, title=self.label, description=self.description, examples=examples, pattern=c.date_regex
+            self.name, str, title=self.label, description=self.description, examples=examples, pattern=c.DATE_REGEX
         )
 
 
 @dataclass
-class DateRangeParameterConfig(_DateTypeParameterConfig[_po.DateRangeParameterOption]):
+class DateRangeParameterConfig(_DateTypeParameterConfig[po.DateRangeParameterOption]):
     """
     Class to define configurations for date range parameter widgets.
     """
-    _all_options: Sequence[_po.DateRangeParameterOption] = field(repr=False)
+    _all_options: Sequence[po.DateRangeParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.DateRangeParameterOption | dict], *,
+        self, name: str, label: str, all_options: Sequence[po.DateRangeParameterOption | dict], *,
         description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -339,17 +333,16 @@ class DateRangeParameterConfig(_DateTypeParameterConfig[_po.DateRangeParameterOp
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.DateRangeParameterOption(*args, **kwargs)
+        return po.DateRangeParameterOption(*args, **kwargs)
     
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.DateRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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)
+        curr_option: po.DateRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
             if curr_option is not None:
                 selected_start_date = curr_option._default_start_date
@@ -358,7 +351,7 @@ class DateRangeParameterConfig(_DateTypeParameterConfig[_po.DateRangeParameterOp
                 selected_start_date, selected_end_date = None, None
         else:
             try:
-                selected_start_date, selected_end_date = _u.load_json_or_comma_delimited_str_as_list(selection)
+                selected_start_date, selected_end_date = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError:
                 raise self._invalid_input_error(selection, "Date range parameter selection must be two dates.")
         return p.DateRangeParameter(self, curr_option, selected_start_date, selected_end_date)
@@ -385,14 +378,14 @@ class _NumericParameterConfig(ParameterConfig[ParamOptionType]):
 
 
 @dataclass
-class NumberParameterConfig(_NumericParameterConfig[_po.NumberParameterOption]):
+class NumberParameterConfig(_NumericParameterConfig[po.NumberParameterOption]):
     """
     Class to define configurations for number parameter widgets.
     """
-    _all_options: Sequence[_po.NumberParameterOption] = field(repr=False)
+    _all_options: Sequence[po.NumberParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.NumberParameterOption | dict], *,
+        self, name: str, label: str, all_options: Sequence[po.NumberParameterOption | dict], *,
         description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -403,17 +396,16 @@ class NumberParameterConfig(_NumericParameterConfig[_po.NumberParameterOption]):
     
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.NumberParameterOption(*args, **kwargs)
+        return po.NumberParameterOption(*args, **kwargs)
     
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.NumberDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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)
+        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
         return p.NumberParameter(self, curr_option, selected_value)
     
@@ -425,14 +417,14 @@ class NumberParameterConfig(_NumericParameterConfig[_po.NumberParameterOption]):
 
 
 @dataclass
-class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParameterOption]):
+class NumberRangeParameterConfig(_NumericParameterConfig[po.NumberRangeParameterOption]):
     """
     Class to define configurations for number range parameter widgets.
     """
-    _all_options: Sequence[_po.NumberRangeParameterOption] = field(repr=False)
+    _all_options: Sequence[po.NumberRangeParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.NumberRangeParameterOption | dict], *, 
+        self, name: str, label: str, all_options: Sequence[po.NumberRangeParameterOption | dict], *, 
         description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
@@ -443,17 +435,16 @@ class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParamete
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.NumberRangeParameterOption(*args, **kwargs)
+        return po.NumberRangeParameterOption(*args, **kwargs)
     
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.NumberRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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)
+        curr_option: po.NumberRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
             if curr_option is not None:
                 selected_lower_value = curr_option._default_lower_value
@@ -462,7 +453,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParamete
                 selected_lower_value, selected_upper_value = None, None
         else:
             try:
-                selected_lower_value, selected_upper_value = _u.load_json_or_comma_delimited_str_as_list(selection)
+                selected_lower_value, selected_upper_value = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError:
                 raise self._invalid_input_error(selection, "Number range parameter selection must be two numbers.")
         return p.NumberRangeParameter(self, curr_option, selected_lower_value, selected_upper_value)
@@ -475,22 +466,22 @@ class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParamete
 
 
 @dataclass
-class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
+class TextParameterConfig(ParameterConfig[po.TextParameterOption]):
     """
     Class to define configurations for text parameter widgets.
     """
-    _all_options: Sequence[_po.TextParameterOption] = field(repr=False)
+    _all_options: Sequence[po.TextParameterOption] = field(repr=False)
     input_type: str
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[_po.TextParameterOption | dict], *, description: str = "", 
+        self, name: str, label: str, all_options: Sequence[po.TextParameterOption | dict], *, description: str = "", 
         input_type: str = "text", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
         super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
         
         allowed_input_types = ["text", "textarea", "number", "date", "datetime-local", "month", "time", "color", "password"]
         if input_type not in allowed_input_types:
-            raise _u.ConfigurationError(f"Invalid input type '{input_type}' for text parameter '{name}'. Must be one of {allowed_input_types}.")
+            raise u.ConfigurationError(f"Invalid input type '{input_type}' for text parameter '{name}'. Must be one of {allowed_input_types}.")
 
         self.input_type = input_type
         for option in self._all_options:
@@ -499,9 +490,9 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
     def validate_entered_text(self, entered_text: str) -> str:
         if self.input_type == "number":
             try:
-                int(entered_text)
+                float(entered_text)
             except ValueError:
-                raise self._invalid_input_error(entered_text, "Must be an integer (without decimals)")
+                raise self._invalid_input_error(entered_text, "Must be a number")
         elif self.input_type == "date":
             try:
                 datetime.strptime(entered_text, "%Y-%m-%d")
@@ -523,7 +514,7 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
             except ValueError:
                 raise self._invalid_input_error(entered_text, "Must be a time in hh:mm format.")
         elif self.input_type == "color":
-            if not re.match(c.color_regex, entered_text):
+            if not re.match(c.COLOR_REGEX, entered_text):
                 raise self._invalid_input_error(entered_text, "Must be a valid color hex code (e.g. #000000).")
         
         return entered_text
@@ -534,17 +525,16 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
-        return _po.TextParameterOption(*args, **kwargs)
+        return po.TextParameterOption(*args, **kwargs)
     
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.TextDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = 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)
+        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
         return p.TextParameter(self, curr_option, entered_text)
     
@@ -555,37 +545,48 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
         )
 
 
-@dataclass
-class DataSourceParameterConfig(ParameterConfigBase):
+ParamConfigType = TypeVar("ParamConfigType", bound=ParameterConfig)
+
+class DataSourceParameterConfig(Generic[ParamConfigType], ParameterConfigBase):
     """
     Class to define configurations for parameter widgets whose options come from lookup tables
     """
-    parameter_type: Type[ParameterConfig]
-    data_source: d.DataSource
-
     def __init__(
-        self, parameter_type: Type[ParameterConfig], name: str, label: str, data_source: d.DataSource | dict, *, 
+        self, parameter_type: type[ParamConfigType], name: str, label: str, data_source: d.DataSource | dict, *, 
         extra_args: dict = {}, description: str = "", user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
-        super().__init__("data_source", name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
+        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
 
-    def convert(self, df: pd.DataFrame) -> ParameterConfig:
+    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) -> pd.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