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

squirrels/parameters.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
-from typing import Callable, Type, Sequence, Optional, Union, Any
+from typing import Callable, Type, TypeVar, Sequence, Any
 from dataclasses import dataclass
 from datetime import datetime, date
 from decimal import Decimal
 from abc import ABCMeta, abstractmethod
 
-from . import _parameter_configs as pc, _parameter_sets as ps, parameter_options as po, data_sources as d
-from . import _api_response_models as arm, _utils as u
+from . import _parameter_configs as _pc, _parameter_sets as ps, parameter_options as _po, data_sources as d
+from . import _api_response_models as arm, _utils as _u
+
+IntOrFloat = TypeVar("IntOrFloat", int, float)
 
 
 @dataclass
@@ -14,7 +16,7 @@ class Parameter(metaclass=ABCMeta):
     """
     Abstract class for all parameter widgets
     """
-    _config: pc.ParameterConfig
+    _config: _pc.ParameterConfig
 
     @abstractmethod
     def is_enabled(self) -> bool:
@@ -22,18 +24,39 @@ class Parameter(metaclass=ABCMeta):
 
     @staticmethod
     @abstractmethod
-    def _ParameterConfigType() -> Type:
+    def _ParameterConfigType() -> Type[_pc.ParameterConfig]:
         pass
     
+    @classmethod
+    def _CreateWithOptionsHelper(
+        cls, name: str, label: str, all_options: Sequence[_po.ParameterOption | dict], *, description: str = "",
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
+    ) -> None:
+        param_config_type = cls._ParameterConfigType()
+        param_config = param_config_type(
+            name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name, **kwargs
+        )
+        ps.ParameterConfigsSetIO.obj.add(param_config)
+    
+    @classmethod
+    def Create(
+        cls, name: str, label: str, all_options: Sequence[_po.ParameterOption | dict], *, description: str = "",
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
+    ) -> None:
+        """
+        DEPRECATED. Use CreateWithOptions instead
+        """
+        cls._CreateWithOptionsHelper(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+    
     @classmethod
     def CreateWithOptions(
-        cls, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, description: str = "",
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        cls, name: str, label: str, all_options: Sequence[_po.ParameterOption | dict], *, description: str = "",
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a Parameter that may include user attribute or parent
 
-        Parameters:
+        Arguments:
             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
@@ -41,35 +64,33 @@ class Parameter(metaclass=ABCMeta):
             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_config_type = cls._ParameterConfigType()
-        param_config = param_config_type(name, label, all_options, description=description, user_attribute=user_attribute, 
-                                         parent_name=parent_name)
-        ps.ParameterConfigsSetIO.obj.add(param_config)
-    
-    @classmethod
-    def Create(
-        cls, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, description: str = "",
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
-    ) -> None:
-        """
-        DEPRECATED. Use CreateWithOptions instead
-        """
-        cls.CreateWithOptions(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
+        cls._CreateWithOptionsHelper(name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name)
 
     @classmethod
     @abstractmethod
     def CreateSimple(cls, name: str, label: str, *args, description: str = "", **kwargs) -> None:
         pass
+
+    @classmethod
+    def _CreateFromSourceHelper(
+        cls, name: str, label: str, data_source: d.DataSource | dict, *, extra_args: dict = {}, description: str = "", 
+        user_attribute: str | None = None, parent_name: str | None = None
+    ) -> None:
+        param_config = _pc.DataSourceParameterConfig(
+            cls._ParameterConfigType(), name, label, data_source, description=description, user_attribute=user_attribute, 
+            parent_name=parent_name, extra_args=extra_args
+        )
+        ps.ParameterConfigsSetIO.obj.add(param_config)
     
     @classmethod
     def CreateFromSource(
-        cls, name: str, label: str, data_source: Union[d.DataSource , dict], *, description: str = "", 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        cls, name: str, label: str, data_source: d.DataSource | dict, *, description: str = "", 
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for any Parameter that uses a DataSource to receive the options
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             data_source: The lookup table to use for this parameter
@@ -77,25 +98,28 @@ class Parameter(metaclass=ABCMeta):
             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_config_type = cls._ParameterConfigType()
-        param_config = pc.DataSourceParameterConfig(param_config_type, name, label, data_source, description=description, 
-                                                    user_attribute=user_attribute, parent_name=parent_name)
-        ps.ParameterConfigsSetIO.obj.add(param_config)
+        cls._CreateFromSourceHelper(name, label, data_source, description=description, user_attribute=user_attribute, parent_name=parent_name)
         
     def _enquote(self, value: str) -> str:
         return "'" + value.replace("'", "''") + "'" 
     
-    def _validate_date(self, input_date: str) -> date:
+    def _validate_input_date(self, input_date: date | str, curr_option: _po._DateTypeParameterOption) -> date:
+        if isinstance(input_date, str):
+            try:
+                input_date = datetime.strptime(input_date.strip(), "%Y-%m-%d").date()
+            except ValueError:
+                raise self._config._invalid_input_error(str(input_date), "Must be a date in YYYY-MM-DD format.")
+        
         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, "Must be a date in YYYY-MM-DD format.", e)
+            return curr_option._validate_date(input_date)
+        except _u.ConfigurationError as e:
+            raise self._config._invalid_input_error(str(input_date), str(e))
     
-    def _validate_number(self, input_number: po.Number, curr_option: po._NumericParameterOption) -> Decimal:
+    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, str(e), e)
+        except _u.ConfigurationError as e:
+            raise self._config._invalid_input_error(str(input_number), str(e))
     
     @abstractmethod
     def _to_json_dict0(self) -> dict:
@@ -120,8 +144,8 @@ class Parameter(metaclass=ABCMeta):
 
 @dataclass
 class _SelectionParameter(Parameter):
-    _config: pc.SelectionParameterConfig
-    _options: Sequence[po.SelectParameterOption]
+    _config: _pc.SelectionParameterConfig
+    _options: Sequence[_po.SelectParameterOption]
 
     def __post_init__(self):
         self._options = tuple(self._options)
@@ -135,7 +159,7 @@ class _SelectionParameter(Parameter):
 
     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, f"The selected id {selected_id} does not exist in available options.")
+            raise self._config._invalid_input_error(selected_id, f"The selected id {selected_id} does not exist in available options.")
     
     @abstractmethod
     def _to_json_dict0(self) -> dict:
@@ -158,8 +182,8 @@ class SingleSelectParameter(_SelectionParameter):
         options: The parameter options that are currently selectable
         selected_id: The ID of the selected option
     """
-    _config: pc.SingleSelectParameterConfig
-    _selected_id: Optional[str]
+    _config: _pc.SingleSelectParameterConfig
+    _selected_id: str | None
 
     def __post_init__(self):
         super().__post_init__()
@@ -171,16 +195,16 @@ class SingleSelectParameter(_SelectionParameter):
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.SingleSelectParameterConfig
+        return _pc.SingleSelectParameterConfig
     
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, description: str = "", **kwargs
+        cls, name: str, label: str, all_options: Sequence[_po.SelectParameterOption], *, description: str = "", **kwargs
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
-        Parameters:
+        Arguments:
             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
@@ -189,12 +213,12 @@ class SingleSelectParameter(_SelectionParameter):
         cls.CreateWithOptions(name, label, all_options, description=description)
 
     def get_selected(
-        self, field: Optional[str] = None, *, default_field: Optional[str] = None, default: Any = None, **kwargs
-    ) -> Union[po.SelectParameterOption, Any, None]:
+        self, field: str | None = None, *, default_field: str | None = None, default: Any = None, **kwargs
+    ) -> _po.SelectParameterOption | Any | None:
         """
         Gets the selected single-select option or selected custom field
 
-        Parameters:
+        Arguments:
             field: If field is not None, the method gets this field from the "custom_fields" attribute of the selected option. 
                 Otherwise, returns the class object of the selected option
             default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used 
@@ -210,50 +234,76 @@ class SingleSelectParameter(_SelectionParameter):
             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)
