squirrels 0.1.1.post1__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

squirrels/data_sources.py

@@ -1,65 +1,196 @@
 from __future__ import annotations
-from typing import Type, Dict, Tuple, List, Optional
+from typing import Type, Sequence, Iterable, Optional, Any
 from dataclasses import dataclass, field
+from abc import ABCMeta, abstractmethod
+import pandas as pd
 
-from squirrels import parameters as p, parameter_options as po
-from squirrels._timed_imports import pandas as pd
-from squirrels import _constants as c, _utils
+from . import _parameter_configs as pc, parameter_options as po, _utils as u, _constants as c
+from ._manifest import ManifestIO
 
 
 @dataclass
-class DataSource:
+class DataSource(metaclass=ABCMeta):
     """
     Abstract class for lookup tables coming from a database
     """
-    table_or_query: str
+    _table_or_query: str
+    _id_col: Optional[str]
+    _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)
+
+    @abstractmethod
+    def __init__(
+        self, table_or_query: str, *, id_col: Optional[str] = None, user_group_col: Optional[str] = None, 
+        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        self._table_or_query = table_or_query
+        self._id_col = id_col
+        self._user_group_col = user_group_col
+        self._parent_id_col = parent_id_col
+        self._connection_name = connection_name
     
-    def __post_init__(self) -> None:
-        if not hasattr(self, 'parent_id_col'):
-            self.parent_id_col = None
-        if not hasattr(self, 'connection_name'):
-            self.connection_name = c.DEFAULT_DB_CONN
+    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_query(self) -> str:
+    def _get_query(self) -> str:
         """
         Get the "table_or_query" attribute as a select query
 
         Returns:
             str: The converted select query
         """
-        if self.table_or_query.strip().lower().startswith('select '):
-            query = self.table_or_query
+        if self._table_or_query.strip().lower().startswith('select '):
+            query = self._table_or_query
         else:
-            query = f'SELECT * FROM {self.table_or_query}'
+            query = f'SELECT * FROM {self._table_or_query}'
         return query
     
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.Parameter:
+    @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:
+        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}')
+    
+    def _get_aggregated_df(self, df: pd.DataFrame, columns_to_include: Iterable[str]) -> pd.DataFrame:
+        agg_rules = {}
+        for column in columns_to_include:
+            if column is not None:
+                agg_rules[column] = "first"
+        if self._user_group_col is not None:
+            agg_rules[self._user_group_col] = list
+        if self._parent_id_col is not None:
+            agg_rules[self._parent_id_col] = list
+
+        groupby_dim = self._id_col if self._id_col is not None else df.index
+        try:
+            df_agg = df.groupby(groupby_dim).agg(agg_rules)
+        except KeyError as e:
+            raise u.ConfigurationError(e)
+        
+        return df_agg
+        
+    def _get_key_from_record(self, key: Optional[str], record: dict[str, Any], default: Any) -> 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]:
+        value = self._get_key_from_record(key, record, list())
+        return [str(x) for x in value]
+
 
-        Args:
+@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)
+
+    @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] = {}, user_group_col: Optional[str] = None, 
+        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        super().__init__(table_or_query, id_col=id_col, user_group_col=user_group_col, parent_id_col=parent_id_col, 
+                         connection_name=connection_name)
+        self._options_col = options_col
+        self._order_by_col = order_by_col
+        self._is_default_col = is_default_col
+        self._custom_cols = custom_cols
+
+    def _get_all_options(self, df: pd.DataFrame) -> 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)
+
+        if self._order_by_col is None:
+            df_agg.sort_index(inplace=True)
+        else:
+            df_agg.sort_values(self._order_by_col, inplace=True)
+
+        def get_is_default(record: dict[str, 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]:
+            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")
+        return tuple(
+            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))
+            for id, record in records.items()
+        )
+
+
+@dataclass
+class SingleSelectDataSource(_SelectionDataSource):
+    """
+    Lookup table for single 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
+        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] = {}, user_group_col: Optional[str] = None, 
+            parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        ) -> None:
+        """
+        Constructor for SingleSelectDataSource
+
+        Parameters:
+            ...see Attributes of SingleSelectDataSource
+        """
+        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:
+        """
+        Method to convert the associated DataSourceParameter into a SingleSelectParameterConfig
+
+        Parameters:
             ds_param: The parameter to convert
             df: The dataframe containing the parameter options data
 
         Returns:
             The converted parameter
         """
-        raise _utils.AbstractMethodCallError(self.__class__, "convert")
-    
-    def _get_parent(self, row):
-        return str(_utils.get_row_value(row, self.parent_id_col)) if self.parent_id_col is not None else None
-    
-    def _validate_parameter_class(self, ds_param: p.DataSourceParameter, parameter_classes: List[Type[p.Parameter]]) -> None:
-        if ds_param.parameter_class not in parameter_classes:
-            parameter_class_name = ds_param.parameter_class.__name__
-            datasource_class_name = self.__class__.__name__
-            raise _utils.ConfigurationError(f'Invalid widget type "{parameter_class_name}" for {datasource_class_name}')
+        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, is_hidden=ds_param.is_hidden, 
+                                              user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
 
 
 @dataclass
-class SelectionDataSource(DataSource):
+class MultiSelectDataSource(_SelectionDataSource):
     """
