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

squirrels/data_sources.py

@@ -1,41 +1,35 @@
-from __future__ import annotations
-from typing import Type, Sequence, Iterable, Optional, Any
-from dataclasses import dataclass, field
-from abc import ABCMeta, abstractmethod
-import pandas as pd
+from __future__ import annotations as _a
+import pandas as _pd, typing as _t, dataclasses as _d, abc as _abc
 
-from . import _parameter_configs as pc, parameter_options as po, _utils as u, _constants as c
-from ._manifest import ManifestIO
+from . import _parameter_configs as _pc, parameter_options as _po, _utils as _u
 
 
-@dataclass
-class DataSource(metaclass=ABCMeta):
+@_d.dataclass
+class DataSource(metaclass=_abc.ABCMeta):
     """
     Abstract class for lookup tables coming from a database
     """
     _table_or_query: str
-    _id_col: Optional[str]
-    _from_seeds: bool
-    _user_group_col: Optional[str] # = field(default=None, kw_only=True)
-    _parent_id_col: Optional[str] # = field(default=None, kw_only=True)
-    _connection_name: Optional[str] # = field(default=None, kw_only=True)
+    _id_col: str | None
+    _is_from_seeds: bool
+    _user_group_col: str | None
+    _parent_id_col: str | None
+    _connection_name: str | None
 
-    @abstractmethod
+    @_abc.abstractmethod
     def __init__(
-        self, table_or_query: str, *, id_col: Optional[str] = None, from_seeds: bool = False, user_group_col: Optional[str] = None, 
-        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        self, table_or_query: str, *, id_col: str | None = None, from_seeds: bool = False, user_group_col: str | None = None, 
+        parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
     ) -> None:
         self._table_or_query = table_or_query
         self._id_col = id_col
-        self._from_seeds = from_seeds
+        self._is_from_seeds = from_seeds
         self._user_group_col = user_group_col
         self._parent_id_col = parent_id_col
         self._connection_name = connection_name
     