+        return _u.process_if_not_none(self._selected_id, get_selected_from_id)
+    
+    def get_selected_quoted(self, field: str, *, default_field: str | None = None, default: str | None = None, **kwargs) -> str | None:
+        """
+        Gets the selected single-select option surrounded by single quotes
+
+        Arguments:
+            field: The "custom_fields" attribute of the selected option.
+            default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used
+                as the "field" instead.
+            default: If field does not exist for a parameter option, default_field is None, but default is not None, then the default
+                is returned as the selected field. Does nothing if default_field is not None
+
+        Returns:
+            A string surrounded by single quotes
+        """
+        selected_value = self.get_selected(field, default_field=default_field, default=default)
+        
+        def _enquote(x: Any) -> str:
+            if not isinstance(selected_value, str):
+                raise _u.ConfigurationError(
+                    f"Method 'get_selected_quoted' can only be used on fields with only string values"
+                )
+            return self._enquote(x)
+        
+        return _u.process_if_not_none(selected_value, _enquote)
     
-    def get_selected_id(self, **kwargs) -> Optional[str]:
+    def get_selected_id(self, **kwargs) -> str | None:
         """
         Gets the ID of the selected option
 
         Returns:
             A string ID or None if there are no selectable options
         """
-        def get_id(x: po.SelectParameterOption): return x._identifier
-        return u.process_if_not_none(self.get_selected(), get_id)
+        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, **kwargs) -> Optional[str]:
+    def get_selected_id_quoted(self, **kwargs) -> str | None:
         """
         Gets the ID of the selected option surrounded by single quotes
 
         Returns:
             A string or None if there are no selectable options
         """
-        return u.process_if_not_none(self.get_selected_id(), self._enquote)
+        return _u.process_if_not_none(self.get_selected_id(), self._enquote)
     
-    def get_selected_label(self, **kwargs) -> Optional[str]:
+    def get_selected_label(self, **kwargs) -> str | None:
         """
         Gets the label of the selected option
 
         Returns:
             A string or None if there are no selectable options
         """
-        def get_label(x: po.SelectParameterOption): return x._label
-        return u.process_if_not_none(self.get_selected(), get_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, **kwargs) -> Optional[str]:
+    def get_selected_label_quoted(self, **kwargs) -> str | None:
         """
         Gets the label of the selected option surrounded by single quotes
 
         Returns:
             A string or None if there are no selectable options
         """
