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

squirrels/_parameter_configs.py

@@ -1,18 +1,21 @@
 from __future__ import annotations
-from typing import Annotated, Type, Optional, Union, Sequence, Iterator, Any
+from typing import Generic, TypeVar, Annotated, Type, Sequence, Iterator, Any
+from typing_extensions import Self
 from datetime import datetime
 from dataclasses import dataclass, field
 from abc import ABCMeta, abstractmethod
 from copy import copy
 from fastapi import Query
-from pydantic.fields import Field, FieldInfo
+from pydantic.fields import Field
 import pandas as pd, re
 
-from . import parameter_options as po, parameters as p, data_sources as d, _api_response_models as arm, _utils as u, _constants as c
+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 ._connection_set import ConnectionSet
 from ._seeds import Seeds
 
+ParamOptionType = TypeVar("ParamOptionType", bound=_po.ParameterOption)
+
 
 @dataclass
 class APIParamFieldInfo:
@@ -20,10 +23,10 @@ class APIParamFieldInfo:
     type: type
     title: str = ""
     description: str = ""
-    examples: Optional[list[Any]] = None
-    pattern: Optional[str] = None
-    min_length: Optional[int] = None
-    max_length: Optional[int] = None
+    examples: list[Any] | None = None
+    pattern: str | None = None
+    min_length: int | None = None
+    max_length: int | None = None
     
     def as_query_info(self):
         query_info = Query(
@@ -48,13 +51,13 @@ class ParameterConfigBase(metaclass=ABCMeta):
     name: str
     label: str
     description: str # = field(default="", kw_only=True)
-    user_attribute: Optional[str] # = field(default=None, kw_only=True)
-    parent_name: Optional[str] # = field(default=None, 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: Optional[str] = None, 
-        parent_name: Optional[str] = None
+        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
@@ -63,10 +66,10 @@ class ParameterConfigBase(metaclass=ABCMeta):
         self.user_attribute = user_attribute
         self.parent_name = parent_name
 
-    def _get_user_group(self, user: Optional[User]) -> Any:
+    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 " +
+                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)
         
@@ -78,27 +81,35 @@ class ParameterConfigBase(metaclass=ABCMeta):
 
 
 @dataclass
-class ParameterConfig(ParameterConfigBase):
+class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
     """
     Abstract class for all parameter classes (except DataSourceParameters)
     """
-    all_options: Sequence[po.ParameterOption] = field(repr=False)
+    _all_options: Sequence[ParamOptionType] = field(repr=False)
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, 
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__(widget_type, 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)
+        super().__init__(self.widget_type(), 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:
+        return self.ParameterOption(**option) if isinstance(option, dict) else option
+
+    @property
+    def all_options(self) -> Sequence[ParamOptionType]:
+        return self._all_options
 
-    def __to_param_option(self, option: Union[po.ParameterOption, dict]) -> po.ParameterOption:
-        return self.__class__.ParameterOption(**option) if isinstance(option, dict) else option
+    @staticmethod
+    @abstractmethod
+    def widget_type() -> str:
+        pass
 
     @staticmethod
     @abstractmethod
-    def ParameterOption(*args, **kwargs) -> po.ParameterOption:
+    def ParameterOption(*args, **kwargs) -> ParamOptionType:
         pass
 
     @staticmethod
@@ -106,20 +117,22 @@ class ParameterConfig(ParameterConfigBase):
     def DataSource(*args, **kwargs) -> d.DataSource:
         pass
     
-    def _raise_invalid_input_error(self, selection: str, more_details: str = '', e: Exception = None) -> None:
-        raise u.InvalidInputError(f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details) from e
+    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)
     
     @abstractmethod
     def with_selection(
-        self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter], 
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None, 
+        *, request_version: int | None = None
     ) -> p.Parameter:
         pass
     
