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

squirrels/parameters.py

@@ -1,210 +1,164 @@
 from __future__ import annotations
-from typing import Type, Sequence, Dict, List, Any, Iterator, Optional, Union
+from typing import Type, Sequence, Optional, Union, Any
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, date
 from decimal import Decimal
-import copy
+from abc import ABCMeta, abstractmethod
 
-from squirrels import parameter_options as po, _utils as u
-from squirrels.data_sources import DataSource
-from squirrels._parameter_set import ParameterSetBase
-from squirrels._timed_imports import pandas as pd
+from . import _parameter_configs as pc, _parameter_sets as ps, parameter_options as po, data_sources as d, _utils as u
 
 
 @dataclass
-class Parameter:
+class Parameter(metaclass=ABCMeta):
     """
-    Abstract class for all parameter classes. Useful for type hints.
+    Abstract class for all parameter widgets
     """
-    widget_type: str
-    name: str
-    label: str
-    all_options: Sequence[po.ParameterOption]
-    is_hidden: bool
-    parent: Optional[_SelectionParameter]
+    _config: pc.ParameterConfig
 
-    def WithParent(all_options: Sequence[po.ParameterOption], parent: SingleSelectParameter, new_param: Parameter):
-        """
-        Helper class method to assign a SingleSelectParameter as the parent for another parameter
-
-        Parameters:
-            all_options: The list of options with one of "parent_option_id" or "parent_option_ids" attribute set.
-            parent: The parent parameter. All option ids of the parent must exist at least once in "parent_option_ids" of all_options
-            new_param: The child parameter to modify. Usually not a selection parameter
-        """
-        new_param._set_parent_and_options(parent, all_options)
-        new_param.parent._add_child_mutate(new_param)
-        return new_param.refresh(parent)
-
-    def refresh(self, parent: Optional[_SelectionParameter] = None) -> Parameter:
+    @staticmethod
+    @abstractmethod
+    def _ParameterConfigType() -> Type:
+        pass
+    
+    @classmethod
+    def Create(
+        cls, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, is_hidden: bool = False, 
+        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+    ) -> None:
         """
-        Refreshes the selectable options (or change of default value) based on the selection of the parent parameter
+        Method for creating the configurations for a Parameter that may include user attribute or parent
 
         Parameters:
-            parent: The parent parameter subscribed to for updates
-        
-        Returns:
-            A copy of self for the new selectable options based on current selection of parent
+            name: The name of the parameter
+            label: The display label for the parameter
+            all_options: All options associated to this parameter regardless of the user group or parent parameter option they depend on
+            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
+            user_attribute: The user attribute that may cascade the options for this parameter. Default is None
+            parent_name: Name of parent parameter that may cascade the options for this parameter. Default is None (no parent)
         """
-        param_copy = copy.copy(self)
-        if parent is not None:
-            param_copy.parent = parent
-        param_copy._refresh_mutate()
-        return param_copy
+        param_config_type = cls._ParameterConfigType()
+        param_config = param_config_type(name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+                                         parent_name=parent_name, **kwargs)
+        ps.ParameterConfigsSetIO.obj.add(param_config)
 
-    def with_selection(self, _: str) -> Parameter:
-        """
-        Abstract method for applying the selection to the parameter
-        """
-        raise u.AbstractMethodCallError(self.__class__, "with_selection")
+    @classmethod
+    @abstractmethod
+    def CreateSimple(cls, name: str, label: str, *args, is_hidden: bool = False, **kwargs) -> None:
+        pass
     
-    def get_all_dependent_params(self) -> ParameterSetBase:
+    @classmethod
+    def CreateFromSource(
+        cls, name: str, label: str, data_source: Union[d.DataSource , dict], *, is_hidden: bool = False, 
+        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+    ) -> None:
         """
-        Gets the collection of descendent parameters with changes applied based on the selection of this parameter
+        Method for creating the configurations for any Parameter that uses a DataSource to received the options
 
-        Returns:
-            A collection of descendent parameters as a ParameterSetBase
+        Parameters:
+            name: The name of the parameter
+            label: The display label for the parameter
+            data_source: The lookup table to use for this parameter
+            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
+            user_attribute: The user attribute that may cascade the options for this parameter. Default is None
+            parent_name: Name of parent parameter that may cascade the options for this parameter. Default is None (no parent)
         """
-        dependent_params = ParameterSetBase()
-        self._accum_all_dependent_params(dependent_params)
-        return dependent_params
-    
-    def _set_default_as_selection_mutate(self) -> None:
-        raise u.AbstractMethodCallError(self.__class__, "_set_default_as_selection_mutate")
-    
-    def _refresh_mutate(self) -> None:
-        if self.parent is not None and hasattr(self, 'curr_option'):
-            self.curr_option = next(self._get_valid_options_iterator())
-        self._set_default_as_selection_mutate()
-    
-    def _get_valid_options_iterator(self) -> Iterator[po.ParameterOption]:
-        selected_parent_option_ids = self.parent._get_selected_ids_as_list()
-        return (x for x in self.all_options if x.is_valid(selected_parent_option_ids))
-    
-    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 _verify_parent_is_single_select(self) -> None:
-        if not isinstance(self.parent, SingleSelectParameter):
-            raise u.ConfigurationError(f'For "{self.name}", it''s not a selection parameter, so its parent must be a SingleSelectParameter')
-        
-    def _verify_parent_options_have_one_child_each(self) -> None:
-        accum_set = set()
-        for option in self.all_options:
-            if not accum_set.isdisjoint(option.parent_option_ids):
-                raise u.ConfigurationError(f'For "{self.name}", it''s not a selection parameter, so no two options can share the same parent option')
-            accum_set = accum_set.union(option.parent_option_ids)
-        if len(accum_set) != len(self.parent.options):
-            raise u.ConfigurationError(f'For "{self.name}", all parent option ids must exist across all options')
-    
-    def _set_parent_and_options(self, parent: SingleSelectParameter, all_options: Sequence[po.ParameterOption]) -> None:
-        self.parent = parent
-        self.all_options = all_options
-        self._verify_parent_is_single_select()
-        self._verify_parent_options_have_one_child_each()
-    
-    def _accum_all_dependent_params(self, param_set: ParameterSetBase) -> None:
-        param_set.add_parameter(self)
+        param_config_type = cls._ParameterConfigType()
+        param_config = pc.DataSourceParameterConfig(param_config_type, name, label, data_source, is_hidden=is_hidden, 
+                                                    user_attribute=user_attribute, parent_name=parent_name)
+        ps.ParameterConfigsSetIO.obj.add(param_config)
         
     def _enquote(self, value: str) -> str:
         return "'" + value.replace("'", "''") + "'" 