-        return u.process_if_not_none(self.get_selected_label(), self._enquote)
+        return _u.process_if_not_none(self.get_selected_label(), self._enquote)
 
     def _get_selected_ids_as_list(self) -> Sequence[str]:
         selected_id = self.get_selected_id()
         if selected_id is not None:
-            return (self.get_selected_id(),)
+            return (selected_id,)
         else:
             return tuple()
     
@@ -269,7 +319,7 @@ class SingleSelectParameter(_SelectionParameter):
         return output
     
     def _get_response_model0(self):
-        return arm.SingleSelectParameterModel
+        return arm.SingleSelectParameterModel if self.is_enabled() else arm.NoneParameterModel
 
 
 @dataclass
@@ -282,7 +332,7 @@ class MultiSelectParameter(_SelectionParameter):
         options: The parameter options that are currently selectable
         selected_ids: A sequence of IDs of the selected options
     """
-    _config: pc.MultiSelectParameterConfig
+    _config: _pc.MultiSelectParameterConfig
     _selected_ids: Sequence[str]
 
     def __post_init__(self):
@@ -293,18 +343,18 @@ class MultiSelectParameter(_SelectionParameter):
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.MultiSelectParameterConfig
+        return _pc.MultiSelectParameterConfig
     
     @classmethod
     def CreateWithOptions(
-        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "",
+        cls, name: str, label: str, all_options: Sequence[_po.SelectParameterOption | dict], *, description: str = "",
         show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True,
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a MultiSelectParameter that may include user attribute or parent
 
-        Parameters:
+        Arguments:
             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
@@ -315,35 +365,34 @@ class MultiSelectParameter(_SelectionParameter):
             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_config = pc.MultiSelectParameterConfig(
+        cls._CreateWithOptionsHelper(
             name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name,
             show_select_all=show_select_all, order_matters=order_matters, none_is_all=none_is_all
         )
-        ps.ParameterConfigsSetIO.obj.add(param_config)
     
     @classmethod
     def Create(
-        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "",
+        cls, name: str, label: str, all_options: Sequence[_po.SelectParameterOption | dict], *, description: str = "",
         show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True,
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         DEPRECATED. Use CreateWithOptions instead
         """
