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

squirrels/_parameter_configs.py

@@ -1,12 +1,42 @@
 from __future__ import annotations
-from typing import Type, Optional, Union, Sequence, Iterator, Any
+from typing import Annotated, Type, Optional, Union, Sequence, Iterator, Any
 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
 
-from . import parameter_options as po, parameters as p, data_sources as d, _utils as u
+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
+from ._connection_set import ConnectionSet
+from ._seeds import Seeds
+
+
+@dataclass
+class APIParamFieldInfo:
+    name: str
+    type: type
+    title: str = ""
+    description: str = ""
+    examples: Optional[list[Any]] = None
+    pattern: Optional[str] = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = 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)
+    
+    def as_body_info(self):
+        field_info = Field(None,
+            title=self.title, description=self.description, examples=self.examples, pattern=self.pattern,
+            min_length=self.min_length, max_length=self.max_length
+        )
+        return (self.type, field_info)
 
 
 @dataclass
@@ -16,26 +46,26 @@ class ParameterConfigBase(metaclass=ABCMeta):
     """
     name: str
     label: str
-    is_hidden: bool # = field(default=False, kw_only=True)
+    description: str # = field(default="", kw_only=True)
     user_attribute: Optional[str] # = field(default=None, kw_only=True)
     parent_name: Optional[str] # = field(default=None, kw_only=True)
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, *, is_hidden: bool = False, user_attribute: Optional[str] = None, 
+        self, widget_type: str, name: str, label: str, *, description: str = "", user_attribute: Optional[str] = None, 
         parent_name: Optional[str] = None
     ) -> None:
         self.widget_type = widget_type
         self.name = name
         self.label = label
-        self.is_hidden = is_hidden
+        self.description = description
         self.user_attribute = user_attribute
         self.parent_name = parent_name
 
     def _get_user_group(self, user: Optional[User]) -> Any:
         if self.user_attribute is not None:
             if user is None:
-                raise u.ConfigurationError(f"Public datasets (which allows non-authenticated users) cannot use parameter " +
+                raise u.ConfigurationError(f"Non-authenticated users (only allowed for public datasets) cannot use parameter " +
                                            f"'{self.name}' because 'user_attribute' is defined on this parameter.")
             return getattr(user, self.user_attribute)
         
@@ -45,11 +75,9 @@ class ParameterConfigBase(metaclass=ABCMeta):
         """
         return copy(self)
 
-    def to_json_dict0(self) -> dict:
+    def to_json_dict0(self) -> arm.ParameterModelBase:
         return {
-            'widget_type': self.widget_type,
-            'name': self.name,
-            'label': self.label
+            "widget_type": self.widget_type, "name": self.name, "label": self.label, "description": self.description
         }
 
 