-    Lookup table for selection parameters (single and multi)
+    Lookup table for single select parameter options
 
     Attributes:
         table_or_query: Either the name of the table to use, or a query to run
@@ -67,24 +198,36 @@ class SelectionDataSource(DataSource):
         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
-        parent_id_col: The column name of the parent option id that this option belongs to
         custom_cols: Dictionary of attribute to column name for custom fields for the SelectParameterOption
+        include_all: Whether applying no selection is equivalent to selecting all. Default is True
+        order_matters: Whether the ordering of the selection matters. Default is False 
+        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
     """
-    id_col: str
-    options_col: str
-    order_by_col: Optional[str] = None
-    is_default_col: Optional[str] = None
-    parent_id_col: Optional[str] = None
-    custom_cols: Dict[str, str] = field(default_factory=dict)
-    connection_name: str = c.DEFAULT_DB_CONN
-
-    def __post_init__(self):
-        self.order_by_col = self.order_by_col if self.order_by_col is not None else self.id_col
-
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.Parameter:
+    _include_all: bool # = field(default=True, kw_only=True)
+    _order_matters: bool # = field(default=False, kw_only=True)
+
+    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] = {}, include_all: bool = True, order_matters: bool = False, 
+            user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+        ) -> None:
+        """
+        Constructor for SingleSelectDataSource
+
+        Parameters:
+            ...see Attributes of SingleSelectDataSource
+        """
+        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)
+        self._include_all = include_all
+        self._order_matters = order_matters
+    
+    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.MultiSelectParameterConfig:
         """
-        Method to convert the associated DataSourceParameter into a SingleSelect or MultiSelect Parameter
+        Method to convert the associated DataSourceParameter into a MultiSelectParameterConfig
 
         Parameters:
             ds_param: The parameter to convert
@@ -93,29 +236,11 @@ class SelectionDataSource(DataSource):
         Returns:
             The converted parameter
         """
-        self._validate_parameter_class(ds_param, [p.SingleSelectParameter, p.MultiSelectParameter])
-
-        def is_default(row):
-            return int(_utils.get_row_value(row, self.is_default_col)) == 1 if self.is_default_col is not None else False
-        
-        def get_custom_fields(row):
-            result = {}
-            for key, val in self.custom_cols.items():
-                result[key] = _utils.get_row_value(row, val)
-            return result
-        
-        try:
-            df.sort_values(self.order_by_col, inplace=True)
-        except KeyError as e:
-            raise _utils.ConfigurationError(f'Could not sort on column name "{self.order_by_col}" as it does not exist')
-        
-        options = tuple(
-            po.SelectParameterOption(str(_utils.get_row_value(row, self.id_col)), str(_utils.get_row_value(row, self.options_col)), 
-                                     is_default=is_default(row), parent_option_id=self._get_parent(row), custom_fields=get_custom_fields(row))
-            for _, row in df.iterrows()
-        )
-        
-        return ds_param.parameter_class(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden, parent=ds_param.parent)
+        self._validate_parameter_type(ds_param, pc.MultiSelectParameterConfig)
+        all_options = self._get_all_options(df)
+        return pc.MultiSelectParameterConfig(ds_param.name, ds_param.label, all_options, include_all=self._include_all, 
+                                             order_matters=self._order_matters, is_hidden=ds_param.is_hidden, 
+                                             user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
 
 
 @dataclass
@@ -125,19 +250,97 @@ class DateDataSource(DataSource):
 
     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
         default_date_col: The column name of the default date
+        date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
+        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)
+
+    def __init__(
+        self, table_or_query: str, default_date_col: str, *, date_format: str = '%Y-%m-%d', id_col: Optional[str] = None, 
+        user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Constructor for DateDataSource
+
+        Parameters:
+            ...see Attributes of DateDataSource
+        """
+        super().__init__(table_or_query, id_col=id_col, user_group_col=user_group_col, parent_id_col=parent_id_col, 
+                         connection_name=connection_name)
+        self._default_date_col = default_date_col
+        self._date_format = date_format
+
+    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.DateParameterConfig:
+        """
+        Method to convert the associated DataSourceParameter into a DateParameterConfig
+
+        Parameters:
+            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)
+
+        columns = [self._default_date_col]
+        df_agg = self._get_aggregated_df(df, columns)
+
+        records: dict[str, dict[str, Any]] = 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))
+            for _, record in records.items()
+        )
+        return pc.DateParameterConfig(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden, 
+                                      user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
+
+
+@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
+        id_col: The column name of the id
+        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'
+        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
-    parent_id_col: Optional[str] = None
-    date_format: Optional[str] = '%Y-%m-%d'
-    connection_name: str = c.DEFAULT_DB_CONN
+    _default_start_date_col: str
+    _default_end_date_col: str
+    _date_format: str # = field(default="%Y-%m-%d", kw_only=True)
+
+    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, user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, 
+        connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Constructor for DateRangeDataSource
+
+        Parameters:
+            ...see Attributes of DateRangeDataSource
+        """
+        super().__init__(table_or_query, id_col=id_col, user_group_col=user_group_col, parent_id_col=parent_id_col, 
+                         connection_name=connection_name)
+        self._default_start_date_col = default_start_date_col
+        self._default_end_date_col = default_end_date_col
+        self._date_format = date_format
 
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.DateParameter:
+    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.DateRangeParameterConfig:
         """
-        Method to convert the associated DataSourceParameter into a DateParameter
+        Method to convert the associated DataSourceParameter into a DateRangeParameterConfig
 
         Parameters:
             ds_param: The parameter to convert
@@ -146,22 +349,21 @@ class DateDataSource(DataSource):
         Returns:
             The converted parameter
         """