-        cls.CreateWithOptions(
-            name, label, all_options, description=description, show_select_all=show_select_all,
-            order_matters=order_matters, none_is_all=none_is_all, user_attribute=user_attribute, parent_name=parent_name
+        cls._CreateWithOptionsHelper(
+            name, label, all_options, description=description, user_attribute=user_attribute, parent_name=parent_name, 
+            show_select_all=show_select_all, order_matters=order_matters, none_is_all=none_is_all
         )
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, description: str = "",
+        cls, name: str, label: str, all_options: Sequence[_po.SelectParameterOption], *, description: str = "",
         show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a MultiSelectParameter that doesn't involve user attributes or parent parameters
 
-        Parameters:
+        Arguments:
             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
@@ -359,14 +408,14 @@ class MultiSelectParameter(_SelectionParameter):
     
     @classmethod
     def CreateFromSource(
-        cls, name: str, label: str, data_source: Union[d.SelectDataSource, dict], *, description: str = "",
+        cls, name: str, label: str, data_source: d.SelectDataSource | dict, *, description: str = "",
         show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True,
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a MultiSelectParameter that uses a SelectDataSource to receive the options
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             data_source: The lookup table to use for this parameter
@@ -380,11 +429,10 @@ class MultiSelectParameter(_SelectionParameter):
         extra_args = {
             "show_select_all": show_select_all, "order_matters": order_matters, "none_is_all": none_is_all
         }
-        param_config = pc.DataSourceParameterConfig(
-            pc.MultiSelectParameterConfig, name, label, data_source, extra_args=extra_args, description=description, 
+        cls._CreateFromSourceHelper(
+            name, label, data_source, extra_args=extra_args, description=description,
             user_attribute=user_attribute, parent_name=parent_name
         )
-        ps.ParameterConfigsSetIO.obj.add(param_config)
 
     def has_non_empty_selection(self) -> bool:
         """
@@ -399,12 +447,12 @@ class MultiSelectParameter(_SelectionParameter):
         return len(self._selected_ids) > 0
 
     def get_selected_list(
-        self, field: Optional[str] = None, *, default_field: Optional[str] = None, default: Any = None, **kwargs
-    ) -> Sequence[Union[po.SelectParameterOption, Any]]:
+        self, field: str | None = None, *, default_field: str | None = None, default: Any = None, **kwargs
+    ) -> Sequence[_po.SelectParameterOption | Any]:
         """
         Gets the sequence of the selected option(s) or a sequence of selected custom fields
 
-        Parameters:
+        Arguments:
             field: If field is not None, the method gets this field from the "custom_fields" attribute of the selected options. 
                 Otherwise, returns the class objects of the selected options
             default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used 
@@ -424,6 +472,70 @@ class MultiSelectParameter(_SelectionParameter):
             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_list_of_strings(
+        self, method: str, field: str, default_field: str | None, default: str | None, **kwargs
+    ) -> list[str]:
+        selected_list = self.get_selected_list(field, default_field=default_field, default=default)
+        list_of_strings: list[str] = []
+        for selected in selected_list:
+            if not isinstance(selected, str):
+                raise _u.ConfigurationError(
+                    f"Method '{method}' can only be used on fields with only string values"
+                )
+            list_of_strings.append(selected)
+        return list_of_strings
+    
+    def get_selected_list_joined(self, field: str, *, default_field: str | None = None, default: str | None = None, **kwargs) -> str:
+        """
+        Gets the selected custom fields joined by comma
+
+        Arguments:
+            field: The "custom_fields" attribute of the selected options.
+            default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used
+                as the "field" instead.
+            default: If field does not exist for a parameter option, default_field is None, but default is not None, the default
+                is returned as the selected field. Does nothing if default_field is not None
+
+        Returns:
+            A string
+        """
+        list_of_strings = self._get_selected_list_of_strings("get_selected_list_joined", field, default_field, default)
+        return ','.join(list_of_strings)
+    
+    def get_selected_list_quoted(self, field: str, *, default_field: str | None = None, default: str | None = None, **kwargs) -> tuple[str, ...]:
+        """
+        Gets the selected custom fields surrounded by single quotes
+
+        Arguments:
+            field: The "custom_fields" attribute of the selected options.
+            default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used
+                as the "field" instead.
+            default: If field does not exist for a parameter option, default_field is None, but default is not None, the default
+                is returned as the selected field. Does nothing if default_field is not None
+
+        Returns:
+            A tuple of strings
+        """
+        list_of_strings = self._get_selected_list_of_strings("get_selected_list_quoted", field, default_field, default)
+        return tuple(self._enquote(x) for x in list_of_strings)
+    
+    def get_selected_list_quoted_joined(self, field: str, *, default_field: str | None = None, default: str | None = None, **kwargs) -> str:
+        """
+        Gets the selected custom fields surrounded by single quotes and joined by comma
+
+        Arguments:
+            field: The "custom_fields" attribute of the selected options.
+            default_field: If field does not exist for a parameter option and default_field is not None, the default_field is used
+                as the "field" instead.
+            default: If field does not exist for a parameter option, default_field is None, but default is not None, the default
+                is returned as the selected field. Does nothing if default_field is not None
+        
+        Returns:
+            A string
+        """
+        list_of_strings = self._get_selected_list_of_strings("get_selected_list_quoted_joined", field, default_field, default)
+        return ','.join(self._enquote(x) for x in list_of_strings)
 
     def get_selected_ids_as_list(self, **kwargs) -> Sequence[str]:
         """
@@ -514,11 +626,29 @@ class MultiSelectParameter(_SelectionParameter):
         return output
     
     def _get_response_model0(self):
-        return arm.MultiSelectParameterModel
+        return arm.MultiSelectParameterModel if self.is_enabled() else arm.NoneParameterModel
+
+
+@dataclass
+class _DateTypeParameter(Parameter):
+    _curr_option: _po._DateTypeParameterOption | None
+    
+    def is_enabled(self) -> bool:
+        return self._curr_option is not None
+    
+    def _cast_optional_date_to_str(self, date: date | None) -> str | None:
+        return None if date is None else date.strftime("%Y-%m-%d")
+
+    def _to_json_dict0(self):
+        output = super()._to_json_dict0()
+        if self._curr_option is not None:
+            output["min_date"] = self._cast_optional_date_to_str(self._curr_option._min_date)
+            output["max_date"] = self._cast_optional_date_to_str(self._curr_option._max_date)
+        return output
 
 
 @dataclass
-class DateParameter(Parameter):
+class DateParameter(_DateTypeParameter):
     """
     Class for date parameter widgets.
 
@@ -527,56 +657,58 @@ class DateParameter(Parameter):
         curr_option: The current option showing for defaults based on user attribute and selection of parent
         selected_date: The selected date
     """
-    _config: pc.DateParameterConfig
-    _curr_option: Optional[po.DateParameterOption]
-    _selected_date: Union[date, str]
+    _config: _pc.DateParameterConfig
+    _curr_option: _po.DateParameterOption | None
+    _selected_date: date | str | None
 
     def __post_init__(self):
-        self._selected_date: date = self._validate_date(self._selected_date)
+        if self._curr_option is not None and self._selected_date is not None:
+            self._selected_date = self._validate_input_date(self._selected_date, self._curr_option)
     
     def is_enabled(self) -> bool:
         return self._curr_option is not None
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.DateParameterConfig
+        return _pc.DateParameterConfig
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, default_date: Union[str, date], *, description: str = "", 
-        date_format: str = '%Y-%m-%d', **kwargs
+        cls, name: str, label: str, default_date: str | date, *, description: str = "", 
+        min_date: str | date | None = None, max_date: str | date | None = None, date_format: str = '%Y-%m-%d', **kwargs
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             default_date: Default date for this option
             description: Explains the meaning of the parameter
             date_format: Format of the default date, default is '%Y-%m-%d'
         """
-        single_param_option = po.DateParameterOption(default_date, date_format=date_format)
+        single_param_option = _po.DateParameterOption(default_date, min_date=min_date, max_date=max_date, date_format=date_format)
         cls.CreateWithOptions(name, label, (single_param_option,), description=description)
     
-    def get_selected_date(self, *, date_format: str = None, **kwargs) -> str:
+    def get_selected_date(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected date as string
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
             A string
         """
+        assert self._curr_option is not None and isinstance(self._selected_date, date), "Parameter is not enabled"
         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, **kwargs) -> str:
+    def get_selected_date_quoted(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected date as string surrounded by single quotes
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
@@ -601,11 +733,11 @@ class DateParameter(Parameter):
         return output
     
     def _get_response_model0(self):
-        return arm.DateParameterModel if self.is_enabled() else arm.ParameterModelBase
+        return arm.DateParameterModel if self.is_enabled() else arm.NoneParameterModel
 
 
 @dataclass
-class DateRangeParameter(Parameter):
+class DateRangeParameter(_DateTypeParameter):
     """
     Class for date range parameter widgets.
 
@@ -615,31 +747,35 @@ class DateRangeParameter(Parameter):
         selected_start_date: The selected start date
         selected_end_date: The selected end date
     """
-    _config: pc.DateRangeParameterConfig
-    _curr_option: Optional[po.DateRangeParameterOption]
-    _selected_start_date: Union[date, str]
-    _selected_end_date: Union[date, str]
+    _config: _pc.DateRangeParameterConfig
+    _curr_option: _po.DateRangeParameterOption | None
+    _selected_start_date: date | str | None
+    _selected_end_date: date | str | None
 
     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)
+        if self._curr_option is not None:
+            if self._selected_start_date is not None:
+                self._selected_start_date = self._validate_input_date(self._selected_start_date, self._curr_option)
+            if self._selected_end_date is not None:
+                self._selected_end_date = self._validate_input_date(self._selected_end_date, self._curr_option)
     
     def is_enabled(self) -> bool:
         return self._curr_option is not None
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.DateRangeParameterConfig
+        return _pc.DateRangeParameterConfig
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, default_start_date: Union[str, date], default_end_date: Union[str, date], *, 
-        description: str = "", date_format: str = '%Y-%m-%d', **kwargs
+        cls, name: str, label: str, default_start_date: str | date, default_end_date: str | date, *, 
+        description: str = "", min_date: str | date | None = None, max_date: str | date | None = None,
+        date_format: str = '%Y-%m-%d', **kwargs
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             default_start_date: Default start date for this option
@@ -647,27 +783,30 @@ class DateRangeParameter(Parameter):
             description: Explains the meaning of the parameter
             date_format: Format of the default date, default is '%Y-%m-%d'
         """
-        single_param_option = po.DateRangeParameterOption(default_start_date, default_end_date, date_format=date_format)
+        single_param_option = _po.DateRangeParameterOption(
+            default_start_date, default_end_date, min_date=min_date, max_date=max_date, date_format=date_format
+        )
         cls.CreateWithOptions(name, label, (single_param_option,), description=description)
     
-    def get_selected_start_date(self, *, date_format: str = None, **kwargs) -> str:
+    def get_selected_start_date(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected start date as string
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
             A string
         """
+        assert self._curr_option is not None and isinstance(self._selected_start_date, date), "Parameter is not enabled"
         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:
+    def get_selected_start_date_quoted(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected start date as string surrounded by single quotes
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
@@ -675,24 +814,25 @@ class DateRangeParameter(Parameter):
         """
         return self._enquote(self.get_selected_start_date(date_format=date_format))
     
-    def get_selected_end_date(self, *, date_format: str = None, **kwargs) -> str:
+    def get_selected_end_date(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected end date as string
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
             A string
         """
+        assert self._curr_option is not None and isinstance(self._selected_end_date, date), "Parameter is not enabled"
         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_end_date_quoted(self, *, date_format: str = None, **kwargs) -> str:
+    def get_selected_end_date_quoted(self, *, date_format: str | None = None, **kwargs) -> str:
         """
         Gets selected end date as string surrounded by single quotes
 
-        Parameters:
+        Arguments:
             date_format: The date format (see Python's datetime formats). If not specified, self.date_format is used
 
         Returns:
@@ -716,11 +856,27 @@ class DateRangeParameter(Parameter):
         return output
     
     def _get_response_model0(self):
-        return arm.DateRangeParameterModel if self.is_enabled() else arm.ParameterModelBase
+        return arm.DateRangeParameterModel if self.is_enabled() else arm.NoneParameterModel
 
 
 @dataclass
-class NumberParameter(Parameter):
+class _NumberTypeParameter(Parameter):
+    _curr_option: _po._NumericParameterOption | None
+    
+    def is_enabled(self) -> bool:
+        return self._curr_option is not None
+
+    def _to_json_dict0(self):
+        output = super()._to_json_dict0()
+        if self._curr_option is not None:
+            output["min_value"] = float(self._curr_option._min_value)
+            output["max_value"] = float(self._curr_option._max_value)
+            output["increment"] = float(self._curr_option._increment)
+        return output
+    
+
+@dataclass
+class NumberParameter(_NumberTypeParameter):
     """
     Class for number parameter widgets.
 
@@ -729,31 +885,29 @@ class NumberParameter(Parameter):
         curr_option: The current option showing for defaults based on user attribute and selection of parent
         selected_value: The selected integer or decimal number
     """
-    _config: pc.NumberParameterConfig
-    _curr_option: Optional[po.NumberParameterOption]
-    _selected_value: po.Number
+    _config: _pc.NumberParameterConfig
+    _curr_option: _po.NumberParameterOption | None
+    _selected_value: _po.Number | None
 
     def __post_init__(self):
-        self._selected_value: Decimal = self._validate_number(self._selected_value, self._curr_option)
-    
-    def is_enabled(self) -> bool:
-        return self._curr_option is not None
+        if self._curr_option is not None and self._selected_value is not None:
+            self._selected_value = self._validate_number(self._selected_value, self._curr_option)
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.NumberParameterConfig
+        return _pc.NumberParameterConfig
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, min_value: po.Number, max_value: po.Number, *, description: str = "", 
-        increment: po.Number = 1, default_value: Optional[po.Number] = None, **kwargs
+        cls, name: str, label: str, min_value: _po.Number, max_value: _po.Number, *, description: str = "", 
+        increment: _po.Number = 1, default_value: _po.Number | None = None, **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:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             min_value: Minimum selectable value
@@ -762,7 +916,7 @@ class NumberParameter(Parameter):
             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
         """
-        single_param_option = po.NumberParameterOption(min_value, max_value, increment=increment, default_value=default_value)
+        single_param_option = _po.NumberParameterOption(min_value, max_value, increment=increment, default_value=default_value)
         cls.CreateWithOptions(name, label, (single_param_option,), description=description)
     
     def get_selected_value(self, **kwargs) -> float:
@@ -772,6 +926,7 @@ class NumberParameter(Parameter):
         Returns:
             float
         """
+        assert self._selected_value is not None, "Parameter is not enabled"
         return float(self._selected_value)
         
     def _to_json_dict0(self):
@@ -783,16 +938,15 @@ class NumberParameter(Parameter):
         """
         output = super()._to_json_dict0()
         if self.is_enabled():
-            output.update(self._curr_option._to_json_dict())
             output["selected_value"] = self.get_selected_value()
         return output
     
     def _get_response_model0(self):
-        return arm.NumberParameterModel if self.is_enabled() else arm.ParameterModelBase
+        return arm.NumberParameterModel if self.is_enabled() else arm.NoneParameterModel
 
 
 @dataclass
-class NumberRangeParameter(Parameter):
+class NumberRangeParameter(_NumberTypeParameter):
     """
     Class for number range parameter widgets.
 
@@ -802,26 +956,26 @@ class NumberRangeParameter(Parameter):
         selected_lower_value: The selected lower integer or decimal number
         selected_upper_value: The selected upper integer or decimal number
     """
-    _config: pc.NumberRangeParameterConfig
-    _curr_option: Optional[po.NumberRangeParameterOption]
-    _selected_lower_value: po.Number
-    _selected_upper_value: po.Number
+    _config: _pc.NumberRangeParameterConfig
+    _curr_option: _po.NumberRangeParameterOption | None
+    _selected_lower_value: _po.Number | None
+    _selected_upper_value: _po.Number | 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)
-    
-    def is_enabled(self) -> bool:
-        return self._curr_option is not None
+        if self._curr_option is not None:
+            if self._selected_lower_value is not None:
+                self._selected_lower_value = self._validate_number(self._selected_lower_value, self._curr_option)
+            if self._selected_upper_value is not None:
+                self._selected_upper_value = self._validate_number(self._selected_upper_value, self._curr_option)
     
     @staticmethod
     def _ParameterConfigType():
-        return pc.NumberRangeParameterConfig
+        return _pc.NumberRangeParameterConfig
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, min_value: po.Number, max_value: po.Number, *, description: str = "",
-        increment: po.Number = 1, default_lower_value: Optional[po.Number] = None, default_upper_value: Optional[po.Number] = None,
+        cls, name: str, label: str, min_value: _po.Number, max_value: _po.Number, *, description: str = "",
+        increment: _po.Number = 1, default_lower_value: _po.Number | None = None, default_upper_value: _po.Number | None = None,
         **kwargs
     ) -> None:
         """
@@ -829,7 +983,7 @@ class NumberRangeParameter(Parameter):
         
         * Note that the "Number" type denotes an int, a Decimal (from decimal module), or a string that can be parsed to Decimal
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             min_value: Minimum selectable value
@@ -840,7 +994,7 @@ class NumberRangeParameter(Parameter):
             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
         """
-        single_param_option = po.NumberRangeParameterOption(
+        single_param_option = _po.NumberRangeParameterOption(
             min_value, max_value, increment=increment, default_lower_value=default_lower_value, default_upper_value=default_upper_value
         )
         cls.CreateWithOptions(name, label, (single_param_option,), description=description)
@@ -852,6 +1006,7 @@ class NumberRangeParameter(Parameter):
         Returns:
             float
         """
+        assert self._selected_lower_value is not None, "Parameter is not enabled"
         return float(self._selected_lower_value)
 
     def get_selected_upper_value(self, **kwargs) -> float:
@@ -861,6 +1016,7 @@ class NumberRangeParameter(Parameter):
         Returns:
             float
         """
+        assert self._selected_upper_value is not None, "Parameter is not enabled"
         return float(self._selected_upper_value)
 
     def _to_json_dict0(self):
@@ -871,14 +1027,13 @@ class NumberRangeParameter(Parameter):
             A dictionary for the JSON object
         """
         output = super()._to_json_dict0()
-        if self._curr_option is not None:
-            output.update(self._curr_option._to_json_dict())
+        if self.is_enabled():
             output['selected_lower_value'] = self.get_selected_lower_value()
             output['selected_upper_value'] = self.get_selected_upper_value()
         return output
     
     def _get_response_model0(self):
-        return arm.NumberRangeParameterModel if self.is_enabled() else arm.ParameterModelBase
+        return arm.NumberRangeParameterModel if self.is_enabled() else arm.NoneParameterModel
 
 
 @dataclass
@@ -886,7 +1041,7 @@ class TextValue:
     _value_do_not_touch: str
 
     def __repr__(self):
-        raise u.ConfigurationError(
+        raise _u.ConfigurationError(
             "Cannot convert TextValue directly to string (to avoid SQL injection). Try using it through placeholders instead"
         )
 
@@ -896,7 +1051,7 @@ class TextValue:
         
         This method returns a new object and leaves the original the same.
 
-        Parameters:
+        Arguments:
             str_to_str_function: A function that accepts a string and returns a string
 
         Returns:
@@ -904,7 +1059,7 @@ class TextValue:
         """
         new_value = str_to_str_function(self._value_do_not_touch)
         if not isinstance(new_value, str):
-            raise u.ConfigurationError("Function provided must return string")
+            raise _u.ConfigurationError("Function provided must return string")
         return TextValue(new_value)
     
     def apply_percent_wrap(self) -> TextValue:
@@ -920,7 +1075,7 @@ class TextValue:
         """
         Transforms the entered text with a function that takes a string and returns a boolean.
 
-        Parameters:
+        Arguments:
             str_to_bool_function: A function that accepts a string and returns a boolean.
 
         Returns:
@@ -928,14 +1083,14 @@ class TextValue:
         """
         new_value = str_to_bool_function(self._value_do_not_touch)
         if not isinstance(new_value, bool):
-            raise u.ConfigurationError("Function provided must return bool")
+            raise _u.ConfigurationError("Function provided must return bool")
         return new_value
     
-    def apply_as_number(self, str_to_num_function: Callable[[str], Union[int, float]]) ->  Union[int, float]:
+    def apply_as_number(self, str_to_num_function: Callable[[str], IntOrFloat]) ->  IntOrFloat:
         """
         Transforms the entered text with a function that takes a string and returns an int or float.
 
-        Parameters:
+        Arguments:
             str_to_num_function: A function that accepts a string and returns an int or float.
 
         Returns:
@@ -943,14 +1098,14 @@ class TextValue:
         """
         new_value = str_to_num_function(self._value_do_not_touch)
         if not isinstance(new_value, (int, float)):
-            raise u.ConfigurationError("Function provided must return a number")
+            raise _u.ConfigurationError("Function provided must return a number")
         return new_value
     
     def apply_as_datetime(self, str_to_datetime_function: Callable[[str], datetime]) -> datetime:
         """
         Transforms the entered text with a function that takes a string and returns a datetime object.
 
-        Parameters:
+        Arguments:
             str_to_datetime_function: A function that accepts a string and returns a datetime object.
 
         Returns:
@@ -958,7 +1113,7 @@ class TextValue:
         """
         new_value = str_to_datetime_function(self._value_do_not_touch)
         if not isinstance(new_value, datetime):
-            raise u.ConfigurationError("Function provided must return datetime")
+            raise _u.ConfigurationError("Function provided must return datetime")
         return new_value
 
 
@@ -967,33 +1122,33 @@ class TextParameter(Parameter):
     """
     Class for text parameter widgets.
     """
-    _config: pc.TextParameterConfig
-    _curr_option: Optional[po.TextParameterOption]
-    _entered_text: str
+    _config: _pc.TextParameterConfig
+    _curr_option: _po.TextParameterOption | None
+    _entered_text: str | None
 
     def __post_init__(self):
-        try:
-            if self.is_enabled():
+        if self.is_enabled() and isinstance(self._entered_text, str):
+            try:
                 self._entered_text = self._config.validate_entered_text(self._entered_text)
-        except u.ConfigurationError as e:
-            self._config._raise_invalid_input_error(self._entered_text, str(e), e)
+            except _u.ConfigurationError as e:
+                raise self._config._invalid_input_error(self._entered_text, str(e))
     
     def is_enabled(self) -> bool:
         return self._curr_option is not None
-
+    
     @staticmethod
     def _ParameterConfigType():
-        return pc.TextParameterConfig
+        return _pc.TextParameterConfig
     
     @classmethod
     def CreateWithOptions(
-        cls, name: str, label: str, all_options: Sequence[Union[po.TextParameterOption, dict]], *, description: str = "",
-        input_type: str = "text", user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        cls, name: str, label: str, all_options: Sequence[_po.TextParameterOption | dict], *, description: str = "",
+        input_type: str = "text", user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a MultiSelectParameter that may include user attribute or parent
 
-        Parameters:
+        Arguments:
             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
@@ -1002,21 +1157,19 @@ class TextParameter(Parameter):
             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_config = pc.TextParameterConfig(
-            name, label, all_options, description=description, input_type=input_type, user_attribute=user_attribute, 
-            parent_name=parent_name
+        cls._CreateWithOptionsHelper(
+            name, label, all_options, description=description, input_type=input_type, user_attribute=user_attribute, parent_name=parent_name
         )
-        ps.ParameterConfigsSetIO.obj.add(param_config)
     
     @classmethod
     def Create(
-        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "",
-        input_type: str = "text", user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        cls, name: str, label: str, all_options: Sequence[_po.TextParameterOption | dict], *, description: str = "",
+        input_type: str = "text", user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         DEPRECATED. Use CreateWithOptions instead
         """
-        cls.CreateWithOptions(
+        cls._CreateWithOptionsHelper(
             name, label, all_options, description=description, input_type=input_type, user_attribute=user_attribute, parent_name=parent_name
         )
 
@@ -1027,25 +1180,25 @@ class TextParameter(Parameter):
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
         
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             description: Explains the meaning of the parameter
             default_text: Default input text for this option. Optional, default is empty string.
             input_type: The type of input field to use. Must be one of "text", "textarea", "number", "color", "date", "datetime-local", "month", "time", and "password". Optional, default is "text". More information on input types other than "textarea" can be found at https://www.w3schools.com/html/html_form_input_types.asp. More information on "textarea" can be found at https://www.w3schools.com/tags/tag_textarea.asp
         """
-        single_param_option = po.TextParameterOption(default_text=default_text)
+        single_param_option = _po.TextParameterOption(default_text=default_text)
         cls.CreateWithOptions(name, label, (single_param_option,), description=description, input_type=input_type)
     
     @classmethod
     def CreateFromSource(
-        cls, name: str, label: str, data_source: Union[d.TextDataSource, dict], *, description: str = "",
-        input_type: str = "text", user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+        cls, name: str, label: str, data_source: d.TextDataSource | dict, *, description: str = "",
+        input_type: str = "text", user_attribute: str | None = None, parent_name: str | None = None, **kwargs
     ) -> None:
         """
         Method for creating the configurations for a MultiSelectParameter that uses a SelectDataSource to receive the options
 
-        Parameters:
+        Arguments:
             name: The name of the parameter
             label: The display label for the parameter
             data_source: The lookup table to use for this parameter
@@ -1057,11 +1210,9 @@ class TextParameter(Parameter):
         extra_args = {
             "input_type": input_type
         }
-        param_config = pc.DataSourceParameterConfig(
-            pc.TextParameterConfig, name, label, data_source, extra_args=extra_args, description=description, 
-            user_attribute=user_attribute, parent_name=parent_name
+        cls._CreateFromSourceHelper(
+            name, label, data_source, extra_args=extra_args, description=description, user_attribute=user_attribute, parent_name=parent_name
         )
-        ps.ParameterConfigsSetIO.obj.add(param_config)
     
     def get_entered_text(self, **kwargs) -> TextValue:
         """
@@ -1070,6 +1221,7 @@ class TextParameter(Parameter):
         Returns:
             A TextValue object
         """
+        assert isinstance(self._entered_text, str), "Parameter is not enabled"
         return TextValue(self._entered_text)
     
     def get_entered_int(self, **kwargs) -> int:
@@ -1079,7 +1231,7 @@ class TextParameter(Parameter):
         Returns: int
         """
         if self._config.input_type != "number":
-            raise u.ConfigurationError("Method 'get_entered_int' requires TextParameter to have input type 'number'")
+            raise _u.ConfigurationError("Method 'get_entered_int' requires TextParameter to have input type 'number'")
         text = self.get_entered_text()
         return text.apply_as_number(int)
     
@@ -1091,7 +1243,7 @@ class TextParameter(Parameter):
         """
         applicable_input_types = ["date", "datetime-local", "month", "time"]
         if self._config.input_type not in applicable_input_types:
-            raise u.ConfigurationError(f"Method 'get_entered_datetime' requires TextParameter to have one of these input types: {applicable_input_types}")
+            raise _u.ConfigurationError(f"Method 'get_entered_datetime' requires TextParameter to have one of these input types: {applicable_input_types}")
         text = self.get_entered_text()
 
         date_formats = { "date": "%Y-%m-%d", "datetime-local": "%Y-%m-%dT%H:%M", "month": "%Y-%m", "time": "%H:%M" }
@@ -1106,9 +1258,9 @@ class TextParameter(Parameter):
         """
         output = super()._to_json_dict0()
         output['input_type'] = self._config.input_type
-        if self._curr_option is not None:
+        if self.is_enabled():
             output['entered_text'] = self._entered_text
         return output
     
     def _get_response_model0(self):
-        return arm.TextParameterModel if self.is_enabled() else arm.ParameterModelBase
+        return arm.TextParameterModel if self.is_enabled() else arm.NoneParameterModel