squirrels 0.3.0__tar.gz → 0.3.2__tar.gz

{squirrels-0.3.0 → squirrels-0.3.2}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: squirrels
-Version: 0.3.0
+Version: 0.3.2
 Summary: Squirrels - API Framework for Data Analytics
 Home-page: https://squirrels-analytics.github.io
-License: MIT
+License: Apache-2.0
 Author: Tim Huang
 Author-email: tim.yuting@hotmail.com
 Requires-Python: >=3.9,<4.0
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

{squirrels-0.3.0 → squirrels-0.3.2}/pyproject.toml

@@ -1,8 +1,8 @@
 [tool.poetry]
 name = "squirrels"
-version = "0.3.0"
+version = "0.3.2"
 description = "Squirrels - API Framework for Data Analytics"
-license = "MIT"
+license = "Apache-2.0"
 authors = ["Tim Huang <tim.yuting@hotmail.com>"]
 readme = "README.md"
 homepage = "https://squirrels-analytics.github.io"

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.3.0'
+__version__ = '0.3.2'
 
 from .arguments.init_time_args import ConnectionsArgs, ParametersArgs
 from .arguments.run_time_args import AuthArgs, ContextArgs, ModelDepsArgs, ModelArgs

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_api_response_models.py

@@ -33,7 +33,6 @@ class SingleSelectParameterModel(SelectParameterModel):
 class MultiSelectParameterModel(SelectParameterModel):
     widget_type: Annotated[str, Field(examples=["multi_select"])]
     show_select_all: bool
-    is_dropdown: bool
     order_matters: bool
     selected_ids: list[str]
 
@@ -63,7 +62,7 @@ class NumberRangeParameterModel(NumericParameterModel):
 class TextParameterModel(ParameterModelBase):
     widget_type: Annotated[str, Field(examples=["text"])]
     entered_text: str
-    is_textarea: bool
+    input_type: str
 
 class ParametersModel(BaseModel):
     parameters: list[

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_api_server.py

@@ -81,19 +81,15 @@ class ApiServer:
             except u.InvalidInputError as exc:
                 traceback.print_exc()
                 return JSONResponse(status_code=status.HTTP_400_BAD_REQUEST, 
-                                    content={"message": f"Invalid user input: {str(exc)}"})
+                                    content={"message": str(exc), "blame": "API client"})
             except u.ConfigurationError as exc:
                 traceback.print_exc()
                 return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
-                                    content={"message": f"Squirrels configuration error: {str(exc)}"})
-            except NotImplementedError as exc:
-                traceback.print_exc()
-                return JSONResponse(status_code=status.HTTP_501_NOT_IMPLEMENTED, 
-                                    content={"message": f"Not implemented error: {str(exc)}"})
+                                    content={"message": f"An unexpected error occurred", "blame": "Squirrels project"})
             except Exception as exc:
                 traceback.print_exc()
                 return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
-                                    content={"message": f"Server error: {str(exc)}"})
+                                    content={"message": f"An unexpected error occurred", "blame": "Squirrels framework"})
 
         app.add_middleware(
             CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], 
@@ -266,6 +262,12 @@ class ApiServer:
             curr_parameters_path = parameters_path.format(dataset=dataset_normalized)
             curr_results_path = results_path.format(dataset=dataset_normalized)
 
+            for param in dataset_cfg.parameters:
+                if param not in param_fields:
+                    all_params = list(param_fields.keys())
+                    raise u.ConfigurationError(f"Dataset '{dataset_name}' use parameter '{param}' which doesn't exist. Available parameters are:"
+                                               f"\n  {all_params}")
+
             QueryModelGet = make_dataclass("QueryParams", [
                 param_fields[param].as_query_info() for param in dataset_cfg.parameters
             ])

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_authenticator.py

@@ -39,7 +39,7 @@ class Authenticator:
         try:
             real_user = get_user(self._get_auth_args(username, password)) if get_user is not None else None
         except Exception as e:
