squirrels 0.4.0__py3-none-any.whl → 0.5.0rc0__py3-none-any.whl

squirrels/_package_loader.py

@@ -1,14 +1,18 @@
-import git, shutil, os, time
+import shutil, os, time
 
-from . import _constants as c, _utils as _u
+from . import _constants as c, _utils as u
 from ._manifest import ManifestConfig
 
 
 class PackageLoaderIO:
 
     @classmethod
-    def load_packages(cls, logger: _u.Logger, manifest_cfg: ManifestConfig, *, reload: bool = False) -> None:
+    def load_packages(cls, logger: u.Logger, manifest_cfg: ManifestConfig, *, reload: bool = False) -> None:
         start = time.time()
+        
+        # Importing git here avoids requirement of having git installed on system if not needed
+        import git
+
         # If reload, delete the modules directory (if it exists). It will be recreated later
         if reload and os.path.exists(c.PACKAGES_FOLDER):
             shutil.rmtree(c.PACKAGES_FOLDER)
@@ -20,6 +24,6 @@ class PackageLoaderIO:
                 try:
                     git.Repo.clone_from(repo.git, target_dir, branch=repo.revision, depth=1)
                 except git.GitCommandError as e:
-                    raise _u.ConfigurationError(f"Git clone of package failed for this repository: {repo.git}") from e
+                    raise u.ConfigurationError(f"Git clone of package failed for this repository: {repo.git}") from e
         
         logger.log_activity_time("loading packages", start)

squirrels/_parameter_configs.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Generic, TypeVar, Annotated, Type, Sequence, Iterator, Any
+from typing import Generic, TypeVar, Annotated, Sequence, Iterator, Any
 from typing_extensions import Self
 from datetime import datetime
 from dataclasses import dataclass, field
@@ -7,10 +7,11 @@ from abc import ABCMeta, abstractmethod
 from copy import copy
 from fastapi import Query
 from pydantic.fields import Field
-import pandas as pd, re
+import polars as pl, re
 
-from . import parameter_options as _po, parameters as p, data_sources as d, _utils as _u, _constants as c
-from .user_base import User
+from . import parameter_options as _po, parameters as p, data_sources as d, _utils as u, _constants as c
+from ._exceptions import InvalidInputError
+from ._auth import BaseUser
 from ._connection_set import ConnectionSet
 from ._seeds import Seeds
 
@@ -27,16 +28,17 @@ class APIParamFieldInfo:
     pattern: str | None = None
     min_length: int | None = None
     max_length: int | None = None
+    default: Any = None
     
     def as_query_info(self):
         query_info = Query(
             title=self.title, description=self.description, examples=self.examples, pattern=self.pattern,
             min_length=self.min_length, max_length=self.max_length
         )
-        return (self.name, Annotated[self.type, query_info], None)
+        return (self.name, Annotated[self.type, query_info], self.default)
     
     def as_body_info(self):
