squirrels 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

squirrels/parameters.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
-from typing import Type, Sequence, Optional, Union, Any
+from typing import Callable, Type, Sequence, Optional, Union, 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, _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
 
 
 @dataclass
@@ -15,6 +16,10 @@ class Parameter(metaclass=ABCMeta):
     """
     _config: pc.ParameterConfig
 
+    @abstractmethod
+    def is_enabled(self) -> bool:
+        return True
+
     @staticmethod
     @abstractmethod
     def _ParameterConfigType() -> Type:
@@ -22,7 +27,7 @@ class Parameter(metaclass=ABCMeta):
     
     @classmethod
     def Create(
-        cls, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, is_hidden: bool = False, 
+        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:
         """
@@ -32,38 +37,38 @@ class Parameter(metaclass=ABCMeta):
             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
+            description: Explains the meaning of the 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_type = cls._ParameterConfigType()
-        param_config = param_config_type(name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        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
     @abstractmethod
-    def CreateSimple(cls, name: str, label: str, *args, is_hidden: bool = False, **kwargs) -> None:
+    def CreateSimple(cls, name: str, label: str, *args, description: str = "", **kwargs) -> None:
         pass
     
     @classmethod
     def CreateFromSource(
-        cls, name: str, label: str, data_source: Union[d.DataSource , dict], *, is_hidden: bool = False, 
+        cls, name: str, label: str, data_source: Union[d.DataSource , dict], *, description: str = "", 
         user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
     ) -> None:
         """
-        Method for creating the configurations for any Parameter that uses a DataSource to received the options
+        Method for creating the configurations for any Parameter that uses a DataSource to receive the options
 
         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
+            description: Explains the meaning of the 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_type = cls._ParameterConfigType()
-        param_config = pc.DataSourceParameterConfig(param_config_type, name, label, data_source, is_hidden=is_hidden, 
+        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)
         
@@ -87,7 +92,17 @@ class Parameter(metaclass=ABCMeta):
         """
         Helper method to convert the derived Parameter class into a JSON dictionary
         """
-        return self._config.to_json_dict0()
+        output = self._config.to_json_dict0()
+        if not self.is_enabled():
+            output["widget_type"] = "disabled"
+        return output
+    
+    @abstractmethod
+    def _get_response_model0(self) -> type[arm.ParameterModelBase]:
+        pass
+    
+    def _to_api_response_model0(self) -> arm.ParameterModel:
+        return self._get_response_model0().model_validate(self.to_json_dict0())
 
 
 @dataclass
@@ -98,6 +113,9 @@ class _SelectionParameter(Parameter):
     def __post_init__(self):
         self._options = tuple(self._options)
 
+    def is_enabled(self) -> bool:
+        return len(self._options) > 0
+    
     @abstractmethod
     def _get_selected_ids_as_list(self) -> Sequence[str]:
         pass
@@ -107,7 +125,7 @@ class _SelectionParameter(Parameter):
             self._config._raise_invalid_input_error(selected_id, f"The selected id {selected_id} does not exist in available options.")
     
     @abstractmethod
-    def to_json_dict0(self):
+    def to_json_dict0(self) -> dict:
         """
         Helper method to convert the derived selection parameter class into a JSON object
         """
@@ -143,7 +161,7 @@ class SingleSelectParameter(_SelectionParameter):
     
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, is_hidden: bool = False, **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
@@ -152,9 +170,9 @@ class SingleSelectParameter(_SelectionParameter):
             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
+            description: Explains the meaning of the parameter
         """
-        cls.Create(name, label, all_options, is_hidden=is_hidden)
+        cls.Create(name, label, all_options, description=description)
 
     def get_selected(
         self, field: Optional[str] = None, *, default_field: Optional[str] = None, default: Any = None, **kwargs
@@ -235,6 +253,9 @@ class SingleSelectParameter(_SelectionParameter):
         output = super().to_json_dict0()
         output['selected_id'] = self._selected_id
         return output
+    
+    def _get_response_model0(self):
+        return arm.SingleSelectParameterModel
 
 
 @dataclass
@@ -262,55 +283,85 @@ class MultiSelectParameter(_SelectionParameter):
     
     @classmethod
     def Create(
-        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, show_select_all: bool = True, 
-        is_dropdown: bool = True, order_matters: bool = False, none_is_all: bool = True, is_hidden: bool = False, 
+        cls, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "",
+        show_select_all: bool = True, is_dropdown: bool = True, order_matters: bool = False, none_is_all: bool = True,
         user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
     ) -> None:
         """
-        Method for creating the configurations for a Parameter that may include user attribute or parent
+        Method for creating the configurations for a MultiSelectParameter that may include user attribute or parent
 
         Parameters:
             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
+            description: Explains the meaning of the parameter
             show_select_all: Communicate to front-end whether to include a "select all" option
             is_dropdown: Communicate to front-end whether the widget should be a dropdown with checkboxes
             order_matters: Communicate to front-end whether the order of the selections made matter
             none_is_all: Whether having no options selected is equivalent to all selectable options selected
-            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_config = pc.MultiSelectParameterConfig(
             name, label, all_options, 
             show_select_all=show_select_all, is_dropdown=is_dropdown, order_matters=order_matters, none_is_all=none_is_all, 
-            is_hidden=is_hidden, user_attribute=user_attribute, parent_name=parent_name
+            description=description, user_attribute=user_attribute, parent_name=parent_name
         )
         ps.ParameterConfigsSetIO.obj.add(param_config)
 
     @classmethod
     def CreateSimple(
-        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, show_select_all: bool = True, 
-        is_dropdown: bool = True, order_matters: bool = False, none_is_all: bool = True, is_hidden: bool = False, **kwargs
+        cls, name: str, label: str, all_options: Sequence[po.SelectParameterOption], *, description: str = "",
+        show_select_all: bool = True, is_dropdown: bool = True, order_matters: bool = False, none_is_all: bool = True, **kwargs
     ) -> None:
         """
-        Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
+        Method for creating the configurations for a MultiSelectParameter 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: All options associated to this parameter regardless of the user group or parent parameter option they depend on
+            description: Explains the meaning of the parameter
             show_select_all: Communicate to front-end whether to include a "select all" option
             is_dropdown: Communicate to front-end whether the widget should be a dropdown with checkboxes
             order_matters: Communicate to front-end whether the order of the selections made matter
             none_is_all: Whether having no options selected is equivalent to all selectable options selected
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
         cls.Create(
-            name, label, all_options, 
-            show_select_all=show_select_all, s_dropdown=is_dropdown, order_matters=order_matters, none_is_all=none_is_all, 
-            is_hidden=is_hidden
+            name, label, all_options, description=description,
+            show_select_all=show_select_all, s_dropdown=is_dropdown, order_matters=order_matters, none_is_all=none_is_all
+        )
+    
+    @classmethod
+    def CreateFromSource(
+        cls, name: str, label: str, data_source: Union[d.SelectDataSource, dict], *, description: str = "",
+        show_select_all: bool = True, is_dropdown: bool = True, order_matters: bool = False, none_is_all: bool = True,
+        user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Method for creating the configurations for a MultiSelectParameter that uses a SelectDataSource to receive the options
+
+        Parameters:
+            name: The name of the parameter
+            label: The display label for the parameter
+            data_source: The lookup table to use for this parameter
+            description: Explains the meaning of the parameter
+            show_select_all: Communicate to front-end whether to include a "select all" option
+            is_dropdown: Communicate to front-end whether the widget should be a dropdown with checkboxes
+            order_matters: Communicate to front-end whether the order of the selections made matter
+            none_is_all: Whether having no options selected is equivalent to all selectable options selected
+            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)
+        """
+        extra_args = {
+            "show_select_all": show_select_all, "is_dropdown": is_dropdown, 
+            "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, 
+            user_attribute=user_attribute, parent_name=parent_name
         )
+        ps.ParameterConfigsSetIO.obj.add(param_config)
 
     def has_non_empty_selection(self) -> bool:
         """
@@ -436,6 +487,9 @@ class MultiSelectParameter(_SelectionParameter):
         output = super().to_json_dict0()
         output['selected_ids'] = list(self._selected_ids)
         return output
+    
+    def _get_response_model0(self):
+        return arm.MultiSelectParameterModel
 
 
 @dataclass
@@ -448,19 +502,23 @@ class DateParameter(Parameter):
         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
+    _curr_option: Optional[po.DateParameterOption]
     _selected_date: Union[date, str]
 
     def __post_init__(self):
         self._selected_date: date = self._validate_date(self._selected_date)
     
+    def is_enabled(self) -> bool:
+        return self._curr_option is not None
+    
     @staticmethod
     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
+        cls, name: str, label: str, default_date: Union[str, date], *, description: str = "", 
+        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
@@ -469,11 +527,11 @@ class DateParameter(Parameter):
             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'
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
         single_param_option = po.DateParameterOption(default_date, date_format=date_format)
-        cls.Create(name, label, (single_param_option,), is_hidden=is_hidden)
+        cls.Create(name, label, (single_param_option,), description=description)
     
     def get_selected_date(self, *, date_format: str = None, **kwargs) -> str:
         """
@@ -510,9 +568,14 @@ class DateParameter(Parameter):
             A dictionary for the JSON object
         """
         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")
+        if self.is_enabled():
+            output["selected_date"] = self.get_selected_date(date_format="%Y-%m-%d")
+        else:
+            output["selected_date"] = ""
         return output
+    
+    def _get_response_model0(self):
+        return arm.DateParameterModel if self.is_enabled() else arm.ParameterModelBase
 
 
 @dataclass
@@ -526,7 +589,7 @@ class DateRangeParameter(Parameter):
         selected_start_date: The selected start date
         selected_end_date: The selected end date
     """
-    _curr_option: po.DateRangeParameterOption
+    _curr_option: Optional[po.DateRangeParameterOption]
     _selected_start_date: Union[date, str]
     _selected_end_date: Union[date, str]
 
@@ -534,14 +597,17 @@ class DateRangeParameter(Parameter):
         self._selected_start_date: date = self._validate_date(self._selected_start_date)
         self._selected_end_date: date = self._validate_date(self._selected_end_date)
     
+    def is_enabled(self) -> bool:
+        return self._curr_option is not None
+    
     @staticmethod
     def _ParameterConfigType():
         return pc.DateRangeParameterConfig
 
     @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
+        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
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
@@ -551,11 +617,11 @@ class DateRangeParameter(Parameter):
             label: The display label for the parameter
             default_start_date: Default start date for this option
             default_end_date: Default end date for this option
+            description: Explains the meaning of the parameter
             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
         """
         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)
+        cls.Create(name, label, (single_param_option,), description=description)
     
     def get_selected_start_date(self, *, date_format: str = None, **kwargs) -> str:
         """
@@ -617,10 +683,13 @@ class DateRangeParameter(Parameter):
             A dictionary for the JSON object
         """
         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")
+        if self.is_enabled():
+            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
+    
+    def _get_response_model0(self):
+        return arm.DateRangeParameterModel if self.is_enabled() else arm.ParameterModelBase
 
 
 @dataclass
@@ -633,20 +702,23 @@ 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
     """
-    _curr_option: po.NumberParameterOption
+    _curr_option: Optional[po.NumberParameterOption]
     _selected_value: po.Number
 
     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
+    
     @staticmethod
     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
+        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
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
@@ -658,21 +730,21 @@ class NumberParameter(Parameter):
             label: The display label for the parameter
             min_value: Minimum selectable value
             max_value: Maximum selectable value
+            description: Explains the meaning of the 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
-            is_hidden: Whether the parameter is hidden in the parameters API response. Default is False
         """
         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)