-    def _get_connection_name(self) -> str:
-        if self._connection_name is None:
-            return ManifestIO.obj.settings.get(c.DB_CONN_DEFAULT_USED_SETTING, c.DEFAULT_DB_CONN)
-        return self._connection_name
+    def _get_connection_name(self, default_conn_name: str) -> str:
+        return self._connection_name if self._connection_name is not None else default_conn_name
 
     def _get_query(self) -> str:
         """
@@ -50,20 +44,20 @@ class DataSource(metaclass=ABCMeta):
             query = f'SELECT * FROM {self._table_or_query}'
         return query
     
-    @abstractmethod
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.ParameterConfig:
+    @_abc.abstractmethod
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.ParameterConfig:
         """
         An abstract method for converting itself into a parameter
         """
         pass
     
-    def _validate_parameter_type(self, ds_param: pc.DataSourceParameterConfig, target_parameter_type: Type[pc.ParameterConfig]) -> None:
+    def _validate_parameter_type(self, ds_param: _pc.DataSourceParameterConfig, target_parameter_type: _t.Type[_pc.ParameterConfig]) -> None:
         if ds_param.parameter_type != target_parameter_type:
             parameter_type_name = ds_param.parameter_type.__name__
             datasource_type_name = self.__class__.__name__
-            raise u.ConfigurationError(f'Invalid widget type "{parameter_type_name}" for {datasource_type_name}')
+            raise _u.ConfigurationError(f'Invalid widget type "{parameter_type_name}" for {datasource_type_name}')
     
-    def _get_aggregated_df(self, df: pd.DataFrame, columns_to_include: Iterable[str]) -> pd.DataFrame:
+    def _get_aggregated_df(self, df: _pd.DataFrame, columns_to_include: _t.Iterable[str]) -> _pd.DataFrame:
         agg_rules = {}
         for column in columns_to_include:
             if column is not None:
@@ -77,36 +71,33 @@ class DataSource(metaclass=ABCMeta):
         try:
             df_agg = df.groupby(groupby_dim).agg(agg_rules)
         except KeyError as e:
-            raise u.ConfigurationError(e)
+            raise _u.ConfigurationError(e)
         
         return df_agg
         
-    def _get_key_from_record(self, key: Optional[str], record: dict[str, Any], default: Any) -> Any:
+    def _get_key_from_record(self, key: str | None, record: dict[str, _t.Any], default: _t.Any) -> _t.Any:
         return record[key] if key is not None else default
     
-    def _get_key_from_record_as_list(self, key: Optional[str], record: dict[str, Any]) -> Iterable[str]:
+    def _get_key_from_record_as_list(self, key: str | None, record: dict[str, _t.Any]) -> _t.Iterable[str]:
         value = self._get_key_from_record(key, record, list())
         return [str(x) for x in value]
-    
-    def is_from_seed(self) -> bool:
-        return self._from_seeds
 
 
-@dataclass
+@_d.dataclass
 class _SelectionDataSource(DataSource):
     """
     Abstract class for selection parameter data sources
     """
     _options_col: str
-    _order_by_col: Optional[str] # = field(default=None, kw_only=True)
-    _is_default_col: Optional[str] # = field(default=None, kw_only=True)
-    _custom_cols: dict[str, str] # = field(default_factory=dict, kw_only=True)
+    _order_by_col: str | None
+    _is_default_col: str | None
+    _custom_cols: dict[str, str]
 
-    @abstractmethod
+    @_abc.abstractmethod
     def __init__(
-        self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: Optional[str] = None, 
-        is_default_col: Optional[str] = None, custom_cols: dict[str, str] = {}, from_seeds: bool = False, 
-        user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, 
+        self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: str | None = None, 
+        is_default_col: str | None = None, custom_cols: dict[str, str] = {}, from_seeds: bool = False, 
+        user_group_col: str | None = None, parent_id_col: str | None = None, connection_name: str | None = None, 
         **kwargs
     ) -> None:
         super().__init__(
@@ -118,7 +109,7 @@ class _SelectionDataSource(DataSource):
         self._is_default_col = is_default_col
         self._custom_cols = custom_cols
 
-    def _get_all_options(self, df: pd.DataFrame) -> Sequence[po.SelectParameterOption]:
+    def _get_all_options(self, df: _pd.DataFrame) -> _t.Sequence[_po.SelectParameterOption]:
         columns = [self._options_col, self._order_by_col, self._is_default_col, *self._custom_cols.values()]
         df_agg = self._get_aggregated_df(df, columns)
 
@@ -127,18 +118,18 @@ class _SelectionDataSource(DataSource):
         else:
             df_agg.sort_values(self._order_by_col, inplace=True)
 
-        def get_is_default(record: dict[str, Any]) -> bool:
+        def get_is_default(record: dict[str, _t.Any]) -> bool:
             return int(record[self._is_default_col]) == 1 if self._is_default_col is not None else False
 
-        def get_custom_fields(record: dict[str, Any]) -> dict[str, Any]:
+        def get_custom_fields(record: dict[str, _t.Any]) -> dict[str, _t.Any]:
             result = {}
             for key, val in self._custom_cols.items():
                 result[key] = record[val]
             return result
         
-        records: dict[str, dict[str, Any]] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         return tuple(
-            po.SelectParameterOption(str(id), str(record[self._options_col]), 
+            _po.SelectParameterOption(str(id), str(record[self._options_col]), 
                                      is_default=get_is_default(record), custom_fields=get_custom_fields(record),
                                      user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
                                      parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
@@ -146,46 +137,43 @@ class _SelectionDataSource(DataSource):
         )
 
 
-@dataclass
+@_d.dataclass
 class SelectDataSource(_SelectionDataSource):
     """
     Lookup table for select parameter options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to run
-        id_col: The column name of the id
-        options_col: The column name of the options
-        order_by_col: The column name to order the options by. Orders by the id_col instead if this is None
-        is_default_col: The column name that indicates which options are the default
-        custom_cols: Dictionary of attribute to column name for custom fields for the SelectParameterOption
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that must be selected for this option to be valid
-        connection_name: Name of the connection to use defined in connections.py
     """
 
     def __init__(
-            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: Optional[str] = None, 
-            is_default_col: Optional[str] = None, custom_cols: dict[str, str] = {}, from_seeds: bool = False, 
-            user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, 
+            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: str | None = None, 
+            is_default_col: str | None = None, custom_cols: dict[str, str] = {}, from_seeds: bool = False, 
+            user_group_col: str | None = None, parent_id_col: str | None = None, connection_name: str | None = None, 
             **kwargs
         ) -> None:
         """
         Constructor for SelectDataSource
 