-        field_info = Field(None,
+        field_info = Field(self.default,
             title=self.title, description=self.description, examples=self.examples, pattern=self.pattern,
             min_length=self.min_length, max_length=self.max_length
         )
@@ -50,26 +52,14 @@ class ParameterConfigBase(metaclass=ABCMeta):
     """
     name: str
     label: str
-    description: str # = field(default="", kw_only=True)
-    user_attribute: str | None # = field(default=None, kw_only=True)
-    parent_name: str | None # = field(default=None, kw_only=True)
+    description: str = field(default="", kw_only=True)
+    user_attribute: str | None = field(default=None, kw_only=True)
+    parent_name: str | None = field(default=None, kw_only=True)
 
-    @abstractmethod
-    def __init__(
-        self, widget_type: str, name: str, label: str, *, description: str = "", user_attribute: str | None = None, 
-        parent_name: str | None = None
-    ) -> None:
-        self.widget_type = widget_type
-        self.name = name
-        self.label = label
-        self.description = description
-        self.user_attribute = user_attribute
-        self.parent_name = parent_name
-
-    def _get_user_group(self, user: User | None) -> Any:
+    def _get_user_group(self, user: BaseUser | None) -> Any:
         if self.user_attribute is not None:
             if user is None:
-                raise _u.ConfigurationError(f"Non-authenticated users (only allowed for public datasets) cannot use parameter " +
+                raise u.ConfigurationError(f"Public datasets (accessible without authentication) cannot use parameter " +
                                            f"'{self.name}' because 'user_attribute' is defined on this parameter.")
             return getattr(user, self.user_attribute)
         
@@ -92,7 +82,7 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
         self, name: str, label: str, all_options: Sequence[ParamOptionType | dict], *, description: str = "", 
         user_attribute: str | None = None, parent_name: str | None = None
     ) -> None:
-        super().__init__(self.widget_type(), name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
+        super().__init__(name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
         self._all_options = tuple(self._to_param_option(x) for x in all_options)
 
     def _to_param_option(self, option: ParamOptionType | dict) -> ParamOptionType:
@@ -117,18 +107,17 @@ class ParameterConfig(Generic[ParamOptionType], ParameterConfigBase):
     def DataSource(*args, **kwargs) -> d.DataSource:
         pass
     
-    def _invalid_input_error(self, selection: str, more_details: str = '') -> _u.InvalidInputError:
-        return _u.InvalidInputError(f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details)
+    def _invalid_input_error(self, selection: str, more_details: str = '') -> InvalidInputError:
+        return InvalidInputError(200, f'Selected value "{selection}" is not valid for parameter "{self.name}". ' + more_details)
     
     @abstractmethod
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None, 
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.Parameter:
         pass
     
     def _get_options_iterator(
-        self, all_options: Sequence[ParamOptionType], user: User | None, parent_param: p._SelectionParameter | None
+        self, all_options: Sequence[ParamOptionType], user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> Iterator[ParamOptionType]:
         user_group = self._get_user_group(user)
         selected_parent_option_ids = frozenset(parent_param._get_selected_ids_as_list()) if parent_param else None
@@ -164,7 +153,7 @@ class SelectionParameterConfig(ParameterConfig[_po.SelectParameterOption]):
         self.children[child.name] = child
         self.trigger_refresh = True
     
-    def _get_options(self, user: User | None, parent_param: p._SelectionParameter | None) -> Sequence[_po.SelectParameterOption]:
+    def _get_options(self, user: BaseUser | None, parent_param: p._SelectionParameter | None) -> Sequence[_po.SelectParameterOption]:
         return tuple(self._get_options_iterator(self.all_options, user, parent_param))
     
     def _get_default_ids_iterator(self, options: Sequence[_po.SelectParameterOption]) -> Iterator[str]:
@@ -200,8 +189,7 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.SingleSelectParameter:
         options = self._get_options(user, parent_param)
         if selection is None:
@@ -224,9 +212,9 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     """
     Class to define configurations for multi-select parameter widgets.
     """
-    show_select_all: 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)
+    show_select_all: 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[_po.SelectParameterOption | dict], *, description: str = "", 
@@ -249,14 +237,13 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
         return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.MultiSelectParameter:
         options = self._get_options(user, parent_param)
         if selection is None:
             selected_ids = tuple(self._get_default_ids_iterator(options))
         else:
-            selected_ids = _u.load_json_or_comma_delimited_str_as_list(selection)
+            selected_ids = u.load_json_or_comma_delimited_str_as_list(selection)
         return p.MultiSelectParameter(self, options, selected_ids)
     
     def get_api_field_info(self) -> APIParamFieldInfo:
@@ -306,8 +293,7 @@ class DateParameterConfig(_DateTypeParameterConfig[_po.DateParameterOption]):
         return d.DateDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.DateParameter:
         curr_option: _po.DateParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         selected_date = curr_option._default_date if selection is None and curr_option is not None else selection
@@ -316,7 +302,7 @@ class DateParameterConfig(_DateTypeParameterConfig[_po.DateParameterOption]):
     def get_api_field_info(self) -> APIParamFieldInfo:
         examples = [str(x._default_date) for x in self.all_options]
         return APIParamFieldInfo(
-            self.name, str, title=self.label, description=self.description, examples=examples, pattern=c.date_regex
+            self.name, str, title=self.label, description=self.description, examples=examples, pattern=c.DATE_REGEX
         )
 
 
@@ -346,8 +332,7 @@ class DateRangeParameterConfig(_DateTypeParameterConfig[_po.DateRangeParameterOp
         return d.DateRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.DateRangeParameter:
         curr_option: _po.DateRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
@@ -358,7 +343,7 @@ class DateRangeParameterConfig(_DateTypeParameterConfig[_po.DateRangeParameterOp
                 selected_start_date, selected_end_date = None, None
         else:
             try:
-                selected_start_date, selected_end_date = _u.load_json_or_comma_delimited_str_as_list(selection)
+                selected_start_date, selected_end_date = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError:
                 raise self._invalid_input_error(selection, "Date range parameter selection must be two dates.")
         return p.DateRangeParameter(self, curr_option, selected_start_date, selected_end_date)
@@ -410,8 +395,7 @@ class NumberParameterConfig(_NumericParameterConfig[_po.NumberParameterOption]):
         return d.NumberDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.NumberParameter:
         curr_option: _po.NumberParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         selected_value = curr_option._default_value if selection is None and curr_option is not None else selection
@@ -450,8 +434,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParamete
         return d.NumberRangeDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.NumberRangeParameter:
         curr_option: _po.NumberRangeParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         if selection is None:
@@ -462,7 +445,7 @@ class NumberRangeParameterConfig(_NumericParameterConfig[_po.NumberRangeParamete
                 selected_lower_value, selected_upper_value = None, None
         else:
             try:
-                selected_lower_value, selected_upper_value = _u.load_json_or_comma_delimited_str_as_list(selection)
+                selected_lower_value, selected_upper_value = u.load_json_or_comma_delimited_str_as_list(selection)
             except ValueError:
                 raise self._invalid_input_error(selection, "Number range parameter selection must be two numbers.")
         return p.NumberRangeParameter(self, curr_option, selected_lower_value, selected_upper_value)
@@ -490,7 +473,7 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
         
         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}.")
+            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:
@@ -499,9 +482,9 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
     def validate_entered_text(self, entered_text: str) -> str:
         if self.input_type == "number":
             try:
-                int(entered_text)
+                float(entered_text)
             except ValueError:
-                raise self._invalid_input_error(entered_text, "Must be an integer (without decimals)")
+                raise self._invalid_input_error(entered_text, "Must be a number")
         elif self.input_type == "date":
             try:
                 datetime.strptime(entered_text, "%Y-%m-%d")
@@ -523,7 +506,7 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
             except ValueError:
                 raise self._invalid_input_error(entered_text, "Must be a time in hh:mm format.")
         elif self.input_type == "color":
-            if not re.match(c.color_regex, entered_text):
+            if not re.match(c.COLOR_REGEX, entered_text):
                 raise self._invalid_input_error(entered_text, "Must be a valid color hex code (e.g. #000000).")
         
         return entered_text
@@ -541,8 +524,7 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
         return d.TextDataSource(*args, **kwargs)
     
     def with_selection(
-        self, selection: str | None, user: User | None, parent_param: p._SelectionParameter | None,
-        *, request_version: int | None = None
+        self, selection: str | None, user: BaseUser | None, parent_param: p._SelectionParameter | None
     ) -> p.TextParameter:
         curr_option: _po.TextParameterOption | None = next(self._get_options_iterator(self.all_options, user, parent_param), None)
         entered_text = curr_option._default_text if selection is None and curr_option is not None else selection
@@ -555,29 +537,27 @@ class TextParameterConfig(ParameterConfig[_po.TextParameterOption]):
         )
 
 
-@dataclass
-class DataSourceParameterConfig(ParameterConfigBase):
+ParamConfigType = TypeVar("ParamConfigType", bound=ParameterConfig)
+
+class DataSourceParameterConfig(Generic[ParamConfigType], ParameterConfigBase):
     """
     Class to define configurations for parameter widgets whose options come from lookup tables
     """
-    parameter_type: Type[ParameterConfig]
-    data_source: d.DataSource
-
     def __init__(
-        self, parameter_type: Type[ParameterConfig], name: str, label: str, data_source: d.DataSource | dict, *, 
+        self, parameter_type: type[ParamConfigType], 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:
-        super().__init__("data_source", name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
+        super().__init__(name, label, description=description, user_attribute=user_attribute, parent_name=parent_name)
         self.parameter_type = parameter_type
         if isinstance(data_source, dict):
             data_source = parameter_type.DataSource(**data_source)
         self.data_source = data_source
         self.extra_args = extra_args
 
-    def convert(self, df: pd.DataFrame) -> ParameterConfig:
+    def convert(self, df: pl.DataFrame) -> ParamConfigType:
         return self.data_source._convert(self, df)
     
-    def get_dataframe(self, default_conn_name: str, conn_set: ConnectionSet, seeds: Seeds) -> pd.DataFrame:
+    def get_dataframe(self, default_conn_name: str, conn_set: ConnectionSet, seeds: Seeds) -> pl.DataFrame:
         datasource = self.data_source
         query = datasource._get_query()
         if datasource._is_from_seeds:
@@ -587,5 +567,5 @@ class DataSourceParameterConfig(ParameterConfigBase):
                 conn_name = datasource._get_connection_name(default_conn_name)
                 df = conn_set.run_sql_query_from_conn_name(query, conn_name)
             except RuntimeError as e:
-                raise _u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}"') from e
+                raise u.ConfigurationError(f'Error executing query for datasource parameter "{self.name}"') from e
         return df

squirrels/_parameter_sets.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-from typing import Optional, Sequence
+from typing import Optional, Sequence, Any
 from dataclasses import dataclass, field
 from collections import OrderedDict
-import time, concurrent.futures, pandas as pd
+import time, concurrent.futures, polars as pl
 
 from . import _utils as u, _constants as c, parameters as p, _parameter_configs as _pc, _py_module as pm, _api_response_models as arm
 from .arguments.init_time_args import ParametersArgs
 from ._manifest import ParametersConfig, ManifestConfig
 from ._connection_set import ConnectionSet, ConnectionsArgs
 from ._seeds import Seeds
-from .user_base import User
+from ._auth import BaseUser
 
 
 @dataclass
@@ -51,7 +51,7 @@ class ParameterConfigsSet:
     def _get_all_ds_param_configs(self) -> Sequence[_pc.DataSourceParameterConfig]:
         return list(self._data_source_params.values())
 
-    def __convert_datasource_params(self, df_dict: dict[str, pd.DataFrame]) -> None:
+    def __convert_datasource_params(self, df_dict: dict[str, pl.DataFrame]) -> None:
         done = set()
         for curr_name in self._data_source_params:
             stack = [curr_name] # Note: parents must be converted first before children
@@ -98,19 +98,21 @@ class ParameterConfigsSet:
                 
                 parent._add_child_mutate(param_config)
     
-    def _post_process_params(self, df_dict: dict[str, pd.DataFrame]) -> None:
+    def _post_process_params(self, df_dict: dict[str, pl.DataFrame]) -> None:
         self.__convert_datasource_params(df_dict)
         self.__validate_param_relationships()
     
     def apply_selections(
-        self, dataset_params: Optional[Sequence[str]], selections: dict[str, str], user: Optional[User], 
-        *, updates_only: bool = False, request_version: Optional[int] = None
+        self, dataset_params: Optional[Sequence[str]], selections: dict[str, Any], user: BaseUser | None, *, parent_param: str | None = None
     ) -> ParameterSet:
         if dataset_params is None:
-            dataset_params = list(self._data.keys())
+            if user is None:
+                dataset_params = [k for k, v in self._data.items() if v.user_attribute is None]
+            else:
+                dataset_params = list(self._data.keys())
         
         parameters_by_name: dict[str, p.Parameter] = {}
-        params_to_process = selections.keys() if selections and updates_only else dataset_params
+        params_to_process = [parent_param] if parent_param else dataset_params
         params_to_process_set = set(params_to_process)
         for some_name in params_to_process:
             stack = [some_name] # Note: process parent selections first (if applicable) before children
@@ -154,8 +156,8 @@ class ParameterConfigsSetIO:
     obj: ParameterConfigsSet # this is static (set in load_from_file) to simplify development experience for pyconfigs/parameters.py
     
     @classmethod
-    def _get_df_dict_from_data_sources(cls, default_conn_name: str, seeds: Seeds, conn_set: ConnectionSet) -> dict[str, pd.DataFrame]:
-        def get_dataframe(ds_param_config: _pc.DataSourceParameterConfig) -> tuple[str, pd.DataFrame]:
+    def _get_df_dict_from_data_sources(cls, default_conn_name: str, seeds: Seeds, conn_set: ConnectionSet) -> dict[str, pl.DataFrame]:
+        def get_dataframe(ds_param_config: _pc.DataSourceParameterConfig) -> tuple[str, pl.DataFrame]:
             return ds_param_config.name, ds_param_config.get_dataframe(default_conn_name, conn_set, seeds)
         
         ds_param_configs = cls.obj._get_all_ds_param_configs()
@@ -172,7 +174,7 @@ class ParameterConfigsSetIO:
     
     @classmethod
     def get_param_args(cls, conn_args: ConnectionsArgs) -> ParametersArgs:
-        return ParametersArgs(conn_args.proj_vars, conn_args.env_vars)
+        return ParametersArgs(conn_args.project_path, conn_args.proj_vars, conn_args.env_vars)
     
     @classmethod
     def load_from_file(
@@ -186,7 +188,7 @@ class ParameterConfigsSetIO:
         
         pm.run_pyconfig_main(base_path, c.PARAMETERS_FILE, {"sqrl": param_args})
         
-        default_conn_name = manifest_cfg.settings_obj.get_default_connection_name()
+        default_conn_name = manifest_cfg.env_vars.get(c.SQRL_CONNECTIONS_DEFAULT_NAME_USED, "default")
         df_dict = cls._get_df_dict_from_data_sources(default_conn_name, seeds, conn_set)
         cls.obj._post_process_params(df_dict)