-        self._validate_parameter_class(ds_param, [p.DateParameter])
-        
-        def get_date(row: pd.Series) -> str:
-            return str(_utils.get_row_value(row, self.default_date_col))
-        
-        def create_date_param_option(row: pd.Series) -> po.DateParameterOption:
-            return po.DateParameterOption(get_date(row), self.date_format, self._get_parent(row))
-        
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            return p.DateParameter(ds_param.name, ds_param.label, get_date(row), self.date_format, 
-                                   is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(create_date_param_option(row) for _, row in df.iterrows())
-            return p.DateParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                              is_hidden=ds_param.is_hidden)
+        self._validate_parameter_type(ds_param, pc.DateRangeParameterConfig)
+
+        columns = [self._default_start_date_col, self._default_end_date_col]
+        df_agg = self._get_aggregated_df(df, columns)
+
+        records: dict[str, dict[str, Any]] = 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))
+            for _, record in records.items()
+        )
+        return pc.DateRangeParameterConfig(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden, 
+                                           user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
 
 
 @dataclass
@@ -169,15 +371,21 @@ class _NumericDataSource(DataSource):
     """
     Abstract class for number or number range data sources
     """
-    min_value_col: str
-    max_value_col: str
-    increment_col: Optional[str] = None
+    _min_value_col: str
+    _max_value_col: str
+    _increment_col: Optional[str] # = field(default=None, kw_only=True)
+    
+    @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, user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, 
+        connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        super().__init__(table_or_query, id_col=id_col, user_group_col=user_group_col, parent_id_col=parent_id_col, connection_name=connection_name)
+        self._min_value_col = min_value_col
+        self._max_value_col = max_value_col
+        self._increment_col = increment_col
 
-    def _convert_helper(self, row: pd.Series) -> Tuple[str, str, str]:
-        min_val = str(_utils.get_row_value(row, self.min_value_col))
-        max_val = str(_utils.get_row_value(row, self.max_value_col))
-        incr_val = str(_utils.get_row_value(row, self.increment_col)) if self.increment_col is not None else '1'
-        return min_val, max_val, incr_val
 
 @dataclass
 class NumberDataSource(_NumericDataSource):
@@ -186,20 +394,35 @@ class NumberDataSource(_NumericDataSource):
 
     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
         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
+        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] = None
-    parent_id_col: Optional[str] = None
-    connection_name: str = c.DEFAULT_DB_CONN
+    _default_value_col: Optional[str] # = field(default=None, kw_only=True)
+
+    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, user_group_col: Optional[str] = None, 
+        parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Constructor for NumberDataSource
 
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.NumberParameter:
+        Parameters:
+            ...see Attributes of NumberDataSource
+        """
+        super().__init__(table_or_query, min_value_col, max_value_col, increment_col=increment_col, id_col=id_col, 
+                         user_group_col=user_group_col, parent_id_col=parent_id_col, connection_name=connection_name)
+        self._default_value_col = default_value_col
+
+    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.NumberParameterConfig:
         """