-        Parameters:
-            ...see Attributes of SelectDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to run
+            id_col: The column name of the id
+            options_col: The column name of the options
+            order_by_col: The column name to order the options by. Orders by the id_col instead if this is None
+            is_default_col: The column name that indicates which options are the default
+            custom_cols: Dictionary of attribute to column name for custom fields for the SelectParameterOption
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that must be selected for this option to be valid
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, id_col, options_col, order_by_col=order_by_col, is_default_col=is_default_col, custom_cols=custom_cols,
             from_seeds=from_seeds, user_group_col=user_group_col, parent_id_col=parent_id_col, connection_name=connection_name
         )
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.SelectionParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.SelectionParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a SingleSelectParameterConfig or MultiSelectParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
@@ -193,77 +181,71 @@ class SelectDataSource(_SelectionDataSource):
             The converted parameter
         """
         all_options = self._get_all_options(df)
-        if ds_param.parameter_type == pc.SingleSelectParameterConfig:
-            return pc.SingleSelectParameterConfig(
+        if ds_param.parameter_type == _pc.SingleSelectParameterConfig:
+            return _pc.SingleSelectParameterConfig(
                 ds_param.name, ds_param.label, all_options, description=ds_param.description, 
                 user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name, **ds_param.extra_args
             )
-        elif ds_param.parameter_type == pc.MultiSelectParameterConfig:
-            return pc.MultiSelectParameterConfig(
+        elif ds_param.parameter_type == _pc.MultiSelectParameterConfig:
+            return _pc.MultiSelectParameterConfig(
                 ds_param.name, ds_param.label, all_options, description=ds_param.description, 
                 user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name, **ds_param.extra_args
             )
         else:
-            raise u.ConfigurationError(f'Invalid widget type "{ds_param.parameter_type}" for SelectDataSource')
+            raise _u.ConfigurationError(f'Invalid widget type "{ds_param.parameter_type}" for SelectDataSource')
 
 
-@dataclass
+@_d.dataclass
 class SingleSelectDataSource(_SelectionDataSource):
     """
     DEPRECATED. Use "SelectDataSource" instead.
     """
 
     def __init__(
-            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: Optional[str] = None, 
-            is_default_col: Optional[str] = None, custom_cols: dict[str, str] = {}, user_group_col: Optional[str] = None, 
-            parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: str | None = None, 
+            is_default_col: str | None = None, custom_cols: dict[str, str] = {}, user_group_col: str | None = None, 
+            parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
         ) -> None:
         """
-        Constructor for SelectDataSource
-
-        Parameters:
-            ...see Attributes of SelectDataSource
+        DEPRECATED. Use "SelectDataSource" instead.
         """
         super().__init__(table_or_query, id_col, options_col, order_by_col=order_by_col, is_default_col=is_default_col,
                          custom_cols=custom_cols, user_group_col=user_group_col, parent_id_col=parent_id_col, 
                          connection_name=connection_name)
     
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.SingleSelectParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.SingleSelectParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a SingleSelectParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.SingleSelectParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.SingleSelectParameterConfig)
         all_options = self._get_all_options(df)
-        return pc.SingleSelectParameterConfig(ds_param.name, ds_param.label, all_options, description=ds_param.description, 
+        return _pc.SingleSelectParameterConfig(ds_param.name, ds_param.label, all_options, description=ds_param.description, 
                                               user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
 
-@dataclass
+@_d.dataclass
 class MultiSelectDataSource(_SelectionDataSource):
     """
     DEPRECATED. Use "SelectDataSource" instead.
     """
-    _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
+    _order_matters: bool
+    _none_is_all: bool
 
     def __init__(
-            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: Optional[str] = None, 
-            is_default_col: Optional[str] = None, custom_cols: dict[str, str] = {}, show_select_all: bool = True, 
-            order_matters: bool = False, none_is_all: bool = True, user_group_col: Optional[str] = None,
-            parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+            self, table_or_query: str, id_col: str, options_col: str, *, order_by_col: str | None = None, 
+            is_default_col: str | None = None, custom_cols: dict[str, str] = {}, show_select_all: bool = True, 
+            order_matters: bool = False, none_is_all: bool = True, user_group_col: str | None = None,
+            parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
         ) -> None:
         """