+        cls.Create(name, label, (single_param_option,), description=description)
     
-    def get_selected_value(self, **kwargs) -> str:
+    def get_selected_value(self, **kwargs) -> float:
         """
-        Get the selected number
+        Get the selected number (converted from Decimal to float)
 
         Returns:
-            A number parsable string of the selected number
+            float
         """
-        return str(self._selected_value)
+        return float(self._selected_value)
         
     def to_json_dict0(self):
         """
@@ -682,9 +754,13 @@ class NumberParameter(Parameter):
             A dictionary for the JSON object
         """
         output = super().to_json_dict0()
-        output.update(self._curr_option._to_json_dict())
-        output['selected_value'] = self.get_selected_value()
+        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
 
 
 @dataclass
@@ -698,7 +774,7 @@ class NumberRangeParameter(Parameter):
         selected_lower_value: The selected lower integer or decimal number
         selected_upper_value: The selected upper integer or decimal number
     """
-    _curr_option: po.NumberRangeParameterOption
+    _curr_option: Optional[po.NumberRangeParameterOption]
     _selected_lower_value: po.Number
     _selected_upper_value: po.Number
 
@@ -706,14 +782,18 @@ class NumberRangeParameter(Parameter):
         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
+    
     @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
+        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,
+        **kwargs
     ) -> None:
         """
         Method for creating the configurations for a Parameter that doesn't involve user attributes or parent parameters