-
-    def to_json_dict(self) -> Dict:
+    
+    def _validate_date(self, input_date: str) -> date:
+        try:
+            return datetime.strptime(input_date.strip(), "%Y-%m-%d").date() if isinstance(input_date, str) else input_date
+        except ValueError as e:
+            self._config._raise_invalid_input_error(input_date, 'Invalid selection for date.', e)
+    
+    def _validate_number(self, input_number: po.Number, curr_option: po._NumericParameterOption) -> Decimal:
+        try:
+            return curr_option._validate_value(input_number)
+        except u.ConfigurationError as e:
+            self._config._raise_invalid_input_error(input_number, 'Invalid selection for number.', e)
+    
+    @abstractmethod
+    def to_json_dict0(self) -> dict:
         """
         Helper method to convert the derived Parameter class into a JSON dictionary
         """
-        return {
-            'widget_type': self.widget_type,
-            'name': self.name,
-            'label': self.label
-        }
+        return self._config.to_json_dict0()
 
 
 @dataclass
 class _SelectionParameter(Parameter):
-    def __post_init__(self) -> None:
-        self.trigger_refresh: bool = False
-        self.options: Sequence[po.SelectParameterOption] = tuple(self.all_options)
-        self.children: List[_SelectionParameter] = list()
-        if self.parent is not None:
-            self.parent._add_child_mutate(self)
-        self._refresh_mutate()
-    
-    def _add_child_mutate(self, child: Parameter) -> None:
-        self.children.append(child)
-        self.trigger_refresh = True
-    
-    def _refresh_mutate(self) -> None:
-        if self.parent is not None:
-            self.options = tuple(self._get_valid_options_iterator())
-        self._set_default_as_selection_mutate()
-        self.children = [child.refresh(self) for child in self.children]
+    _config: pc.SelectionParameterConfig
+    _options: Sequence[po.SelectParameterOption]
+
+    def __post_init__(self):
+        self._options = tuple(self._options)
 
+    @abstractmethod
     def _get_selected_ids_as_list(self) -> Sequence[str]:
-        raise u.AbstractMethodCallError(self.__class__, "_get_selected_ids_as_list")
+        pass
 
-    def _get_default_iterator(self) -> Iterator[po.ParameterOption]:
-        return (x.identifier for x in self.options if x.is_default)
+    def _validate_selected_id_in_options(self, selected_id):
+        if selected_id not in (x._identifier for x in self._options):
+            self._config._raise_invalid_input_error(selected_id)
     
-    def _validate_selected_id_in_options(self, selected_id: str) -> str:
-        if selected_id in (x.identifier for x in self.options):
-            return selected_id
-        else:
-            self._raise_invalid_input_error(selected_id)
-    
-    def _accum_all_dependent_params(self, param_set: ParameterSetBase) -> None:
-        super()._accum_all_dependent_params(param_set)
-        for child in self.children:
-            child._accum_all_dependent_params(param_set)
-
-    def to_json_dict(self):
+    @abstractmethod
+    def to_json_dict0(self):
         """
         Helper method to convert the derived selection parameter class into a JSON object
         """
-        output = super().to_json_dict()
-        output['options'] = [x.to_dict() for x in self.options]
-        output['trigger_refresh'] = self.trigger_refresh
+        output = super().to_json_dict0()
+        output['options'] = [x._to_json_dict() for x in self._options]
         return output
 
 
 @dataclass
 class SingleSelectParameter(_SelectionParameter):
     """
-    Class to define attributes for single-select parameter widgets.
-    """
-    selected_id: Optional[str]
+    Class for single-select parameter widgets.
 
-    def __init__(self, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, 
-                 is_hidden: bool = False, parent: Optional[_SelectionParameter] = None) -> None:
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        options: The parameter options that are currently selectable
+        selected_id: The ID of the selected option
+    """
+    _config: pc.SingleSelectParameterConfig
+    _selected_id: Optional[str]
+
+    def __post_init__(self):
+        super().__post_init__()
+        if len(self._options) > 0:
+            assert self._selected_id != None
+            self._validate_selected_id_in_options(self._selected_id)
+        else:
+            self._selected_id = None
+    
+    @staticmethod
+    def _ParameterConfigType():
+        return pc.SingleSelectParameterConfig
+    
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, is_hidden: bool = False, **kwargs
+    ) -> None:
         """
-        Constructor for SingleSelectParameter class
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
         Parameters:
             name: The name of the parameter
             label: The display label for the parameter