-        Constructor for SingleSelectDataSource
-
-        Parameters:
-            ...see Attributes of SingleSelectDataSource
+        DEPRECATED. Use "SelectDataSource" instead.
         """
         super().__init__(table_or_query, id_col, options_col, order_by_col=order_by_col, is_default_col=is_default_col,
                          custom_cols=custom_cols, user_group_col=user_group_col, parent_id_col=parent_id_col, 
@@ -272,121 +254,122 @@ class MultiSelectDataSource(_SelectionDataSource):
         self._order_matters = order_matters
         self._none_is_all = none_is_all
     
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.MultiSelectParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.MultiSelectParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a MultiSelectParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.MultiSelectParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.MultiSelectParameterConfig)
         all_options = self._get_all_options(df)
-        return pc.MultiSelectParameterConfig(
+        return _pc.MultiSelectParameterConfig(
             ds_param.name, ds_param.label, all_options, show_select_all=self._show_select_all,
             order_matters=self._order_matters, none_is_all=self._none_is_all, description=ds_param.description, 
             user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name
         )
 
 
-@dataclass
+@_d.dataclass
 class DateDataSource(DataSource):
     """
     Lookup table for date parameter default options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to run
-        default_date_col: The column name of the default date
-        date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
-        id_col: The column name of the id
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that the default date belongs to
-        connection_name: Name of the connection to use defined in connections.py
     """
     _default_date_col: str
-    _date_format: str # = field(default="%Y-%m-%d", kw_only=True)
+    _date_format: str
 
     def __init__(
-        self, table_or_query: str, default_date_col: str, *, date_format: str = '%Y-%m-%d', id_col: Optional[str] = None, 
-        from_seeds: bool = False, user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, 
-        connection_name: Optional[str] = None, **kwargs
+        self, table_or_query: str, default_date_col: str, *, min_date_col: str | None = None, 
+        max_date_col: str | None = None, date_format: str = '%Y-%m-%d', id_col: str | None = None, 
+        from_seeds: bool = False, user_group_col: str | None = None, parent_id_col: str | None = None, 
+        connection_name: str | None = None, **kwargs
     ) -> None:
         """
         Constructor for DateDataSource
 
-        Parameters:
-            ...see Attributes of DateDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to run
+            default_date_col: The column name of the default date
+            date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
+            id_col: The column name of the id
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that the default date belongs to
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, id_col=id_col, from_seeds=from_seeds, user_group_col=user_group_col, parent_id_col=parent_id_col, 
             connection_name=connection_name
         )
         self._default_date_col = default_date_col
+        self._min_date_col = min_date_col
+        self._max_date_col = max_date_col
         self._date_format = date_format
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.DateParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.DateParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a DateParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.DateParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.DateParameterConfig)
 
-        columns = [self._default_date_col]
+        columns = [self._default_date_col, self._min_date_col, self._max_date_col]
         df_agg = self._get_aggregated_df(df, columns)
 
-        records: dict[str, dict[str, Any]] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         options = tuple(
-            po.DateParameterOption(str(record[self._default_date_col]), date_format=self._date_format, 
-                                   user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
-                                   parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
+            _po.DateParameterOption(
+                str(record[self._default_date_col]), date_format=self._date_format, 
+                min_date = str(record[self._min_date_col]) if self._min_date_col else None,
+                max_date = str(record[self._max_date_col]) if self._max_date_col else None,
+                user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
+                parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record)
+            )
             for _, record in records.items()
         )