-    def _get_options_iterator(self, user: Optional[User], parent_param: Optional[p._SelectionParameter]) -> Iterator[po.ParameterOption]:
+    def _get_options_iterator(
+        self, all_options: Sequence[ParamOptionType], user: User | None, 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
-        return (x for x in self.all_options if x._is_valid(user_group, selected_parent_option_ids))
+        return (x for x in all_options if x._is_valid(user_group, selected_parent_option_ids))
     
     @abstractmethod
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -127,39 +140,37 @@ class ParameterConfig(ParameterConfigBase):
 
 
 @dataclass
-class SelectionParameterConfig(ParameterConfig):
+class SelectionParameterConfig(ParameterConfig[_po.SelectParameterOption]):
     """
     Abstract class for select parameter classes (single-select, multi-select, etc)
     """
-    all_options: Sequence[po.SelectParameterOption] = field(repr=False)
     children: dict[str, ParameterConfigBase] = field(default_factory=dict, init=False, repr=False)
     trigger_refresh: bool = field(default=False, init=False)
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
         self.children: dict[str, ParameterConfigBase] = dict()
         self.trigger_refresh = False
 
     @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: Optional[User], parent_param: Optional[p._SelectionParameter]) -> Sequence[po.SelectParameterOption]:
-        return tuple(self._get_options_iterator(user, parent_param))
+    def _get_options(self, user: User | None, 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) -> SelectionParameterConfig:
+    def copy(self) -> Self:
         """
         Use for unit testing only
         """