-            raise u.FileExecutionError(f'Failed to run "{c.GET_USER_FUNC}" in {c.AUTH_FILE}', e)
+            raise u.FileExecutionError(f'Failed to run "{c.GET_USER_FUNC}" in {c.AUTH_FILE}', e) from e
         
         if isinstance(real_user, User):
             return real_user
@@ -53,7 +53,7 @@ class Authenticator:
                 try:
                     return user_cls.Create(username, is_internal=is_internal, **fake_user)
                 except Exception as e:
-                    raise u.FileExecutionError(f'Failed to create user from User model in {c.AUTH_FILE}', e)
+                    raise u.FileExecutionError(f'Failed to create user from User model in {c.AUTH_FILE}', e) from e
         
         return None
     

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_connection_set.py

@@ -31,15 +31,19 @@ class ConnectionSet:
     
     def run_sql_query_from_conn_name(self, query: str, conn_name: str, placeholders: dict = {}) -> pd.DataFrame:
         engine = self._get_engine(conn_name)
-        df = pd.read_sql(query, engine, params=placeholders)
-        return df
+        try:
+            df = pd.read_sql(query, engine, params=placeholders)
+            return df
+        except Exception as e:
+            raise RuntimeError(e) from e
 
     def _dispose(self) -> None:
         """
         Disposes of all the engines in this ConnectionSet
         """
         for pool in self._engines.values():
-            pool.dispose()
+            if isinstance(pool, Engine):
+                pool.dispose()
 
 
 class ConnectionSetIO:

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_constants.py

@@ -79,13 +79,14 @@ ASSETS_FOLDER = 'assets'
 TEMPLATES_FOLDER = 'templates'
 
 ENVIRON_CONFIG_FILE = 'environcfg.yml'
+ENV_CONFIG_FILE = 'env.yml'
 MANIFEST_JINJA_FILE = 'squirrels.yml.j2'
 CONNECTIONS_YML_FILE = 'connections.yml'
 PARAMETERS_YML_FILE = 'parameters.yml'
 MANIFEST_FILE = 'squirrels.yml'
 LU_DATA_FILE = 'lu_data.xlsx'
 
-DATABASE_FOLDER = 'database'
+DATABASE_FOLDER = 'assets'
 PACKAGES_FOLDER = 'sqrl_packages'
 
 MODELS_FOLDER = 'models'

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_environcfg.py

@@ -5,7 +5,8 @@ import os, yaml
 from . import _constants as c, _utils as u
 from ._timer import timer, time
 
-_GLOBAL_SQUIRRELS_CFG_FILE = u.join_paths(os.path.expanduser('~'), '.squirrels', c.ENVIRON_CONFIG_FILE)
+_GLOBAL_SQUIRRELS_CFG_FILE1 = u.join_paths(os.path.expanduser('~'), '.squirrels', c.ENVIRON_CONFIG_FILE)
+_GLOBAL_SQUIRRELS_CFG_FILE2 = u.join_paths(os.path.expanduser('~'), '.squirrels', c.ENV_CONFIG_FILE)
 
 
 @dataclass
@@ -61,17 +62,20 @@ class EnvironConfigIO:
             except FileNotFoundError:
                 return {}
         
-        config1 = load_yaml(_GLOBAL_SQUIRRELS_CFG_FILE)
-        config2 = load_yaml(c.ENVIRON_CONFIG_FILE)
+        master_env_config1 = load_yaml(_GLOBAL_SQUIRRELS_CFG_FILE1)
+        master_env_config2 = load_yaml(_GLOBAL_SQUIRRELS_CFG_FILE2)
+        proj_env_config1 = load_yaml(c.ENVIRON_CONFIG_FILE)
+        proj_env_config2 = load_yaml(c.ENV_CONFIG_FILE)
 
-        for key in config2:
-            config1.setdefault(key, {})
-            config1[key].update(config2[key])
+        for project_config in [master_env_config2, proj_env_config1, proj_env_config2]:
+            for key in project_config:
+                master_env_config1.setdefault(key, {})
+                master_env_config1[key].update(project_config[key])
         