-        return pc.DateParameterConfig(
+        return _pc.DateParameterConfig(
             ds_param.name, ds_param.label, options, description=ds_param.description, user_attribute=ds_param.user_attribute, 
             parent_name=ds_param.parent_name, **ds_param.extra_args
         )
 
 
-@dataclass
+@_d.dataclass
 class DateRangeDataSource(DataSource):
     """
     Lookup table for date parameter default options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to run
-        default_start_date_col: The column name of the default start date
-        default_end_date_col: The column name of the default end date
-        date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
-        id_col: The column name of the id
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that the default date belongs to
-        connection_name: Name of the connection to use defined in connections.py
     """
     _default_start_date_col: str
     _default_end_date_col: str
-    _date_format: str # = field(default="%Y-%m-%d", kw_only=True)
+    _date_format: str
 
     def __init__(
         self, table_or_query: str, default_start_date_col: str, default_end_date_col: str, *, date_format: str = '%Y-%m-%d',
-        id_col: Optional[str] = None, from_seeds: bool = False, user_group_col: Optional[str] = None, 
-        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        min_date_col: str | None = None, max_date_col: str | None = None, id_col: str | None = None, from_seeds: bool = False, 
+        user_group_col: str | None = None, parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
     ) -> None:
         """
         Constructor for DateRangeDataSource
 
-        Parameters:
-            ...see Attributes of DateRangeDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to run
+            default_start_date_col: The column name of the default start date
+            default_end_date_col: The column name of the default end date
+            date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
+            id_col: The column name of the id
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that the default date belongs to
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, id_col=id_col, from_seeds=from_seeds, user_group_col=user_group_col, parent_id_col=parent_id_col, 
@@ -394,52 +377,58 @@ class DateRangeDataSource(DataSource):
         )
         self._default_start_date_col = default_start_date_col
         self._default_end_date_col = default_end_date_col
+        self._min_date_col = min_date_col
+        self._max_date_col = max_date_col
         self._date_format = date_format
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.DateRangeParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.DateRangeParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a DateRangeParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.DateRangeParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.DateRangeParameterConfig)
 
-        columns = [self._default_start_date_col, self._default_end_date_col]
+        columns = [self._default_start_date_col, self._default_end_date_col, self._min_date_col, self._max_date_col]
         df_agg = self._get_aggregated_df(df, columns)
 
-        records: dict[str, dict[str, Any]] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         options = tuple(
-            po.DateRangeParameterOption(str(record[self._default_start_date_col]), str(record[self._default_end_date_col]),
-                                        date_format=self._date_format, 
-                                        user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
-                                        parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
+            _po.DateRangeParameterOption(
+                str(record[self._default_start_date_col]), str(record[self._default_end_date_col]),
+                min_date=str(record[self._min_date_col]) if self._min_date_col else None, 
+                max_date=str(record[self._max_date_col]) if self._max_date_col else None, 
+                date_format=self._date_format, 
+                user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
+                parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record)
+            )
             for _, record in records.items()
         )
-        return pc.DateRangeParameterConfig(
+        return _pc.DateRangeParameterConfig(
             ds_param.name, ds_param.label, options, description=ds_param.description, user_attribute=ds_param.user_attribute, 
             parent_name=ds_param.parent_name, **ds_param.extra_args
         )
 
 
-@dataclass
+@_d.dataclass
 class _NumericDataSource(DataSource):
     """
     Abstract class for number or number range data sources
     """
     _min_value_col: str
     _max_value_col: str
-    _increment_col: Optional[str] # = field(default=None, kw_only=True)
+    _increment_col: str | None
     
-    @abstractmethod
+    @_abc.abstractmethod
     def __init__(
-        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: Optional[str] = None, 
-        id_col: Optional[str] = None, from_seeds: bool = False, user_group_col: Optional[str] = None, 
-        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: str | None = None, 
+        id_col: str | None = None, from_seeds: bool = False, user_group_col: str | None = None, 
+        parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
     ) -> None:
         super().__init__(
             table_or_query, id_col=id_col, from_seeds=from_seeds, user_group_col=user_group_col, parent_id_col=parent_id_col, 
@@ -450,35 +439,32 @@ class _NumericDataSource(DataSource):
         self._increment_col = increment_col
 
 
-@dataclass
+@_d.dataclass
 class NumberDataSource(_NumericDataSource):
     """
     Lookup table for number parameter default options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to run
-        min_value_col: The column name of the minimum value
-        max_value_col: The column name of the maximum value
-        increment_col: The column name of the increment value. Defaults to column of 1's if None
-        default_value_col: The column name of the default value. Defaults to min_value_col if None
-        id_col: The column name of the id
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that the default value belongs to
-        connection_name: Name of the connection to use defined in connections.py
     """
-    _default_value_col: Optional[str] # = field(default=None, kw_only=True)
+    _default_value_col: str | None
 
     def __init__(
-        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: Optional[str] = None,
-        default_value_col: Optional[str] = None, id_col: Optional[str] = None, from_seeds: bool = False, 
-        user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: str | None = None,
+        default_value_col: str | None = None, id_col: str | None = None, from_seeds: bool = False, 
+        user_group_col: str | None = None, parent_id_col: str | None = None, connection_name: str | None = None, **kwargs
     ) -> None:
         """
         Constructor for NumberDataSource
 
-        Parameters:
-            ...see Attributes of NumberDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to run
+            min_value_col: The column name of the minimum value
+            max_value_col: The column name of the maximum value
+            increment_col: The column name of the increment value. Defaults to column of 1's if None
+            default_value_col: The column name of the default value. Defaults to min_value_col if None
+            id_col: The column name of the id
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that the default value belongs to
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, min_value_col, max_value_col, increment_col=increment_col, id_col=id_col, from_seeds=from_seeds,
@@ -486,69 +472,66 @@ class NumberDataSource(_NumericDataSource):
         )
         self._default_value_col = default_value_col
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.NumberParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.NumberParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a NumberParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.NumberParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.NumberParameterConfig)
 
         columns = [self._min_value_col, self._max_value_col, self._increment_col, self._default_value_col]
         df_agg = self._get_aggregated_df(df, columns)
 