@@ -175,19 +186,22 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
     """
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "", 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("single_select", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "single_select"
      
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
     ) -> p.SingleSelectParameter:
         options = self._get_options(user, parent_param)
         if selection is None:
@@ -215,29 +229,34 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     none_is_all: bool # = field(default=True, kw_only=True)
 
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[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: Optional[str] = None, parent_name: Optional[str] = None
+        user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
-        super().__init__("multi_select", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(
+            name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name
+        )
         self.show_select_all = show_select_all
         self.order_matters = order_matters
         self.none_is_all = none_is_all
     
+    @staticmethod
+    def widget_type() -> str:
+        return "multi_select"
+    
     @staticmethod
     def DataSource(*args, **kwargs):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = 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:
@@ -248,47 +267,49 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
 
 
 @dataclass
-class _DateTypeParameterConfig(ParameterConfig):
+class _DateTypeParameterConfig(ParameterConfig[ParamOptionType]):
     """
     Abstract class for date and date range parameter configs
     """
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
 
 
 @dataclass
-class DateParameterConfig(_DateTypeParameterConfig):
+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[Union[po.DateParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("date", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "date"
 
     @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: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
     ) -> p.DateParameter:
-        curr_option: po.DateParameterOption = next(self._get_options_iterator(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)
     
@@ -300,32 +321,35 @@ class DateParameterConfig(_DateTypeParameterConfig):
 
 
 @dataclass
-class DateRangeParameterConfig(_DateTypeParameterConfig):
+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[Union[po.DateRangeParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("date_range", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "date_range"
 
     @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: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
-    ) -> p.DateParameter:
-        curr_option: po.DateRangeParameterOption = next(self._get_options_iterator(user, parent_param), None)
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
+    ) -> p.DateRangeParameter:
+        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
@@ -334,9 +358,9 @@ class DateRangeParameterConfig(_DateTypeParameterConfig):
                 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)
-            except ValueError as e:
-                self._raise_invalid_input_error(selection, "Date range parameter selection must be two dates.", e)
+                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)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -347,47 +371,49 @@ class DateRangeParameterConfig(_DateTypeParameterConfig):
 
 
 @dataclass
-class _NumericParameterConfig(ParameterConfig):
+class _NumericParameterConfig(ParameterConfig[ParamOptionType]):
     """
     Abstract class for number and number range parameter configs
     """
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
 
 
 @dataclass
-class NumberParameterConfig(_NumericParameterConfig):
+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[Union[po.NumberParameterOption, dict]], *,
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("number", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
-
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "number"
+    
     @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: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
     ) -> p.NumberParameter:
-        curr_option: po.NumberParameterOption = next(self._get_options_iterator(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)
     
@@ -399,32 +425,35 @@ class NumberParameterConfig(_NumericParameterConfig):
 
 
 @dataclass
-class NumberRangeParameterConfig(_NumericParameterConfig):
+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[Union[po.NumberRangeParameterOption, dict]], *, 
-        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("number_range", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        super().__init__(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "number_range"
 
     @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: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
     ) -> p.NumberRangeParameter:
-        curr_option: Optional[po.NumberRangeParameterOption] = next(self._get_options_iterator(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
@@ -433,9 +462,9 @@ class NumberRangeParameterConfig(_NumericParameterConfig):
                 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)
-            except ValueError as e:
-                self._raise_invalid_input_error(selection, "Number range parameter selection must be two numbers.", e)
+                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)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -446,73 +475,76 @@ class NumberRangeParameterConfig(_NumericParameterConfig):
 
 
 @dataclass
-class TextParameterConfig(ParameterConfig):
+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[Union[po.TextParameterOption, dict]], *, description: str = "", 
-        input_type: str = "text", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        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__("text", name, label, all_options, description=description, user_attribute=user_attribute, 
-                         parent_name=parent_name)
+        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:
+        for option in self._all_options:
             self.validate_entered_text(option._default_text)
     
     def validate_entered_text(self, entered_text: str) -> str:
         if self.input_type == "number":
             try:
                 int(entered_text)
-            except ValueError as e:
-                raise self._raise_invalid_input_error(entered_text, "Must be an integer (without decimals).", e)
+            except ValueError:
+                raise self._invalid_input_error(entered_text, "Must be an integer (without decimals)")
         elif self.input_type == "date":
             try:
                 datetime.strptime(entered_text, "%Y-%m-%d")
-            except ValueError as e:
-                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM-DD format.", e)
+            except ValueError:
+                raise self._invalid_input_error(entered_text, "Must be a date in YYYY-MM-DD format")
         elif self.input_type == "datetime-local":
             try:
                 datetime.strptime(entered_text, "%Y-%m-%dT%H:%M")
-            except ValueError as e:
-                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM-DDThh:mm format (e.g. 2020-01-01T07:00).", e)
+            except ValueError:
+                raise self._invalid_input_error(entered_text, "Must be a date in YYYY-MM-DDThh:mm format (e.g. 2020-01-01T07:00)")
         elif self.input_type == "month":
             try:
                 datetime.strptime(entered_text, "%Y-%m")
-            except ValueError as e:
-                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM format.", e)
+            except ValueError:
+                raise self._invalid_input_error(entered_text, "Must be a date in YYYY-MM format")
         elif self.input_type == "time":
             try:
                 datetime.strptime(entered_text, "%H:%M")
-            except ValueError as e:
-                raise self._raise_invalid_input_error(entered_text, "Must be a time in hh:mm format.", e)
+            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(r"^#[0-9a-fA-F]{6}$", entered_text):
-                raise self._raise_invalid_input_error(entered_text, "Must be a valid color hex code (e.g. #000000).")
+            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
+    
+    @staticmethod
+    def widget_type() -> str:
+        return "text"
 
     @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: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
-        *, request_version: Optional[int] = None
+        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
+        *, request_version: int | None = None
     ) -> p.TextParameter:
-        curr_option: po.TextParameterOption = next(self._get_options_iterator(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)
     
@@ -532,8 +564,8 @@ class DataSourceParameterConfig(ParameterConfigBase):
     data_source: d.DataSource
 
     def __init__(
-        self, parameter_type: Type[ParameterConfig], name: str, label: str, data_source: Union[d.DataSource, dict], *, 
-        extra_args: dict = {}, description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, parameter_type: Type[ParameterConfig], 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)
         self.parameter_type = parameter_type
@@ -545,15 +577,15 @@ class DataSourceParameterConfig(ParameterConfigBase):
     def convert(self, df: pd.DataFrame) -> ParameterConfig:
         return self.data_source._convert(self, df)
     
-    def get_dataframe(self, conn_set: ConnectionSet, seeds: Seeds) -> pd.DataFrame:
+    def get_dataframe(self, default_conn_name: str, conn_set: ConnectionSet, seeds: Seeds) -> pd.DataFrame:
         datasource = self.data_source
         query = datasource._get_query()
-        if datasource.is_from_seed():
+        if datasource._is_from_seeds:
             df = seeds.run_query(query)
         else:
             try:
-                conn_name = datasource._get_connection_name()
+                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
+                raise _u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}"') from e
         return df