-            all_options: A sequence of SelectParameterOption which defines the attribute for each dropdown option
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False.
-            parent: The parent parameter that may cascade the options for this parameter. Default is no parent
-        """
-        super().__init__("SingleSelectParameter", name, label, all_options, is_hidden, parent)
-    
-    def with_selection(self, selection: str) -> SingleSelectParameter:
+            all_options: All options associated to this parameter regardless of the user group or parent parameter option they depend on
+            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
-        Applies the selected value to this widget parameter
+        cls.Create(name, label, all_options, is_hidden=is_hidden)
 
-        Parameters:
-            selection: The selected value as an ID of one of the dropdown options
-        
-        Returns:
-            A new copy of SingleSelectParameter with the selection applied
-        """
-        param_copy = copy.copy(self)
-        param_copy.selected_id = self._validate_selected_id_in_options(selection)
-        param_copy.children = [child.refresh(param_copy) for child in param_copy.children]
-        return param_copy
-    
-    def get_selected(self, field: Optional[str] = None, *, default_field: Optional[str] = None,
-                     default: Any = None) -> Union[po.SelectParameterOption, str]:
+    def get_selected(
+        self, field: Optional[str] = None, *, default_field: Optional[str] = None, default: Any = None, **kwargs
+    ) -> Union[po.SelectParameterOption, Any, None]:
         """
         Gets the selected single-select option or selected custom field
 
@@ -219,115 +173,133 @@ class SingleSelectParameter(_SelectionParameter):
         Returns:
             A SelectParameterOption class object if no field is provided, or the type of the custom field
         """
-        selected = next(x for x in self.options if x.identifier == self.selected_id)
-        if field is not None:
-            selected = selected.get_custom_field(field, default_field, default)
-        return selected
+        def get_selected_from_id(identifier: str):
+            selected = next(x for x in self._options if x._identifier == identifier)
+            if field is not None:
+                selected = selected.get_custom_field(field, default_field=default_field, default=default)
+            return selected
+        return u.process_if_not_none(self._selected_id, get_selected_from_id)
     
-    def get_selected_id(self) -> str:
+    def get_selected_id(self, **kwargs) -> Optional[str]:
         """
         Gets the ID of the selected option
 
         Returns:
-            A string ID
+            A string ID or None if there are no selectable options
         """
-        return self.get_selected().identifier
+        def get_id(x: po.SelectParameterOption): return x._identifier
+        return u.process_if_not_none(self.get_selected(), get_id)
     
-    def get_selected_id_quoted(self) -> str:
+    def get_selected_id_quoted(self, **kwargs) -> Optional[str]:
         """
         Gets the ID of the selected option surrounded by single quotes
 
         Returns:
-            A string
+            A string or None if there are no selectable options
         """
-        return self._enquote(self.get_selected_id())
+        return u.process_if_not_none(self.get_selected_id(), self._enquote)
     
-    def get_selected_label(self) -> str:
+    def get_selected_label(self, **kwargs) -> Optional[str]:
         """
         Gets the label of the selected option
 
         Returns:
-            A string
+            A string or None if there are no selectable options
         """
-        return self.get_selected().label
+        def get_label(x: po.SelectParameterOption): return x._label
+        return u.process_if_not_none(self.get_selected(), get_label)
     
-    def get_selected_label_quoted(self) -> str:
+    def get_selected_label_quoted(self, **kwargs) -> Optional[str]:
         """
         Gets the label of the selected option surrounded by single quotes
 
         Returns:
-            A string
+            A string or None if there are no selectable options
         """
-        return self._enquote(self.get_selected_label())
-    
-    # Overriding for refresh method
+        return u.process_if_not_none(self.get_selected_label(), self._enquote)
+
     def _get_selected_ids_as_list(self) -> Sequence[str]:
-        return (self.get_selected_id(),)
-    
-    def _get_default(self) -> str:
-        default_id = next(self._get_default_iterator(), None)
-        if default_id is None:
-            default_id = self.options[0].identifier if len(self.options) > 0 else None
-        return default_id
+        selected_id = self.get_selected_id()
+        if selected_id is not None:
+            return (self.get_selected_id(),)
+        else:
+            return tuple()
     
-    def _set_default_as_selection_mutate(self) -> None:
-        self.selected_id = self._get_default()
-
-    def to_json_dict(self) -> Dict:
+    def to_json_dict0(self) -> dict:
         """
         Converts this parameter as a JSON object for the parameters API response
 
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['selected_id'] = self.selected_id
+        output = super().to_json_dict0()
+        output['selected_id'] = self._selected_id
         return output
 
 
 @dataclass
 class MultiSelectParameter(_SelectionParameter):
     """
-    Class to define attributes for multi-select parameter widgets.
+    Class for multi-select parameter widgets.
+
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        options: The parameter options that are currently selectable
+        selected_ids: A sequence of IDs of the selected options
     """
-    selected_ids: Sequence[str]
-    include_all: bool
-    order_matters: bool
+    _config: pc.MultiSelectParameterConfig
+    _selected_ids: Sequence[str]
 
-    def __init__(self, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, is_hidden = False,
-                 parent: Optional[_SelectionParameter] = None, include_all: bool = True, order_matters: bool = False) -> None:
+    def __post_init__(self):
+        super().__post_init__()
+        self._selected_ids = tuple(self._selected_ids)
+        for selected_id in self._selected_ids:
+            self._validate_selected_id_in_options(selected_id)
+    
+    @staticmethod
+    def _ParameterConfigType():
+        return pc.MultiSelectParameterConfig
+    
+    @classmethod
+    def Create(
+        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, include_all: bool = True, 
+        order_matters: bool = False, is_hidden: bool = False, user_attribute: Optional[str] = None, parent_name: Optional[str] = None, 
+        **kwargs
+    ) -> None:
         """