@@ -62,10 +90,10 @@ class ParameterConfig(ParameterConfigBase):
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, 
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__(widget_type, name, label, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__(widget_type, 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)
 
@@ -96,6 +124,10 @@ class ParameterConfig(ParameterConfigBase):
         user_group = self._get_user_group(user)
         selected_parent_option_ids = frozenset(parent_param._get_selected_ids_as_list()) if parent_param else None
         return (x for x in self.all_options if x._is_valid(user_group, selected_parent_option_ids))
+    
+    @abstractmethod
+    def get_api_field_info(self) -> APIParamFieldInfo:
+        pass
 
 
 @dataclass
@@ -103,15 +135,16 @@ class SelectionParameterConfig(ParameterConfig):
     """
     Abstract class for select parameter classes (single-select, multi-select, etc)
     """
+    all_options: Sequence[po.SelectParameterOption] = field(repr=False)
     children: dict[str, ParameterConfigBase] = field(default_factory=dict, init=False, repr=False)
     trigger_refresh: bool = field(default=False, init=False)
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__(widget_type, name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
         self.children: dict[str, ParameterConfigBase] = dict()
         self.trigger_refresh = False
@@ -151,15 +184,15 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
     """
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, is_hidden: bool = False, 
+        self, name: str, label: str, all_options: Sequence[Union[po.SelectParameterOption, dict]], *, description: str = "", 
         user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("single_select", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__("single_select", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
      
     @staticmethod
     def DataSource(*args, **kwargs):
-        return d.SingleSelectDataSource(*args, **kwargs)
+        return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
@@ -173,6 +206,12 @@ class SingleSelectParameterConfig(SelectionParameterConfig):
         else:
             selected_id = selection
         return p.SingleSelectParameter(self, options, selected_id)
+    
+    def get_api_field_info(self) -> APIParamFieldInfo:
+        examples = [x._identifier for x in self.all_options]
+        return APIParamFieldInfo(
+            self.name, str, title=self.label, description=self.description, examples=examples
+        )
 
 
 @dataclass
@@ -186,11 +225,11 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     none_is_all: bool # = field(default=True, kw_only=True)
 
     def __init__(
-        self, 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, 
+        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,
         user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("multi_select", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        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
@@ -199,7 +238,7 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
     
     @staticmethod
     def DataSource(*args, **kwargs):
-        return d.MultiSelectDataSource(*args, **kwargs)
+        return d.SelectDataSource(*args, **kwargs)
     
     def with_selection(
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
@@ -218,6 +257,12 @@ class MultiSelectParameterConfig(SelectionParameterConfig):
         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]
+        return APIParamFieldInfo(
+            self.name, list[str], title=self.label, description=self.description, examples=[identifiers]
+        )
 
 
 @dataclass
@@ -228,24 +273,25 @@ class _DateTypeParameterConfig(ParameterConfig):
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__(widget_type, name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
 
 @dataclass
 class DateParameterConfig(_DateTypeParameterConfig):
     """
-    Class to define configurations for single-select parameter widgets.
+    Class to define configurations for date parameter widgets.
     """
+    all_options: Sequence[po.DateParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.DateParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, name: str, label: str, all_options: Sequence[Union[po.DateParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("date", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__("date", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
     @staticmethod
@@ -260,22 +306,29 @@ class DateParameterConfig(_DateTypeParameterConfig):
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
         *, request_version: Optional[int] = None
     ) -> p.DateParameter:
-        curr_option: po.DateParameterOption = next(self._get_options_iterator(user, parent_param))
-        selected_date = curr_option._default_date if selection is None else selection
+        curr_option: po.DateParameterOption = next(self._get_options_iterator(user, parent_param), None)
+        selected_date = curr_option._default_date if selection is None and curr_option is not None else selection
         return p.DateParameter(self, curr_option, selected_date)
+    
+    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
+        )
 
 
 @dataclass
 class DateRangeParameterConfig(_DateTypeParameterConfig):
     """
-    Class to define configurations for single-select parameter widgets.
+    Class to define configurations for date range parameter widgets.
     """
+    all_options: Sequence[po.DateRangeParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.DateRangeParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, name: str, label: str, all_options: Sequence[Union[po.DateRangeParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("date_range", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__("date_range", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
     @staticmethod
@@ -290,16 +343,25 @@ class DateRangeParameterConfig(_DateTypeParameterConfig):
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
         *, request_version: Optional[int] = None
     ) -> p.DateParameter:
-        curr_option: po.DateRangeParameterOption = next(self._get_options_iterator(user, parent_param))
+        curr_option: po.DateRangeParameterOption = next(self._get_options_iterator(user, parent_param), None)
         if selection is None:
-            selected_start_date = curr_option._default_start_date
-            selected_end_date = curr_option._default_end_date
+            if curr_option is not None:
+                selected_start_date = curr_option._default_start_date
+                selected_end_date = curr_option._default_end_date
+            else:
+                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)
             except ValueError as e:
                 self._raise_invalid_input_error(selection, "Date range parameter selection must be two dates joined by comma.", e)
         return p.DateRangeParameter(self, curr_option, selected_start_date, selected_end_date)
+    
+    def get_api_field_info(self) -> APIParamFieldInfo:
+        examples = [[str(x._default_start_date), str(x._default_end_date)] for x in self.all_options]
+        return APIParamFieldInfo(
+            self.name, list[str], title=self.label, description=self.description, examples=examples, max_length=2
+        )
 
 
 @dataclass
@@ -310,24 +372,25 @@ class _NumericParameterConfig(ParameterConfig):
 
     @abstractmethod
     def __init__(
-        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, widget_type: str, name: str, label: str, all_options: Sequence[Union[po.ParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__(widget_type, name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__(widget_type, name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
 
 @dataclass
 class NumberParameterConfig(_NumericParameterConfig):
     """
-    Class to define configurations for single-select parameter widgets.
+    Class to define configurations for number parameter widgets.
     """
+    all_options: Sequence[po.NumberParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.NumberParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, name: str, label: str, all_options: Sequence[Union[po.NumberParameterOption, dict]], *,
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("number", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__("number", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
     @staticmethod
@@ -342,22 +405,29 @@ class NumberParameterConfig(_NumericParameterConfig):
         self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
         *, request_version: Optional[int] = None
     ) -> p.NumberParameter:
-        curr_option: po.NumberParameterOption = next(self._get_options_iterator(user, parent_param))
-        selected_value = curr_option._default_value if selection is None else selection
+        curr_option: po.NumberParameterOption = next(self._get_options_iterator(user, parent_param), None)
+        selected_value = curr_option._default_value if selection is None and curr_option is not None else selection
         return p.NumberParameter(self, curr_option, selected_value)
+    
+    def get_api_field_info(self) -> APIParamFieldInfo:
+        examples = [x._default_value for x in self.all_options]
+        return APIParamFieldInfo(
+            self.name, float, title=self.label, description=self.description, examples=examples
+        )
 
 
 @dataclass
 class NumberRangeParameterConfig(_NumericParameterConfig):
     """
-    Class to define configurations for single-select parameter widgets.
+    Class to define configurations for number range parameter widgets.
     """
+    all_options: Sequence[po.NumberRangeParameterOption] = field(repr=False)
     
     def __init__(
-        self, name: str, label: str, all_options: Sequence[Union[po.NumberRangeParameterOption, dict]], *, is_hidden: bool = False, 
-        user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        self, name: str, label: str, all_options: Sequence[Union[po.NumberRangeParameterOption, dict]], *, 
+        description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("number_range", name, label, all_options, is_hidden=is_hidden, user_attribute=user_attribute, 
+        super().__init__("number_range", name, label, all_options, description=description, user_attribute=user_attribute, 
                          parent_name=parent_name)
 
     @staticmethod
@@ -372,16 +442,70 @@ 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))
+        curr_option: po.NumberRangeParameterOption = next(self._get_options_iterator(user, parent_param), None)
         if selection is None:
-            selected_lower_value = curr_option._default_lower_value
-            selected_upper_value = curr_option._default_upper_value
+            if curr_option is not None:
+                selected_lower_value = curr_option._default_lower_value
+                selected_upper_value = curr_option._default_upper_value
+            else:
+                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)
             except ValueError as e:
                 self._raise_invalid_input_error(selection, "Number range parameter selection must be two numbers joined by comma.", e)
         return p.NumberRangeParameter(self, curr_option, selected_lower_value, selected_upper_value)
+    
+    def get_api_field_info(self) -> APIParamFieldInfo:
+        examples = [[x._default_lower_value, x._default_upper_value] for x in self.all_options]
+        return APIParamFieldInfo(
+            self.name, list[str], title=self.label, description=self.description, examples=examples, max_length=2
+        )
+
+
+@dataclass
+class TextParameterConfig(ParameterConfig):
+    """
+    Class to define configurations for text parameter widgets.
+    """
+    all_options: Sequence[po.TextParameterOption] = field(repr=False)
+    is_textarea: bool
+    
+    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
+    ) -> None:
+        super().__init__("text", name, label, all_options, description=description, user_attribute=user_attribute, 
+                         parent_name=parent_name)
+        self.is_textarea = is_textarea
+
+    @staticmethod
+    def ParameterOption(*args, **kwargs):
+        return po.TextParameterOption(*args, **kwargs)
+    
+    @staticmethod
+    def DataSource(*args, **kwargs):
+        return d.TextDataSource(*args, **kwargs)
+    
+    def with_selection(
+        self, selection: Optional[str], user: Optional[User], parent_param: Optional[p._SelectionParameter],
+        *, request_version: Optional[int] = None
+    ) -> p.TextParameter:
+        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]
+        return APIParamFieldInfo(
+            self.name, str, title=self.label, description=self.description, examples=examples
+        )
 
 
 @dataclass
@@ -394,13 +518,27 @@ class DataSourceParameterConfig(ParameterConfigBase):
 
     def __init__(
         self, parameter_type: Type[ParameterConfig], name: str, label: str, data_source: Union[d.DataSource, dict], *, 
-        is_hidden: bool = False, user_attribute: Optional[str] = None, parent_name: Optional[str] = None
+        extra_args: dict = {}, description: str = "", user_attribute: Optional[str] = None, parent_name: Optional[str] = None
     ) -> None:
-        super().__init__("data_source", name, label, is_hidden=is_hidden, user_attribute=user_attribute, parent_name=parent_name)
+        super().__init__("data_source", 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:
         return self.data_source._convert(self, df)
+    
+    def get_dataframe(self, conn_set: ConnectionSet, seeds: Seeds) -> pd.DataFrame:
+        datasource = self.data_source
+        query = datasource._get_query()
+        if datasource.is_from_seed():
+            df = seeds.run_query(query)
+        else:
+            try:
+                conn_name = datasource._get_connection_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
+        return df

squirrels/_parameter_sets.py

@@ -4,10 +4,11 @@ from dataclasses import dataclass, field
 from collections import OrderedDict
 import concurrent.futures, pandas as pd
 
-from . import _utils as u, _constants as c, parameters as p, _parameter_configs as pc, _py_module as pm
+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 ManifestIO, ParametersConfig
 from ._connection_set import ConnectionSetIO
+from ._seeds import SeedsIO
 from .user_base import User
 from ._timer import timer, time
 
@@ -22,12 +23,11 @@ class ParameterSet:
     def get_parameters_as_dict(self) -> dict[str, p.Parameter]:
         return self._parameters_dict.copy()
 
-    def to_json_dict0(self, *, debug: bool = False) -> dict:
+    def to_api_response_model0(self) -> arm.ParametersModel:
         parameters = []
         for x in self._parameters_dict.values():
-            if not x._config.is_hidden or debug:
-                parameters.append(x.to_json_dict0())
-        return {"parameters": parameters}
+            parameters.append(x._to_api_response_model0())
+        return arm.ParametersModel(parameters=parameters)
 
 
 @dataclass
@@ -130,12 +130,15 @@ class _ParameterConfigsSet:
                     param = param_conf.with_selection(selections.get(curr_name), user, parent)
                     parameters_by_name[curr_name] = param
                     if isinstance(param_conf, pc.SelectionParameterConfig):
-                        children = list(param_conf.children.keys())
+                        children = list(x for x in param_conf.children.keys() if x in dataset_params)
                 stack.pop()
                 stack.extend(children)
         
         ordered_parameters = OrderedDict((key, parameters_by_name[key]) for key in dataset_params if key in parameters_by_name)
         return ParameterSet(ordered_parameters)
+    
+    def get_all_api_field_info(self) -> dict[str, pc.APIParamFieldInfo]:
+        return {param: config.get_api_field_info() for param, config in self._data.items()}
 
 
 class ParameterConfigsSetIO:
@@ -146,19 +149,13 @@ class ParameterConfigsSetIO:
     obj: _ParameterConfigsSet
     
     @classmethod
-    def _GetDfDict(cls) -> dict[str, pd.DataFrame]:
-        def get_dataframe_from_query(ds_param_config: pc.DataSourceParameterConfig) -> pd.DataFrame:
-            key, datasource = ds_param_config.name, ds_param_config.data_source
-            try:
-                query, conn_name = datasource._get_query(), datasource._get_connection_name()
-                df = ConnectionSetIO.obj.run_sql_query_from_conn_name(query, conn_name)
-            except RuntimeError as e:
-                raise u.ConfigurationError(f'Error executing query for datasource parameter "{key}"') from e
-            return key, df
+    def _GetDfDictFromDataSources(cls) -> dict[str, pd.DataFrame]:
+        def get_dataframe(ds_param_config: pc.DataSourceParameterConfig) -> tuple[str, pd.DataFrame]:
+            return ds_param_config.name, ds_param_config.get_dataframe(ConnectionSetIO.obj, SeedsIO.obj)
         
         ds_param_configs = cls.obj._get_all_ds_param_configs()
         with concurrent.futures.ThreadPoolExecutor() as executor:
-            df_dict = dict(executor.map(get_dataframe_from_query, ds_param_configs))
+            df_dict = dict(executor.map(get_dataframe, ds_param_configs))
         
         return df_dict
     
@@ -180,7 +177,7 @@ class ParameterConfigsSetIO:
         cls.args = ParametersArgs(conn_args.proj_vars, conn_args.env_vars)
         pm.run_pyconfig_main(c.PARAMETERS_FILE, {"sqrl": cls.args})
         
-        df_dict = cls._GetDfDict()
+        df_dict = cls._GetDfDictFromDataSources()
         cls.obj._post_process_params(df_dict)
         
         timer.add_activity_time("loading parameters", start)

squirrels/_py_module.py

@@ -36,9 +36,7 @@ class PyModule:
         Returns:
             The attribute of the module
         """
-        func_or_class = default_attr
-        if self.module is not None and hasattr(self.module, attr_name):
-            func_or_class = getattr(self.module, attr_name)
+        func_or_class = getattr(self.module, attr_name, default_attr)
         if func_or_class is None and is_required:
             raise u.ConfigurationError(f"Module '{self.filepath}' missing required attribute '{attr_name}'")
         return func_or_class
@@ -52,7 +50,7 @@ def run_pyconfig_main(filename: str, kwargs: dict[str, Any] = {}) -> None:
         filename: The name of the file to run main function
         kwargs: Dictionary of the main function arguments
     """
-    filepath = u.join_paths(c.PYCONFIG_FOLDER, filename)
+    filepath = u.join_paths(c.PYCONFIGS_FOLDER, filename)
     module = PyModule(filepath)
     main_function = module.get_func_or_class(c.MAIN_FUNC, is_required=False)
     if main_function:

squirrels/_seeds.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+import os, glob, pandas as pd
+
+from ._timer import timer, time
+from ._manifest import ManifestIO
+from . import _utils as u, _constants as c
+
+
+@dataclass
+class Seeds:
+    _data: dict[str, pd.DataFrame]
+    
+    def run_query(self, sql_query: str) -> pd.DataFrame:
+        return u.run_sql_on_dataframes(sql_query, self._data)
+    
+    def get_dataframes(self) -> dict[str, pd.DataFrame]:
+        return self._data.copy()
+
+
+class SeedsIO:
+    obj: Seeds
+
+    @classmethod
+    def LoadFiles(cls) -> None:
+        start = time.time()
+        infer_schema: bool = ManifestIO.obj.settings.get(c.SEEDS_INFER_SCHEMA_SETTING, True)
+        na_values: list[str] = ManifestIO.obj.settings.get(c.SEEDS_NA_VALUES_SETTING, ["NA"])
+        csv_dtype = None if infer_schema else str
+        
+        seeds_dict = {}
+        csv_files = glob.glob(os.path.join(c.SEEDS_FOLDER, '**/*.csv'), recursive=True)
+        for csv_file in csv_files:
+            file_stem = os.path.splitext(os.path.basename(csv_file))[0]
+            df = pd.read_csv(csv_file, dtype=csv_dtype, keep_default_na=False, na_values=na_values)
+            seeds_dict[file_stem] = df
+        
+        cls.obj = Seeds(seeds_dict)
+        timer.add_activity_time("loading seed files", start)