@@ -725,34 +805,182 @@ class NumberRangeParameter(Parameter):
             label: The display label for the parameter
             min_value: Minimum selectable value
             max_value: Maximum selectable value
+            description: Explains the meaning of the parameter
             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
         """
-        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)
+        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,), description=description)
     
-    def get_selected_lower_value(self, **kwargs) -> str:
+    def get_selected_lower_value(self, **kwargs) -> float:
         """
-        Get the selected lower value number
+        Get the selected lower value number (converted from Decimal to float)
 
         Returns:
-            A number parsable string of the selected number
+            float
         """
-        return str(self._selected_lower_value)
+        return float(self._selected_lower_value)
 
-    def get_selected_upper_value(self, **kwargs) -> str:
+    def get_selected_upper_value(self, **kwargs) -> float:
         """
-        Get the selected upper value number
+        Get the selected upper value number (converted from Decimal to float)
 
         Returns:
-            A number parsable string of the selected number
+            float
+        """
+        return float(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_dict0()
+        if self._curr_option is not None:
+            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
+    
+    def _get_response_model0(self):
+        return arm.NumberRangeParameterModel if self.is_enabled() else arm.ParameterModelBase
+
+
+@dataclass
+class _TextValue:
+    _value_do_not_touch: str
+
+    def __repr__(self):
+        raise u.ConfigurationError(
+            "Cannot convert the entered text of TextParameter directly to string type. Try using it through placeholders instead"
+        )
+
+    def apply(self, str_to_str_function: Callable[[str], str]) -> _TextValue:
+        """
+        Transforms the entered text with a function that takes a string and returns a string. 
+        
+        This method returns a new object and leaves the original the same.
+
+        Parameters:
+            str_to_str_function: A function that accepts a string and returns a string
+
+        Returns:
+            A new TextValue with the transformed entered text
+        """
+        new_value = str_to_str_function(self._value_do_not_touch)
+        assert isinstance(new_value, str), "Function provided must return string"
+        return _TextValue(new_value)
+    
+    def apply_percent_wrap(self) -> _TextValue:
+        """
+        Adds percent signs before and after the entered text, and returns a new object, leaving the original the same.
+
+        Returns:
+            A new TextValue with the transformed entered text
+        """
+        return self.apply(lambda x: "%"+x+"%")
+    
+    def apply_as_bool(self, str_to_bool_function: Callable[[str], bool]) -> bool:
+        """
+        Transforms the entered text with a function that takes a string and returns a boolean.
+
+        Parameters:
+            str_to_bool_function: A function that accepts a string and returns a boolean.
+
+        Returns:
+            A boolean for the transformed value
+        """
+        new_value = str_to_bool_function(self._value_do_not_touch)
+        assert isinstance(new_value, bool), "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]:
+        """
+        Transforms the entered text with a function that takes a string and returns an int or float.
+
+        Parameters:
+            str_to_num_function: A function that accepts a string and returns an int or float.
+
+        Returns:
+            An int or float for the transformed value
+        """
+        new_value = str_to_num_function(self._value_do_not_touch)
+        assert isinstance(new_value, (int, float)), "Function provided must return a number"
+        return new_value
+
+
+@dataclass
+class TextParameter(Parameter):
+    """
+    Class for text parameter widgets.
+    """
+    _curr_option: Optional[po.TextParameterOption]
+    _entered_text: str
+    
+    def is_enabled(self) -> bool:
+        return self._curr_option is not None
+
+    @staticmethod
+    def _ParameterConfigType():
+        return pc.TextParameterConfig
+    
+    @classmethod
+    def Create(
+        cls, name: str, label: str, all_options: Sequence[Union[po.TextParameterOption, dict]], *, description: str = "",
+        is_textarea: bool = False, user_attribute: Optional[str] = None, parent_name: Optional[str] = None, **kwargs
+    ) -> None:
+        """
+        Method for creating the configurations for a MultiSelectParameter that may include user attribute or parent
+
+        Parameters:
+            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
+            description: Explains the meaning of the parameter
+            is_textarea: Whether the textbox field should be big. Optional, 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_config = pc.TextParameterConfig(
+            name, label, all_options, description=description, is_textarea=is_textarea, user_attribute=user_attribute, 
+            parent_name=parent_name
+        )
+        ps.ParameterConfigsSetIO.obj.add(param_config)
+
+    @classmethod
+    def CreateSimple(
+        cls, name: str, label: str, *, description: str = "", default_text: str = "", is_textarea: 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
+            description: Explains the meaning of the parameter
+            default_text: Default input text for this option. Optional, default is empty string.
+            is_textarea: Whether the textbox field should be big. Optional, default is False.
         """
-        return str(self._selected_upper_value)
+        single_param_option = po.TextParameterOption(default_text=default_text)
+        cls.Create(name, label, (single_param_option,), description=description, is_textarea=is_textarea)
+    
+    def get_entered_text(self, **kwargs) -> _TextValue:
+        """
+        Get the selected number
 
+        Returns:
+            A number parsable string of the selected number
+        """
+        return _TextValue(self._entered_text)
+        
     def to_json_dict0(self):
         """
         Converts this parameter as a JSON object for the parameters API response
@@ -761,7 +989,9 @@ class NumberRangeParameter(Parameter):
             A dictionary for the JSON object
         """
         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()
+        if self._curr_option is not None:
+            output['entered_text'] = self._entered_text
         return output
+    
+    def _get_response_model0(self):
+        return arm.TextParameterModel if self.is_enabled() else arm.ParameterModelBase