-        Constructor for MultiSelectParameter class
+        Method for creating the configurations for a Parameter that may include user attribute or parent
 
         Parameters:
             name: The name of the parameter
             label: The display label for the parameter
-            all_options: A sequence of SelectParameterOption which defines the attribute for each dropdown option
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False.
-            parent: The parent parameter that may cascade the options for this parameter. Default is no parent
-            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 
+            all_options: All options associated to this parameter regardless of the user group or parent parameter option they depend on
+            include_all: Whether having no options selected is equivalent to all selectable options selected
+            order_matters: Whether the order of the selections made matter
+            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
+            user_attribute: The user attribute that may cascade the options for this parameter. Default is None
+            parent_name: Name of parent parameter that may cascade the options for this parameter. Default is None (no parent)
         """
-        super().__init__("MultiSelectParameter", name, label, all_options, is_hidden, parent)
-        self.include_all = include_all
-        self.order_matters = order_matters
+        super(cls, cls).Create(name, label, all_options, include_all=include_all, order_matters=order_matters, is_hidden=is_hidden, 
+                               user_attribute=user_attribute, parent_name=parent_name)
 
-    def with_selection(self, selection: str) -> MultiSelectParameter:
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, include_all: bool = True, 
+        order_matters: bool = False, is_hidden: bool = False, **kwargs
+    ) -> None:
         """
-        Applies the selected value(s) to this widget parameter
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
         Parameters:
-            selection: A JSON string of list of strings representing IDs of selected values
-        
-        Returns:
-            A new copy of MultiSelectParameter with the selection applied
+            name: The name of the parameter
+            label: The display label for the parameter
+            all_options: All options associated to this parameter regardless of the user group or parent parameter option they depend on
+            include_all: Whether having no options selected is equivalent to all selectable options selected
+            order_matters: Whether the order of the selections made matter
+            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
-        param_copy = copy.copy(self)
-        selection_split = u.load_json_or_comma_delimited_str_as_list(selection)
-        param_copy.selected_ids = tuple(self._validate_selected_id_in_options(x) for x in selection_split)
-        param_copy.children = [child.refresh(param_copy) for child in self.children]
-        return param_copy
-    
+        cls.Create(name, label, all_options, include_all=include_all, order_matters=order_matters, is_hidden=is_hidden)
+
     def has_non_empty_selection(self) -> bool:
         """
         Returns True if more than zero options were selected. False otherwise.
@@ -338,10 +310,11 @@ class MultiSelectParameter(_SelectionParameter):
         Returns:
             A boolean
         """
-        return len(self.selected_ids) > 0
+        return len(self._selected_ids) > 0
 
-    def get_selected_list(self, field: Optional[str] = None, *, default_field: Optional[str] = None,
-                          default: Any = None) -> Sequence[Union[po.SelectParameterOption, Any]]:
+    def get_selected_list(
+        self, field: Optional[str] = None, *, default_field: Optional[str] = None, default: Any = None, **kwargs
+    ) -> Sequence[Union[po.SelectParameterOption, Any]]:
         """
         Gets the sequence of the selected option(s) or a sequence of selected custom fields
 
@@ -356,35 +329,35 @@ class MultiSelectParameter(_SelectionParameter):
         Returns:
             A sequence of SelectParameterOption class objects or sequence of type of custom field
         """
-        if not self.has_non_empty_selection() and self.include_all:
-            selected_list = self.options
+        if not self.has_non_empty_selection() and self._config.include_all:
+            selected_list = self._options
         else:
-            selected_list = (x for x in self.options if x.identifier in self.selected_ids)
+            selected_list = (x for x in self._options if x._identifier in self._selected_ids)
         
         if field is not None:
-            selected_list = [selected.get_custom_field(field, default_field, default) for selected in selected_list]
+            selected_list = [selected.get_custom_field(field, default_field=default_field, default=default) for selected in selected_list]
         
         return tuple(selected_list)
 
-    def get_selected_ids_as_list(self) -> Sequence[str]:
+    def get_selected_ids_as_list(self, **kwargs) -> Sequence[str]:
         """
         Gets the sequence of ID(s) of the selected option(s)
 
         Returns:
             A sequence of strings
         """
-        return tuple(x.identifier for x in self.get_selected_list())
+        return tuple(x._identifier for x in self.get_selected_list())
     
-    def get_selected_ids_joined(self) -> str:
+    def get_selected_ids_joined(self, **kwargs) -> str:
         """
         Gets the ID(s) of the selected option(s) joined by comma
 
         Returns:
             A string
         """
-        return ', '.join(self.get_selected_ids_as_list())
+        return ','.join(self.get_selected_ids_as_list())
     
-    def get_selected_ids_quoted_as_list(self) -> Sequence[str]:
+    def get_selected_ids_quoted_as_list(self, **kwargs) -> Sequence[str]:
         """
         Gets the sequence of ID(s) of the selected option(s) surrounded by single quotes
 
@@ -393,34 +366,34 @@ class MultiSelectParameter(_SelectionParameter):
         """
         return tuple(self._enquote(x) for x in self.get_selected_ids_as_list())
     
-    def get_selected_ids_quoted_joined(self) -> str:
+    def get_selected_ids_quoted_joined(self, **kwargs) -> str:
         """
         Gets the ID(s) of the selected option(s) surrounded by single quotes and joined by comma
 
         Returns:
             A string
         """
-        return ', '.join(self.get_selected_ids_quoted_as_list())
+        return ','.join(self.get_selected_ids_quoted_as_list())
     