-        records: dict[str, dict[str, Any]] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         options = tuple(
-            po.NumberParameterOption(record[self._min_value_col], record[self._max_value_col], 
+            _po.NumberParameterOption(record[self._min_value_col], record[self._max_value_col], 
                                      increment=self._get_key_from_record(self._increment_col, record, 1),
                                      default_value=self._get_key_from_record(self._default_value_col, record, None),
                                      user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
                                      parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
             for _, record in records.items()
         )
-        return pc.NumberParameterConfig(
+        return _pc.NumberParameterConfig(
             ds_param.name, ds_param.label, options, description=ds_param.description, user_attribute=ds_param.user_attribute, 
             parent_name=ds_param.parent_name, **ds_param.extra_args
         )
 
 
-@dataclass
+@_d.dataclass
 class NumberRangeDataSource(_NumericDataSource):
     """
     Lookup table for number range parameter default options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to 
-        min_value_col: The column name of the minimum value
-        max_value_col: The column name of the maximum value
-        increment_col: The column name of the increment value. Defaults to column of 1's if None
-        default_lower_value_col: The column name of the default lower value. Defaults to min_value_col if None
-        default_upper_value_col: The column name of the default upper value. Defaults to max_value_col if None
-        id_col: The column name of the id
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that the default value belongs to
-        connection_name: Name of the connection to use defined in connections.py
     """
-    _default_lower_value_col: Optional[str] # = field(default=None, kw_only=True)
-    _default_upper_value_col: Optional[str] # = field(default=None, kw_only=True)
+    _default_lower_value_col: str | None
+    _default_upper_value_col: str | None
 
     def __init__(
-        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: Optional[str] = None,
-        default_lower_value_col: Optional[str] = None, default_upper_value_col: Optional[str] = None, id_col: Optional[str] = None, 
-        from_seeds: bool = False, user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, 
-        connection_name: Optional[str] = None, **kwargs
+        self, table_or_query: str, min_value_col: str, max_value_col: str, *, increment_col: str | None = None,
+        default_lower_value_col: str | None = None, default_upper_value_col: str | None = None, id_col: str | None = None, 
+        from_seeds: bool = False, user_group_col: str | None = None, parent_id_col: str | None = None, 
+        connection_name: str | None = None, **kwargs
     ) -> None:
         """
         Constructor for NumRangeDataSource
 
-        Parameters:
-            ...see Attributes of NumRangeDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to 
+            min_value_col: The column name of the minimum value
+            max_value_col: The column name of the maximum value
+            increment_col: The column name of the increment value. Defaults to column of 1's if None
+            default_lower_value_col: The column name of the default lower value. Defaults to min_value_col if None
+            default_upper_value_col: The column name of the default upper value. Defaults to max_value_col if None
+            id_col: The column name of the id
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that the default value belongs to
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, min_value_col, max_value_col, increment_col=increment_col, id_col=id_col, from_seeds=from_seeds, 
@@ -557,25 +540,25 @@ class NumberRangeDataSource(_NumericDataSource):
         self._default_lower_value_col = default_lower_value_col
         self._default_upper_value_col = default_upper_value_col
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.NumberRangeParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.NumberRangeParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a NumberRangeParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.NumberRangeParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.NumberRangeParameterConfig)
 
         columns = [self._min_value_col, self._max_value_col, self._increment_col, self._default_lower_value_col, self._default_upper_value_col]
         df_agg = self._get_aggregated_df(df, columns)
 
-        records: dict[str, Any] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         options = tuple(
-            po.NumberRangeParameterOption(record[self._min_value_col], record[self._max_value_col], 
+            _po.NumberRangeParameterOption(record[self._min_value_col], record[self._max_value_col], 
                                        increment=self._get_key_from_record(self._increment_col, record, 1),
                                        default_lower_value=self._get_key_from_record(self._default_lower_value_col, record, None),
                                        default_upper_value=self._get_key_from_record(self._default_upper_value_col, record, None),
@@ -583,38 +566,35 @@ class NumberRangeDataSource(_NumericDataSource):
                                        parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
             for _, record in records.items()
         )
-        return pc.NumberRangeParameterConfig(
+        return _pc.NumberRangeParameterConfig(
             ds_param.name, ds_param.label, options, description=ds_param.description, user_attribute=ds_param.user_attribute, 
             parent_name=ds_param.parent_name, **ds_param.extra_args
         )
 
 
-@dataclass
+@_d.dataclass
 class TextDataSource(DataSource):
     """
     Lookup table for text parameter default options
-
-    Attributes:
-        table_or_query: Either the name of the table to use, or a query to run
-        default_text_col: The column name of the default text
-        id_col: The column name of the id
-        from_seeds: Boolean for whether this datasource is created from seeds
-        user_group_col: The column name of the user group that the user is in for this option to be valid
-        parent_id_col: The column name of the parent option id that the default date belongs to
-        connection_name: Name of the connection to use defined in connections.py
     """
     _default_text_col: str
 
     def __init__(
-        self, table_or_query: str, default_text_col: str, *, id_col: Optional[str] = None, from_seeds: bool = False, 
-        user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None,
+        self, table_or_query: str, default_text_col: str, *, id_col: str | None = None, from_seeds: bool = False, 
+        user_group_col: str | None = None, parent_id_col: str | None = None, connection_name: str | None = None,
         **kwargs
     ) -> None:
         """
-        Constructor for DateDataSource
+        Constructor for TextDataSource
 
-        Parameters:
-            ...see Attributes of DateDataSource
+        Arguments:
+            table_or_query: Either the name of the table to use, or a query to run
+            default_text_col: The column name of the default text
+            id_col: The column name of the id
+            from_seeds: Boolean for whether this datasource is created from seeds
+            user_group_col: The column name of the user group that the user is in for this option to be valid
+            parent_id_col: The column name of the parent option id that the default date belongs to
+            connection_name: Name of the connection to use defined in connections.py
         """
         super().__init__(
             table_or_query, id_col=id_col, from_seeds=from_seeds, user_group_col=user_group_col, parent_id_col=parent_id_col, 
@@ -622,30 +602,30 @@ class TextDataSource(DataSource):
         )
         self._default_text_col = default_text_col
 
-    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.TextParameterConfig:
+    def _convert(self, ds_param: _pc.DataSourceParameterConfig, df: _pd.DataFrame) -> _pc.TextParameterConfig:
         """
         Method to convert the associated DataSourceParameter into a TextParameterConfig
 
-        Parameters:
+        Arguments:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        self._validate_parameter_type(ds_param, pc.TextParameterConfig)
+        self._validate_parameter_type(ds_param, _pc.TextParameterConfig)
 
         columns = [self._default_text_col]
         df_agg = self._get_aggregated_df(df, columns)
 
-        records: dict[str, dict[str, Any]] = df_agg.to_dict("index")
+        records = df_agg.to_dict("index")
         options = tuple(
-            po.TextParameterOption(default_text=str(record[self._default_text_col]), 
+            _po.TextParameterOption(default_text=str(record[self._default_text_col]), 
                                    user_groups=self._get_key_from_record_as_list(self._user_group_col, record), 
                                    parent_option_ids=self._get_key_from_record_as_list(self._parent_id_col, record))
             for _, record in records.items()
         )
-        return pc.TextParameterConfig(
+        return _pc.TextParameterConfig(
             ds_param.name, ds_param.label, options, description=ds_param.description, user_attribute=ds_param.user_attribute, 
             parent_name=ds_param.parent_name, **ds_param.extra_args
         )