-        Method to convert the associated DataSourceParameter into a NumberParameter
+        Method to convert the associated DataSourceParameter into a NumberParameterConfig
 
         Parameters:
             ds_param: The parameter to convert
@@ -208,51 +431,63 @@ class NumberDataSource(_NumericDataSource):
         Returns:
             The converted parameter
         """
-        self._validate_parameter_class(ds_param, [p.NumberParameter])
+        self._validate_parameter_type(ds_param, pc.NumberParameterConfig)
 
-        def _get_default_value(row: pd.Series) -> str:
-            return str(_utils.get_row_value(row, self.default_value_col)) if self.default_value_col is not None \
-                else str(_utils.get_row_value(row, self.min_value_col))
-        
-        def _create_num_param_option(row: pd.Series) -> po.NumberParameterOption:
-            min_value, max_value, increment = self._convert_helper(row)
-            return po.NumberParameterOption(min_value, max_value, increment, _get_default_value(row), 
-                                            self._get_parent(row))
-
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            min_value, max_value, increment = self._convert_helper(row)
-            return p.NumberParameter(ds_param.name, ds_param.label, min_value, max_value, increment, 
-                                     _get_default_value(row), is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(_create_num_param_option(row) for _, row in df.iterrows())
-            return p.NumberParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                                is_hidden=ds_param.is_hidden)
+        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")
+        options = tuple(
+            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(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden,
+                                        user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)
 
 
 @dataclass
-class NumRangeDataSource(_NumericDataSource):
+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 run
+        table_or_query: Either the name of the table to use, or a query to 
+        id_col: The column name of the id
         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
+        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] = None
-    default_upper_value_col: Optional[str] = None
-    parent_id_col: Optional[str] = None
-    connection_name: str = c.DEFAULT_DB_CONN
+    _default_lower_value_col: Optional[str] # = field(default=None, kw_only=True)
+    _default_upper_value_col: Optional[str] # = field(default=None, kw_only=True)
+
+    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, 
+        user_group_col: Optional[str] = None, parent_id_col: Optional[str] = None, connection_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Constructor for NumRangeDataSource
+
+        Parameters:
+            ...see Attributes of NumRangeDataSource
+        """
+        super().__init__(table_or_query, min_value_col, max_value_col, increment_col=increment_col, id_col=id_col, 
+                         user_group_col=user_group_col, parent_id_col=parent_id_col, connection_name=connection_name)
+        self._default_lower_value_col = default_lower_value_col
+        self._default_upper_value_col = default_upper_value_col
 
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.NumRangeParameter:
+    def _convert(self, ds_param: pc.DataSourceParameterConfig, df: pd.DataFrame) -> pc.NumberRangeParameterConfig:
         """
-        Method to convert the associated DataSourceParameter into a NumRangeParameter
+        Method to convert the associated DataSourceParameter into a NumberRangeParameterConfig
 
         Parameters:
             ds_param: The parameter to convert
@@ -261,30 +496,20 @@ class NumRangeDataSource(_NumericDataSource):
         Returns:
             The converted parameter
         """
-        self._validate_parameter_class(ds_param, [p.NumRangeParameter])
-
-        def _get_default_lower_upper_values(row: pd.Series) -> Tuple[str, str]:
-            lower_value_col = self.default_lower_value_col if self.default_lower_value_col is not None \
-                else self.min_value_col
-            upper_value_col = self.default_upper_value_col if self.default_upper_value_col is not None \
-                else self.max_value_col
-            lower_value = str(_utils.get_row_value(row, lower_value_col))
-            upper_value = str(_utils.get_row_value(row, upper_value_col))
-            return lower_value, upper_value
-        
-        def _create_range_param_option(row: pd.Series) -> po.NumRangeParameterOption:
-            min_value, max_value, increment = self._convert_helper(row)
-            lower_value, upper_value = _get_default_lower_upper_values(row)
-            return po.NumRangeParameterOption(min_value, max_value, increment, lower_value, upper_value, 
-                                           self._get_parent(row)) 
-
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            min_value, max_value, increment = self._convert_helper(row)
-            lower_value, upper_value = _get_default_lower_upper_values(row)
-            return p.NumRangeParameter(ds_param.name, ds_param.label, min_value, max_value, increment, 
-                                    lower_value, upper_value, is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(_create_range_param_option(row) for _, row in df.iterrows())
-            return p.NumRangeParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                                  is_hidden=ds_param.is_hidden)
+        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")
+        options = tuple(
+            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),
+                                       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.NumberRangeParameterConfig(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden,
+                                          user_attribute=ds_param.user_attribute, parent_name=ds_param.parent_name)