-    def get_selected_labels_as_list(self) -> Sequence[str]:
+    def get_selected_labels_as_list(self, **kwargs) -> Sequence[str]:
         """
         Gets the sequence of label(s) of the selected option(s)
 
         Returns:
             A sequence of strings
         """
-        return tuple(x.label for x in self.get_selected_list())
+        return tuple(x._label for x in self.get_selected_list())
     
-    def get_selected_labels_joined(self) -> str:
+    def get_selected_labels_joined(self, **kwargs) -> str:
         """
         Gets the label(s) of the selected option(s) joined by comma
 
         Returns:
             A string
         """
-        return ', '.join(self.get_selected_labels_as_list())
+        return ','.join(self.get_selected_labels_as_list())
     
-    def get_selected_labels_quoted_as_list(self) -> Sequence[str]:
+    def get_selected_labels_quoted_as_list(self, **kwargs) -> Sequence[str]:
         """
         Gets the sequence of label(s) of the selected option(s) surrounded by single quotes
 
@@ -429,97 +402,68 @@ class MultiSelectParameter(_SelectionParameter):
         """
         return tuple(self._enquote(x) for x in self.get_selected_labels_as_list())
     
-    def get_selected_labels_quoted_joined(self) -> str:
+    def get_selected_labels_quoted_joined(self, **kwargs) -> str:
         """
         Gets the label(s) of the selected option(s) surrounded by single quotes and joined by comma
 
         Returns:
             A string
         """
-        return ', '.join(self.get_selected_labels_quoted_as_list())
-    
-    def _get_selected_ids_as_list(self) -> Sequence[str]:
+        return ','.join(self.get_selected_labels_quoted_as_list())
+
+    def _get_selected_ids_as_list(self, **kwargs) -> Sequence[str]:
         return self.get_selected_ids_as_list()
     
-    def _get_default(self) -> Sequence[str]:
-        return tuple(self._get_default_iterator())
-    
-    def _set_default_as_selection_mutate(self):
-        self.selected_ids = self._get_default()
-
-    def to_json_dict(self):
+    def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
 
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['selected_ids'] = list(self.selected_ids)
-        output['include_all'] = self.include_all
-        output['order_matters'] = self.order_matters
+        output = super().to_json_dict0()
+        output['selected_ids'] = list(self._selected_ids)
         return output
 
 
 @dataclass
 class DateParameter(Parameter):
     """
-    Class to define attributes for date parameter widgets.
-    """
-    curr_option: po.DateParameterOption
-    selected_date: datetime
+    Class for date parameter widgets.
 
-    def __init__(self, name: str, label: str, default_date: Union[str, datetime], date_format: str = '%Y-%m-%d', 
-                 *, is_hidden: bool = False) -> None:
-        """
-        Constructor for DateParameter class
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        curr_option: The current option showing for defaults based on user attribute and selection of parent
+        selected_date: The selected date
+    """
+    _curr_option: po.DateParameterOption
+    _selected_date: Union[date, str]
 
-        Parameters:
-            name: The name of the parameter
-            label: The display label for the parameter
-            default_date: The default selected date
-            date_format: The format of the default_date. Default is '%Y-%m-%d'
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
-        """
-        self.curr_option = po.DateParameterOption(default_date, date_format)
-        all_options = (self.curr_option,)
-        super().__init__("DateParameter", name, label, all_options, is_hidden, None)
-        self._set_default_as_selection_mutate()
+    def __post_init__(self):
+        self._selected_date: date = self._validate_date(self._selected_date)
     
     @staticmethod
-    def WithParent(name: str, label: str, all_options: Sequence[po.DateParameterOption], parent: SingleSelectParameter, *, 
-                   is_hidden: bool = False) -> DateParameter:
+    def _ParameterConfigType():
+        return pc.DateParameterConfig
+
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, default_date: Union[str, date], *, date_format: str = '%Y-%m-%d', is_hidden: bool = False, **kwargs
+    ) -> None:
         """
-        A factory method to construct a DateParameter with a parent parameter
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
         Parameters:
             name: The name of the parameter
             label: The display label for the parameter
-            all_options: A sequence of DateParameterOption which contains various default dates linked to specific parent options
-            parent: The parent parameter, which must be a SingleSelectParameter
+            default_date: Default date for this option
+            date_format: Format of the default date, default is '%Y-%m-%d'
             is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
-        new_param = DateParameter(name, label, '2020-01-01', is_hidden=is_hidden) # dummy date in valid format
-        return Parameter.WithParent(all_options, parent, new_param)
+        single_param_option = po.DateParameterOption(default_date, date_format=date_format)
+        cls.Create(name, label, (single_param_option,), is_hidden=is_hidden)
     
-    def with_selection(self, selection: str):
-        """
-        Applies the selected date to this widget parameter
-
-        Parameters:
-            selection: The date string which must be in yyyy-mm-dd format (regardless of self.date_format value)
-        
-        Returns:
-            A new copy of DateParameter with the selection applied
-        """
-        param_copy = copy.copy(self)
-        try:
-            param_copy.selected_date = datetime.strptime(selection, "%Y-%m-%d")
-        except ValueError as e:
-            self._raise_invalid_input_error(selection, 'Invalid selection for date.', e)
-        return param_copy
-
-    def get_selected_date(self, date_format: str = None) -> str:
+    def get_selected_date(self, *, date_format: str = None, **kwargs) -> str:
         """
         Gets selected date as string
 
@@ -529,10 +473,10 @@ class DateParameter(Parameter):
         Returns:
             A string
         """
-        date_format = self.curr_option.date_format if date_format is None else date_format
-        return self.selected_date.strftime(date_format)
+        date_format = self._curr_option._date_format if date_format is None else date_format
+        return self._selected_date.strftime(date_format)
 