-        users = config1.get(c.USERS_KEY, {})
-        env_vars = config1.get(c.ENV_VARS_KEY, {})
-        credentials = config1.get(c.CREDENTIALS_KEY, {})
-        secrets = config1.get(c.SECRETS_KEY, {})
+        users = master_env_config1.get(c.USERS_KEY, {})
+        env_vars = master_env_config1.get(c.ENV_VARS_KEY, {})
+        credentials = master_env_config1.get(c.CREDENTIALS_KEY, {})
+        secrets = master_env_config1.get(c.SECRETS_KEY, {})
 
         cls.obj = _EnvironConfig(users, env_vars, credentials, secrets)
-        timer.add_activity_time(f"loading {c.ENVIRON_CONFIG_FILE} file", start)
+        timer.add_activity_time(f"loading {c.ENV_CONFIG_FILE} file", start)

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_initializer.py

@@ -72,7 +72,7 @@ class Initializer:
 
             remaining_questions = [
                 inquirer.Confirm(AUTH,
-                                 message=f"Do you want to add the '{c.AUTH_FILE}' file?" ,
+                                 message=f"Do you want to add the '{c.AUTH_FILE}' file to enable custom API authentication?" ,
                                  default=False),
                 inquirer.List(SAMPLE_DB, 
                               message="What sample sqlite database do you wish to use (if any)?",
@@ -154,7 +154,7 @@ class Initializer:
                 raise NotImplementedError(f"Format '{parameters_format}' not supported for configuring widget parameters")
             
             self._copy_pyconfig_file(c.CONTEXT_FILE)
-            self._copy_file(c.ENVIRON_CONFIG_FILE)
+            self._copy_file(c.ENV_CONFIG_FILE)
             self._copy_seed_file(c.CATEGORY_SEED_FILE)
             self._copy_seed_file(c.SUBCATEGORY_SEED_FILE)
 

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_manifest.py

@@ -149,7 +149,7 @@ class DatasetsConfig(ManifestComponentConfig):
     label: str
     model: str
     scope: DatasetScope
-    parameters: Optional[list[str]]
+    parameters: list[str]
     traits: dict
     default_test_set: Optional[str]
 
@@ -166,7 +166,7 @@ class DatasetsConfig(ManifestComponentConfig):
             scope_list = [scope.name.lower() for scope in DatasetScope]
             raise u.ConfigurationError(f'Scope not found for dataset "{name}". Scope must be one of {scope_list}') from e
         
-        parameters = kwargs.get(c.DATASET_PARAMETERS_KEY)
+        parameters = kwargs.get(c.DATASET_PARAMETERS_KEY, [])
         traits = kwargs.get(c.DATASET_TRAITS_KEY, {})
         default_test_set = kwargs.get(c.DATASET_DEFAULT_TEST_SET_KEY)
         return cls(name, label, model, scope, parameters, traits, default_test_set)

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_models.py

@@ -38,6 +38,24 @@ class _SqlModelConfig:
 
     ## Applicable for federated models
     materialized: Materialization
+    
+    def set_attribute(self, **kwargs) -> str:
+        connection_name = kwargs.get(c.DBVIEW_CONN_KEY)
+        if connection_name is not None: 
+            if not isinstance(connection_name, str):
+                raise u.ConfigurationError("The 'connection_name' argument of 'config' macro must be a string")
+            self.connection_name = connection_name
+        
+        materialized: str = kwargs.get(c.MATERIALIZED_KEY)
+        if materialized is not None:
+            if not isinstance(materialized, str):
+                raise u.ConfigurationError("The 'materialized' argument of 'config' macro must be a string")
+            try:
+                self.materialized = Materialization[materialized.upper()]
+            except KeyError as e:
+                valid_options = [x.name for x in Materialization]
+                raise u.ConfigurationError(f"The 'materialized' argument value '{materialized}' is not valid. Must be one of: {valid_options}") from e
+        return ""
 
     def get_sql_for_create(self, model_name: str, select_query: str) -> str:
         if self.materialized == Materialization.TABLE:
@@ -45,18 +63,9 @@ class _SqlModelConfig:
         elif self.materialized == Materialization.VIEW:
             create_prefix = f"CREATE VIEW {model_name} AS\n"
         else:
-            raise NotImplementedError(f"Materialization option not supported: {self.materialized}")
+            raise u.ConfigurationError(f"Materialization option not supported: {self.materialized}")
         
         return create_prefix + select_query
-    
-    def set_attribute(self, **kwargs) -> str:
-        connection_name = kwargs.get(c.DBVIEW_CONN_KEY)
-        materialized = kwargs.get(c.MATERIALIZED_KEY)
-        if isinstance(connection_name, str):
-            self.connection_name = connection_name
-        if isinstance(materialized, str):
-            self.materialized = Materialization[materialized.upper()]
-        return ""
 
 
 ContextFunc = Callable[[dict[str, Any], ContextArgs], None]
@@ -220,11 +229,11 @@ class _Model(_Referable):
         connection_name = self._get_dbview_conn_name()
         materialized = self._get_materialized()
         configuration = _SqlModelConfig(connection_name, materialized)
-        is_placeholder = lambda x: x in placeholders
+        is_placeholder = lambda placeholder: placeholder in placeholders
         kwargs = {
             "proj_vars": ctx_args.proj_vars, "env_vars": ctx_args.env_vars, "user": ctx_args.user, "prms": ctx_args.prms, 
             "traits": ctx_args.traits, "ctx": ctx, "is_placeholder": is_placeholder, "set_placeholder": ctx_args.set_placeholder,
-            "config": configuration.set_attribute, "is_param_enabled": ctx_args.param_exists
+            "config": configuration.set_attribute, "param_exists": ctx_args.param_exists
         }
         dependencies = set()
         if self.query_file.model_type == ModelType.FEDERATE:
@@ -236,7 +245,7 @@ class _Model(_Referable):
         try:
             query = await asyncio.to_thread(u.render_string, raw_query, **kwargs)
         except Exception as e:
-            raise u.FileExecutionError(f'Failed to compile sql model "{self.name}"', e)
+            raise u.FileExecutionError(f'Failed to compile sql model "{self.name}"', e) from e
         
         compiled_query = _SqlModelQuery(query, configuration)
         return compiled_query, dependencies
@@ -252,11 +261,11 @@ class _Model(_Referable):
         try:
             dependencies = await asyncio.to_thread(self.query_file.raw_query.dependencies_func, sqrl_args)
         except Exception as e:
-            raise u.FileExecutionError(f'Failed to run "{c.DEP_FUNC}" function for python model "{self.name}"', e)
+            raise u.FileExecutionError(f'Failed to run "{c.DEP_FUNC}" function for python model "{self.name}"', e) from e
         
         dbview_conn_name = self._get_dbview_conn_name()
         connections = ConnectionSetIO.obj.get_engines_as_dict()
-        ref = lambda x: self.upstreams[x].result
+        ref = lambda model: self.upstreams[model].result
         sqrl_args = ModelArgs(
             ctx_args.proj_vars, ctx_args.env_vars, ctx_args.user, ctx_args.prms, ctx_args.traits, placeholders, ctx, 
             dbview_conn_name, connections, dependencies, ref
@@ -267,7 +276,7 @@ class _Model(_Referable):
                 raw_query: _RawPyQuery = self.query_file.raw_query
                 return raw_query.query(sqrl=sqrl_args)
             except Exception as e:
-                raise u.FileExecutionError(f'Failed to run "{c.MAIN_FUNC}" function for python model "{self.name}"', e)
+                raise u.FileExecutionError(f'Failed to run "{c.MAIN_FUNC}" function for python model "{self.name}"', e) from e
         
         return _PyModelQuery(compiled_query), dependencies
 
@@ -286,7 +295,7 @@ class _Model(_Referable):
         elif self.query_file.query_type == QueryType.PYTHON:
             compiled_query, dependencies = await self._compile_python_model(ctx, ctx_args, placeholders)
         else:
-            raise NotImplementedError(f"Query type not supported: {self.query_file.query_type}")
+            raise u.ConfigurationError(f"Query type not supported: {self.query_file.query_type}")
         
         self.compiled_query = compiled_query
         self.wait_count = len(dependencies)
@@ -335,7 +344,7 @@ class _Model(_Referable):
                 try:
                     return ConnectionSetIO.obj.run_sql_query_from_conn_name(query, config.connection_name, placeholders)
                 except RuntimeError as e:
-                    raise u.FileExecutionError(f'Failed to run dbview sql model "{self.name}"', e)
+                    raise u.FileExecutionError(f'Failed to run dbview sql model "{self.name}"', e) from e
             
             df = await asyncio.to_thread(run_sql_query)
             await asyncio.to_thread(self._load_pandas_to_table, df, conn)
@@ -347,7 +356,7 @@ class _Model(_Referable):
                 try:
                     return conn.execute(text(create_query), placeholders)
                 except Exception as e:
-                    raise u.FileExecutionError(f'Failed to run federate sql model "{self.name}"', e)
+                    raise u.FileExecutionError(f'Failed to run federate sql model "{self.name}"', e) from e
             
             await asyncio.to_thread(create_table)
             if self.needs_pandas or self.is_target:
@@ -410,7 +419,7 @@ class _DAG:
         try:
             context_func(ctx=context, sqrl=args)
         except Exception as e:
-            raise u.FileExecutionError(f'Failed to run {c.CONTEXT_FILE} for dataset "{self.dataset.name}"', e)
+            raise u.FileExecutionError(f'Failed to run {c.CONTEXT_FILE} for dataset "{self.dataset.name}"', e) from e
         timer.add_activity_time(f"running context.py for dataset '{self.dataset.name}'", start)
         return context, args
     
@@ -496,7 +505,7 @@ class ModelsIO:
                 if extension == '.py':
                     query_type = QueryType.PYTHON
                     module = pm.PyModule(filepath)
-                    dependencies_func = module.get_func_or_class(c.DEP_FUNC, default_attr=lambda x: [])
+                    dependencies_func = module.get_func_or_class(c.DEP_FUNC, default_attr=lambda sqrl: [])
                     raw_query = _RawPyQuery(module.get_func_or_class(c.MAIN_FUNC), dependencies_func)
                 elif extension == '.sql':
                     query_type = QueryType.SQL
@@ -520,7 +529,7 @@ class ModelsIO:
         populate_raw_queries_for_type(federates_path, ModelType.FEDERATE)
 
         context_path = u.join_paths(c.PYCONFIGS_FOLDER, c.CONTEXT_FILE)
-        cls.context_func = pm.PyModule(context_path).get_func_or_class(c.MAIN_FUNC, default_attr=lambda x, y: None)
+        cls.context_func = pm.PyModule(context_path).get_func_or_class(c.MAIN_FUNC, default_attr=lambda ctx, sqrl: None)
         
         timer.add_activity_time("loading files for models and context.py", start)
 
@@ -572,11 +581,11 @@ class ModelsIO:
         elif test_set in ManifestIO.obj.selection_test_sets:
             test_set_conf = ManifestIO.obj.selection_test_sets[test_set]
         else:
-            raise u.InvalidInputError(f"No test set named '{test_set}' was found when compiling dataset '{dataset}'. The test set must be defined if not default for dataset.")
+            raise u.ConfigurationError(f"No test set named '{test_set}' was found when compiling dataset '{dataset}'. The test set must be defined if not default for dataset.")
         
         error_msg_intro = f"Cannot compile dataset '{dataset}' with test set '{test_set}'."
         if test_set_conf.datasets is not None and dataset not in test_set_conf.datasets:
-            raise u.InvalidInputError(f"{error_msg_intro}\n Applicable datasets for test set '{test_set}' does not include dataset '{dataset}'.")
+            raise u.ConfigurationError(f"{error_msg_intro}\n Applicable datasets for test set '{test_set}' does not include dataset '{dataset}'.")
         
         user_attributes = test_set_conf.user_attributes.copy()
         selections = test_set_conf.parameters.copy()

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_parameter_configs.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 from typing import Annotated, Type, Optional, Union, Sequence, Iterator, Any
+from datetime import datetime
 from dataclasses import dataclass, field
 from abc import ABCMeta, abstractmethod
 from copy import copy
 from fastapi import Query
 from pydantic.fields import Field, FieldInfo
-import pandas as pd
+import pandas as pd, re
 
 from . import parameter_options as po, parameters as p, data_sources as d, _api_response_models as arm, _utils as u, _constants as c
 from .user_base import User
@@ -75,11 +76,6 @@ class ParameterConfigBase(metaclass=ABCMeta):
         """
         return copy(self)
 
-    def to_json_dict0(self) -> arm.ParameterModelBase:
-        return {
-            "widget_type": self.widget_type, "name": self.name, "label": self.label, "description": self.description
-        }
-
 
 @dataclass
 class ParameterConfig(ParameterConfigBase):
@@ -171,11 +167,6 @@ class SelectionParameterConfig(ParameterConfig):
         other.children = self.children.copy()
         return other
 
-    def to_json_dict0(self) -> dict:
-        output = super().to_json_dict0()
-        output['trigger_refresh'] = self.trigger_refresh
-        return output
-
 
 @dataclass
 class SingleSelectParameterConfig(SelectionParameterConfig):
@@ -220,19 +211,17 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     Class to define configurations for multi-select parameter widgets.
     """
     show_select_all: bool # = field(default=True, kw_only=True)
-    is_dropdown: bool # = field(default=True, kw_only=True)
     order_matters: bool # = field(default=False, kw_only=True)
     none_is_all: bool # = field(default=True, kw_only=True)
 
     def __init__(
         self, 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,
+        show_select_all: bool = True, order_matters: bool = False, none_is_all: bool = True,
         user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
         super().__init__("multi_select", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
         self.show_select_all = show_select_all
-        self.is_dropdown = is_dropdown
         self.order_matters = order_matters
         self.none_is_all = none_is_all
     
@@ -250,13 +239,6 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
         else:
             selected_ids = u.load_json_or_comma_delimited_str_as_list(selection)
         return p.MultiSelectParameter(self, options, selected_ids)
-
-    def to_json_dict0(self) -> dict:
-        output = super().to_json_dict0()
-        output['show_select_all'] = self.show_select_all
-        output['is_dropdown'] = self.is_dropdown
-        output['order_matters'] = self.order_matters
-        return output
     
     def get_api_field_info(self) -> APIParamFieldInfo:
         identifiers = [x._identifier for x in self.all_options]
@@ -354,7 +336,7 @@ class DateRangeParameterConfig(_DateTypeParameterConfig):
             try:
                 selected_start_date, selected_end_date = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError as e:
-                self._raise_invalid_input_error(selection, "Date range parameter selection must be two dates joined by comma.", e)
+                self._raise_invalid_input_error(selection, "Date range parameter selection must be two dates.", e)
         return p.DateRangeParameter(self, curr_option, selected_start_date, selected_end_date)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -442,7 +424,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig):
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
         *, request_version: Optional[int] = None
     ) -> p.NumberRangeParameter:
-        curr_option: po.NumberRangeParameterOption = next(self._get_options_iterator(user, parent_param), None)
+        curr_option: Optional[po.NumberRangeParameterOption] = next(self._get_options_iterator(user, parent_param), None)
         if selection is None:
             if curr_option is not None:
                 selected_lower_value = curr_option._default_lower_value
@@ -453,7 +435,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig):
             try:
                 selected_lower_value, selected_upper_value = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError as e:
-                self._raise_invalid_input_error(selection, "Number range parameter selection must be two numbers joined by comma.", e)
+                self._raise_invalid_input_error(selection, "Number range parameter selection must be two numbers.", e)
         return p.NumberRangeParameter(self, curr_option, selected_lower_value, selected_upper_value)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -469,16 +451,54 @@ class TextParameterConfig(ParameterConfig):
     Class to define configurations for text parameter widgets.
     """
     all_options: Sequence[po.TextParameterOption] = field(repr=False)
-    is_textarea: bool
+    input_type: str
     
     def __init__(
-        self, 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
+        self, 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
     ) -> None:
         super().__init__("text", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
-        self.is_textarea = is_textarea
+        
+        allowed_input_types = ["text", "textarea", "number", "date", "datetime-local", "month", "time", "color", "password"]
+        if input_type not in allowed_input_types:
+            raise u.ConfigurationError(f"Invalid input type '{input_type}' for text parameter '{name}'. Must be one of {allowed_input_types}.")
+
+        self.input_type = input_type
+        for option in self.all_options:
+            self.validate_entered_text(option._default_text)
+    
+    def validate_entered_text(self, entered_text: str) -> str:
+        if self.input_type == "number":
+            try:
+                int(entered_text)
+            except ValueError as e:
+                raise self._raise_invalid_input_error(entered_text, "Must be an integer (without decimals).", e)
+        elif self.input_type == "date":
+            try:
+                datetime.strptime(entered_text, "%Y-%m-%d")
+            except ValueError as e:
+                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM-DD format.", e)
+        elif self.input_type == "datetime-local":
+            try:
+                datetime.strptime(entered_text, "%Y-%m-%dT%H:%M")
+            except ValueError as e:
+                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM-DDThh:mm format (e.g. 2020-01-01T07:00).", e)
+        elif self.input_type == "month":
+            try:
+                datetime.strptime(entered_text, "%Y-%m")
+            except ValueError as e:
+                raise self._raise_invalid_input_error(entered_text, "Must be a date in YYYY-MM format.", e)
+        elif self.input_type == "time":
+            try:
+                datetime.strptime(entered_text, "%H:%M")
+            except ValueError as e:
+                raise self._raise_invalid_input_error(entered_text, "Must be a time in hh:mm format.", e)
+        elif self.input_type == "color":
+            if not re.match(r"^#[0-9a-fA-F]{6}$", entered_text):
+                raise self._raise_invalid_input_error(entered_text, "Must be a valid color hex code (e.g. #000000).")
+        
+        return entered_text
 
     @staticmethod
     def ParameterOption(*args, **kwargs):
@@ -495,11 +515,6 @@ class TextParameterConfig(ParameterConfig):
         curr_option: po.TextParameterOption = next(self._get_options_iterator(user, parent_param), None)
         entered_text = curr_option._default_text if selection is None and curr_option is not None else selection
         return p.TextParameter(self, curr_option, entered_text)
-
-    def to_json_dict0(self) -> dict:
-        output = super().to_json_dict0()
-        output['is_textarea'] = self.is_textarea
-        return output
     
     def get_api_field_info(self) -> APIParamFieldInfo:
         examples = [x._default_text for x in self.all_options]

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/_py_module.py

@@ -57,4 +57,4 @@ def run_pyconfig_main(filename: str, kwargs: dict[str, Any] = {}) -> None:
         try:
             main_function(**kwargs)
         except Exception as e:
-            raise u.FileExecutionError(f'Failed to run python file "{filepath}"', e)
+            raise u.FileExecutionError(f'Failed to run python file "{filepath}"', e) from e

{squirrels-0.3.0 → squirrels-0.3.2}/squirrels/arguments/run_time_args.py

@@ -5,7 +5,7 @@ import pandas as pd
 
 from .init_time_args import ConnectionsArgs, ParametersArgs
 from ..user_base import User
-from ..parameters import Parameter, _TextValue
+from ..parameters import Parameter, TextValue
 from .._connection_set import ConnectionSetIO
 from .. import _utils as u
 
@@ -24,7 +24,7 @@ class ContextArgs(ParametersArgs):
     traits: dict[str, Any]
     _placeholders: dict[str, Any]
 
-    def set_placeholder(self, placeholder: str, value: Union[_TextValue, Any]) -> None:
+    def set_placeholder(self, placeholder: str, value: Union[TextValue, Any]) -> str:
         """
         Method to set a placeholder value.
 
@@ -32,9 +32,10 @@ class ContextArgs(ParametersArgs):
             placeholder: A string for the name of the placeholder
             value: The value of the placeholder. Can be of any type
         """
-        if isinstance(value, _TextValue):
+        if isinstance(value, TextValue):
             value = value._value_do_not_touch
         self._placeholders[placeholder] = value
+        return ""
     
     def param_exists(self, param_name: str) -> bool:
         """