-    def get_selected_date_quoted(self, date_format: str = None) -> str:
+    def get_selected_date_quoted(self, *, date_format: str = None, **kwargs) -> str:
         """
         Gets selected date as string surrounded by single quotes
 
@@ -542,12 +486,9 @@ class DateParameter(Parameter):
         Returns:
             A string
         """
-        return self._enquote(self.get_selected_date(date_format))
-    
-    def _set_default_as_selection_mutate(self) -> None:
-        self.selected_date = self.curr_option.default_date
+        return self._enquote(self.get_selected_date(date_format=date_format))
     
-    def to_json_dict(self):
+    def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
 
@@ -556,271 +497,259 @@ class DateParameter(Parameter):
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['selected_date'] = self.get_selected_date("%Y-%m-%d")
-        return output
-
-
-@dataclass
-class _NumericParameter(Parameter):
-    curr_option: po.NumericParameterOption
-    
-    def to_json_dict(self):
-        """
-        Helper method to converts numeric parameters into JSON objects for the parameters API response
-
-        Returns:
-            A dictionary for the JSON object
-        """
-        output = super().to_json_dict()
-        output['min_value'] = str(self.curr_option.min_value)
-        output['max_value'] = str(self.curr_option.max_value)
-        output['increment'] = str(self.curr_option.increment)
+        output = super().to_json_dict0()
+        output.update(self._curr_option._to_json_dict())
+        output['selected_date'] = self.get_selected_date(date_format="%Y-%m-%d")
         return output
 
 
 @dataclass
-class NumberParameter(_NumericParameter):
+class DateRangeParameter(Parameter):
     """
-    Class to define attributes for number slider parameter widgets.
+    Class for date range parameter widgets.
+
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        curr_option: The current option showing for defaults based on user attribute and selection of parent
+        selected_start_date: The selected start date
+        selected_end_date: The selected end date
     """
-    selected_value: Decimal
+    _curr_option: po.DateRangeParameterOption
+    _selected_start_date: Union[date, str]
+    _selected_end_date: Union[date, str]
+
+    def __post_init__(self):
+        self._selected_start_date: date = self._validate_date(self._selected_start_date)
+        self._selected_end_date: date = self._validate_date(self._selected_end_date)
+    
+    @staticmethod
+    def _ParameterConfigType():
+        return pc.DateRangeParameterConfig
 
-    def __init__(self, name: str, label: str, min_value: po.Number, max_value: po.Number, increment: po.Number = 1, 
-                 default_value: po.Number = None, *, is_hidden: bool = False) -> None:
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, default_start_date: Union[str, date], default_end_date: Union[str, date], 
+        *, date_format: str = '%Y-%m-%d', is_hidden: bool = False, **kwargs
+    ) -> None:
         """
-        Constructor for NumberParameter class
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
         Parameters:
             name: The name of the parameter
             label: The display label for the parameter
-            min_value: The minimum bound for selection. Can be of type Decimal, integer, or number parsable string
-            max_value: The maxixmum bound for selection. Can be of type Decimal, integer, or number parsable string
-            increment: The increment for allowable selections. Can be of type Decimal, integer, or number parsable string. Default is 1
-            default_value: The default selection. Can be of type Decimal, integer, or number parsable string. Default is min_value
+            default_start_date: Default start date for this option
+            default_end_date: Default end date for this option
+            date_format: Format of the default date, default is '%Y-%m-%d'
             is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
-        default_value = default_value if default_value is not None else min_value
-        curr_option = po.NumberParameterOption(min_value, max_value, increment, default_value)
-        all_options = (curr_option,)
-        super().__init__("NumberParameter", name, label, all_options, is_hidden, None, curr_option)
-        self._set_default_as_selection_mutate()
+        single_param_option = po.DateRangeParameterOption(default_start_date, default_end_date, date_format=date_format)
+        cls.Create(name, label, (single_param_option,), is_hidden=is_hidden)
     
-    @staticmethod
-    def WithParent(name: str, label: str, all_options: Sequence[po.NumberParameterOption], parent: SingleSelectParameter, *, 
-                   is_hidden: bool = False) -> DateParameter:
+    def get_selected_start_date(self, *, date_format: str = None, **kwargs) -> str:
         """
-        A factory method to construct a NumberParameter with a parent parameter
+        Gets selected start date as string
 
         Parameters:
-            name: The name of the parameter
-            label: The display label for the parameter
-            all_options: A sequence of NumberParameterOption which contains various bounds and default values linked to specific parent options
-            parent: The parent parameter, which must be a SingleSelectParameter
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
+            date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
+
+        Returns:
+            A string
+        """
+        date_format = self._curr_option._date_format if date_format is None else date_format
+        return self._selected_start_date.strftime(date_format)
+
+    def get_selected_start_date_quoted(self, *, date_format: str = None, **kwargs) -> str:
+        """
+        Gets selected start date as string surrounded by single quotes
+
+        Parameters:
+            date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
+
+        Returns:
+            A string
         """
-        new_param = NumberParameter(name, label, 0, 1, is_hidden=is_hidden) # dummy values
-        return Parameter.WithParent(all_options, parent, new_param)
+        return self._enquote(self.get_selected_start_date(date_format=date_format))
     
-    def with_selection(self, selection: str):
+    def get_selected_end_date(self, *, date_format: str = None, **kwargs) -> str:
         """
-        Applies the selected number to this widget parameter
+        Gets selected end date as string
 
         Parameters:
-            selection: The selected number (must be a string parsable as a number)
-        
+            date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
+
         Returns:
-            A new copy of NumberParameter with the selection applied
+            A string
         """
-        param_copy = copy.copy(self)
-        try:
-            param_copy.selected_value = param_copy.curr_option._validate_value(selection)
-        except u.ConfigurationError as e:
-            self._raise_invalid_input_error(selection, 'Invalid selection for number parameter.', e)
-        return param_copy
+        date_format = self._curr_option._date_format if date_format is None else date_format
+        return self._selected_end_date.strftime(date_format)
 
-    def get_selected_value(self) -> str:
+    def get_selected_end_date_quoted(self, *, date_format: str = None, **kwargs) -> str:
         """
-        Get the selected number
+        Gets selected end date as string surrounded by single quotes
+
+        Parameters:
+            date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
-            A number parsable string of the selected number
+            A string
         """
-        return str(self.selected_value)
+        return self._enquote(self.get_selected_end_date(date_format=date_format))
     
-    def _set_default_as_selection_mutate(self) -> None:
-        self.curr_option: po.NumberParameterOption
-        self.selected_value = self.curr_option.default_value
-        
-    def to_json_dict(self):
+    def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
 
+        The "selected_date" field will always be in yyyy-mm-dd format
+
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['selected_value'] = self.get_selected_value()
+        output = super().to_json_dict0()
+        output.update(self._curr_option._to_json_dict())
+        output['selected_start_date'] = self.get_selected_start_date(date_format="%Y-%m-%d")
+        output['selected_end_date'] = self.get_selected_end_date(date_format="%Y-%m-%d")
         return output
 
 
 @dataclass
-class NumRangeParameter(_NumericParameter):
+class NumberParameter(Parameter):
     """
-    Class to define attributes for number range slider (double-ended) parameter widgets.
-    """
-    selected_lower_value: Decimal
-    selected_upper_value: Decimal
+    Class for number parameter widgets.
 
-    def __init__(self, name: str, label: str, min_value: po.Number, max_value: po.Number, increment: po.Number = 1, 
-                 default_lower_value: po.Number = None, default_upper_value: po.Number = None, *, is_hidden: bool = False) -> None:
-        """
-        Constructor for NumberParameter class
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        curr_option: The current option showing for defaults based on user attribute and selection of parent
+        selected_value: The selected integer or decimal number
+    """
+    _curr_option: po.NumberParameterOption
+    _selected_value: po.Number
 
-        Parameters:
-            name: The name of the parameter
-            label: The display label for the parameter
-            min_value: The minimum bound for selection. Can be of type Decimal, integer, or number parsable string
-            max_value: The maxixmum bound for selection. Can be of type Decimal, integer, or number parsable string
-            increment: The increment for allowable selections. Can be of type Decimal, integer, or number parsable string. Default is 1
-            default_lower_value: The default lower selection. Can be of type Decimal, integer, or number parsable string. Default is min_value
-            default_upper_value: The default upper selection. Can be of type Decimal, integer, or number parsable string. Default is max_value
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
-        """
-        default_lower_value = default_lower_value if default_lower_value is not None else min_value
-        default_upper_value = default_upper_value if default_upper_value is not None else max_value
-        curr_option = po.NumRangeParameterOption(min_value, max_value, increment, default_lower_value, default_upper_value)
-        all_options = (curr_option,)
-        super().__init__("NumRangeParameter", name, label, all_options, is_hidden, None, curr_option)
-        self._set_default_as_selection_mutate()
+    def __post_init__(self):
+        self._selected_value: Decimal = self._validate_number(self._selected_value, self._curr_option)
     
     @staticmethod
-    def WithParent(name: str, label: str, all_options: Sequence[po.NumRangeParameterOption], parent: SingleSelectParameter, *, 
-                   is_hidden: bool = False) -> DateParameter:
-        """
-        A factory method to construct a NumRangeParameter with a parent parameter
+    def _ParameterConfigType():
+        return pc.NumberParameterConfig
 
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, min_value: po.Number, max_value: po.Number, *, increment: po.Number = 1, 
+        default_value: Optional[po.Number] = None, is_hidden: bool = False, **kwargs
+    ) -> None:
+        """
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
+        
+        * Note that the "Number" type denotes an int, a Decimal (from decimal module), or a string that can be parsed to Decimal
+        
         Parameters:
             name: The name of the parameter
             label: The display label for the parameter
-            all_options: A sequence of NumRangeParameterOption which contains various bounds and default values linked to specific parent options
-            parent: The parent parameter, which must be a SingleSelectParameter
+            min_value: Minimum selectable value
+            max_value: Maximum selectable value
+            increment: Increment of selectable values, and must fit evenly between min_value and max_value
+            default_value: Default value for this option, and must be selectable based on min_value, max_value, and increment
             is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
-        new_param = NumRangeParameter(name, label, 0, 1, is_hidden=is_hidden) # dummy values
-        return Parameter.WithParent(all_options, parent, new_param)
+        single_param_option = po.NumberParameterOption(min_value, max_value, increment=increment, default_value=default_value)
+        cls.Create(name, label, (single_param_option,), is_hidden=is_hidden)
     
-    def with_selection(self, selection: str):
+    def get_selected_value(self, **kwargs) -> str:
         """
-        Applies the selected numbers to this widget parameter
-
-        Parameters:
-            selection: The lower and upper selected numbers joined by comma (with no spaces)
-        
-        Returns:
-            A new copy of NumRangeParameter with the selection applied
-        """
-        try:
-            lower, upper = selection.split(',')
-        except ValueError as e:
-            self._raise_invalid_input_error(selection, "Range parameter selection must be two numbers joined by comma.", e)
-
-        param_copy = copy.copy(self)
-        try:
-            param_copy.selected_lower_value = param_copy.curr_option._validate_value(lower)
-            param_copy.selected_upper_value = param_copy.curr_option._validate_value(upper, param_copy.selected_lower_value)
-        except u.ConfigurationError as e:
-            self._raise_invalid_input_error(selection, 'Invalid selection for range parameter.', e)
-        return param_copy
-
-    def get_selected_lower_value(self) -> str:
-        """
-        Get the selected lower number
-
-        Returns:
-            A number parsable string of the selected number
-        """
-        return str(self.selected_lower_value)
-
-    def get_selected_upper_value(self) -> str:
-        """
-        Get the selected upper number
+        Get the selected number
 
         Returns:
             A number parsable string of the selected number
         """
-        return str(self.selected_upper_value)
-    
-    def _set_default_as_selection_mutate(self) -> None:
-        self.curr_option: po.NumRangeParameterOption
-        self.selected_lower_value = self.curr_option.default_lower_value
-        self.selected_upper_value = self.curr_option.default_upper_value
-
-    def to_json_dict(self):
+        return str(self._selected_value)
+        
+    def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
 
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['selected_lower_value'] = self.get_selected_lower_value()
-        output['selected_upper_value'] = self.get_selected_upper_value()
+        output = super().to_json_dict0()
+        output.update(self._curr_option._to_json_dict())
+        output['selected_value'] = self.get_selected_value()
         return output
 
 
 @dataclass
-class DataSourceParameter(Parameter):
+class NumberRangeParameter(Parameter):
     """
-    Class for parameters that can use a lookup table to convert itself into another parameter
+    Class for number range parameter widgets.
+
+    Attributes:
+        config: The config for this widget parameter (for immutable attributes like name, label, all possible options, etc)
+        curr_option: The current option showing for defaults based on user attribute and selection of parent
+        selected_lower_value: The selected lower integer or decimal number
+        selected_upper_value: The selected upper integer or decimal number
     """
-    parameter_class: Type[Parameter]
-    data_source: DataSource
-    parent: Optional[Parameter] 
+    _curr_option: po.NumberRangeParameterOption
+    _selected_lower_value: po.Number
+    _selected_upper_value: po.Number
 
-    def __init__(self, parameter_class: Type[Parameter], name: str, label: str, data_source: DataSource, *, 
-                 is_hidden: bool = False, parent: Optional[Parameter] = None) -> None:
+    def __post_init__(self):
+        self._selected_lower_value: Decimal = self._validate_number(self._selected_lower_value, self._curr_option)
+        self._selected_upper_value: Decimal = self._validate_number(self._selected_upper_value, self._curr_option)
+    
+    @staticmethod
+    def _ParameterConfigType():
+        return pc.NumberRangeParameterConfig
+
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, min_value: po.Number, max_value: po.Number, *, increment: po.Number = 1, 
+        default_lower_value: Optional[po.Number] = None, default_upper_value: Optional[po.Number] = None, is_hidden: bool = False, **kwargs
+    ) -> None:
         """
-        Constructor for DataSourceParameter, a Parameter that uses a DataSource to convert itself to another Parameter
+        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
+        
+        * Note that the "Number" type denotes an int, a Decimal (from decimal module), or a string that can be parsed to Decimal
 
         Parameters:
-            parameter_class: The class of widget parameter to convert to
             name: The name of the parameter
             label: The display label for the parameter
-            data_source: The lookup table to use for this parameter
+            min_value: Minimum selectable value
+            max_value: Maximum selectable value
+            increment: Increment of selectable values, and must fit evenly between min_value and max_value
+            default_lower_value: Default lower value for this option, and must be selectable based on min_value, max_value, and increment
+            default_upper_value: Default upper value for this option, and must be selectable based on min_value, max_value, and increment. 
+                    Must also be greater than default_lower_value
             is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
-            parent: The parent parameter that may cascade the options for this parameter. Default is no parent
         """
-        super().__init__("DataSourceParameter", name, label, None, is_hidden, None)
-        self.parameter_class = parameter_class
-        self.data_source = data_source
-        self.parent = parent
+        single_param_option = po.NumberRangeParameterOption(min_value, max_value, increment=increment, default_lower_value=default_lower_value, 
+                                                         default_upper_value=default_upper_value)
+        cls.Create(name, label, (single_param_option,), is_hidden=is_hidden)
+    
+    def get_selected_lower_value(self, **kwargs) -> str:
+        """
+        Get the selected lower value number
 
-    def convert(self, df: pd.DataFrame) -> Parameter:
+        Returns:
+            A number parsable string of the selected number
         """
-        Method to convert this DataSourceParameter into another parameter
+        return str(self._selected_lower_value)
 
-        Parameters:
-            df: The dataframe containing the parameter options data
+    def get_selected_upper_value(self, **kwargs) -> str:
+        """
+        Get the selected upper value number
 
         Returns:
-            The converted parameter
+            A number parsable string of the selected number
         """
-        return self.data_source.convert(self, df)
-    
-    def to_json_dict(self) -> Dict:
+        return str(self._selected_upper_value)
+
+    def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
 
         Returns:
             A dictionary for the JSON object
         """
-        output = super().to_json_dict()
-        output['widget_type'] = self.parameter_class.__name__
-        output['data_source'] = self.data_source.__dict__
+        output = super().to_json_dict0()
+        output.update(self._curr_option._to_json_dict())
+        output['selected_lower_value'] = self.get_selected_lower_value()
+        output['selected_upper_value'] = self.get_selected_upper_value()
         return output
-
-
-# Types:
-SelectionParameter = Union[SingleSelectParameter, MultiSelectParameter]
-NumericParameter = Union[NumberParameter, NumRangeParameter]