squirrels 0.1.0__py3-none-any.whl → 0.6.0.post0__py3-none-any.whl

squirrels/_version.py

@@ -1,3 +1 @@
-__version__ = '0.1.0'
-
-major_version, minor_version, patch_version = __version__.split('.')
+__version__ = '0.6.0'

squirrels/arguments.py

@@ -0,0 +1,7 @@
+from ._arguments.init_time_args import ConnectionsArgs, AuthProviderArgs, ParametersArgs, BuildModelArgs
+from ._arguments.run_time_args import ContextArgs, ModelArgs, DashboardArgs
+
+__all__ = [
+    "ConnectionsArgs", "AuthProviderArgs", "ParametersArgs", "BuildModelArgs", 
+    "ContextArgs", "ModelArgs", "DashboardArgs"
+]

squirrels/auth.py

@@ -0,0 +1,4 @@
+from ._schemas.auth_models import CustomUserFields, RegisteredUser
+from ._auth import ProviderConfigs, provider
+
+__all__ = ["CustomUserFields", "RegisteredUser", "ProviderConfigs", "provider"]

squirrels/connections.py

@@ -0,0 +1,3 @@
+from ._manifest import ConnectionProperties, ConnectionTypeEnum
+
+__all__ = ["ConnectionProperties", "ConnectionTypeEnum"]

squirrels/dashboards.py

@@ -0,0 +1,3 @@
+from ._dashboards import PngDashboard, HtmlDashboard
+
+__all__ = ["PngDashboard", "HtmlDashboard"]

squirrels/data_sources.py

@@ -1,282 +1,14 @@
-from __future__ import annotations
-from typing import Type, Tuple, List, Optional
-from dataclasses import dataclass
-
-from squirrels import parameters as p, parameter_options as po
-from squirrels._timed_imports import pandas as pd
-from squirrels import _constants as c, _utils
-
-
-@dataclass
-class DataSource:
-    """
-    Abstract class for lookup tables coming from a database
-    """
-    table_or_query: str
-    
-    def __post_init__(self) -> None:
-        if not hasattr(self, 'parent_id_col'):
-            self.parent_id_col = None
-        if not hasattr(self, 'connection_name'):
-            self.connection_name = c.DEFAULT_DB_CONN
-
-    def get_query(self) -> str:
-        """
-        Get the "table_or_query" attribute as a select query
-
-        Returns:
-            str: The converted select query
-        """
-        if self.table_or_query.lower().startswith('select '):
-            query = self.table_or_query
-        else:
-            query = f'SELECT * FROM {self.table_or_query}'
-        return query
-    
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.Parameter:
-        """
-        An abstract method for converting itself into a parameter
-
-        Args:
-            ds_param: The parameter to convert
-            df: The dataframe containing the parameter options data
-
-        Returns:
-            The converted parameter
-        """
-        raise _utils.AbstractMethodCallError(self.__class__, "convert")
-    
-    def _get_parent(self, row):
-        return str(_utils.get_row_value(row, self.parent_id_col)) if self.parent_id_col is not None else None
-    
-    def _validate_parameter_class(self, ds_param: p.DataSourceParameter, parameter_classes: List[Type[p.Parameter]]) -> None:
-        if ds_param.parameter_class not in parameter_classes:
-            parameter_class_name = ds_param.parameter_class.__name__
-            datasource_class_name = self.__class__.__name__
-            raise _utils.ConfigurationError(f'Invalid widget type "{parameter_class_name}" for {datasource_class_name}')
-
-
-@dataclass
-class SelectionDataSource(DataSource):
-    """
-    Lookup table for selection parameters (single and multi)
-
-    Attributes:
-        connection_name: Name of the connection to use defined in connections.py
-        table_or_query: Either the name of the table to use, or a query to run
-        id_col: The column name of the id
-        options_col: The column name of the options
-        order_by_col: The column name to order the options by. Orders by the id_col instead if this is None
-        is_default_col: The column name that indicates which options are the default
-        parent_id_col: The column name of the parent option id that this option belongs to
-    """
-    id_col: str
-    options_col: str
-    order_by_col: Optional[str] = None
-    is_default_col: Optional[str] = None
-    parent_id_col: Optional[str] = None
-    connection_name: str = c.DEFAULT_DB_CONN
-
-    def __post_init__(self):
-        self.order_by_col = self.order_by_col if self.order_by_col is not None else self.id_col
-
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.Parameter:
-        """
-        Method to convert the associated DataSourceParameter into a SingleSelect or MultiSelect Parameter
-
-        Parameters:
-            ds_param: The parameter to convert
-            df: The dataframe containing the parameter options data
-
-        Returns:
-            The converted parameter
-        """
-        self._validate_parameter_class(ds_param, [p.SingleSelectParameter, p.MultiSelectParameter])
-
-        def is_default(row):
-            return int(_utils.get_row_value(row, self.is_default_col)) == 1 if self.is_default_col is not None else False
-        
-        try:
-            df.sort_values(self.order_by_col, inplace=True)
-        except KeyError as e:
-            raise _utils.ConfigurationError(f'Could not sort on column name "{self.order_by_col}" as it does not exist')
-        
-        options = tuple(
-            po.SelectParameterOption(str(_utils.get_row_value(row, self.id_col)), str(_utils.get_row_value(row, self.options_col)), is_default(row), 
-                                     parent_option_id=self._get_parent(row))
-            for _, row in df.iterrows()
-        )
-        
-        return ds_param.parameter_class(ds_param.name, ds_param.label, options, is_hidden=ds_param.is_hidden, parent=ds_param.parent)
-
-
-@dataclass
-class DateDataSource(DataSource):
-    """
-    Lookup table for date parameter default options
-
-    Attributes:
-        connection_name: Name of the connection to use defined in connections.py
-        table_or_query: Either the name of the table to use, or a query to run
-        default_date_col: The column name of the default date
-        date_format: The format of the default date(s). Defaults to '%Y-%m-%d'
-        parent_id_col: The column name of the parent option id that the default date belongs to
-    """
-    default_date_col: str
-    parent_id_col: Optional[str] = None
-    date_format: Optional[str] = '%Y-%m-%d'
-    connection_name: str = c.DEFAULT_DB_CONN
-
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.DateParameter:
-        """
-        Method to convert the associated DataSourceParameter into a DateParameter
-
-        Parameters:
-            ds_param: The parameter to convert
-            df: The dataframe containing the parameter options data
-
-        Returns:
-            The converted parameter
-        """
-        self._validate_parameter_class(ds_param, [p.DateParameter])
-        
-        def get_date(row: pd.Series) -> str:
-            return str(_utils.get_row_value(row, self.default_date_col))
-        
-        def create_date_param_option(row: pd.Series) -> po.DateParameterOption:
-            return po.DateParameterOption(get_date(row), self.date_format, self._get_parent(row))
-        
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            return p.DateParameter(ds_param.name, ds_param.label, get_date(row), self.date_format, 
-                                   is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(create_date_param_option(row) for _, row in df.iterrows())
-            return p.DateParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                              is_hidden=ds_param.is_hidden)
-
-
-@dataclass
-class _NumericDataSource(DataSource):
-    """
-    Abstract class for number or number range data sources
-    """
-    min_value_col: str
-    max_value_col: str
-    increment_col: Optional[str] = None
-
-    def _convert_helper(self, row: pd.Series) -> Tuple[str, str, str]:
-        min_val = str(_utils.get_row_value(row, self.min_value_col))
-        max_val = str(_utils.get_row_value(row, self.max_value_col))
-        incr_val = str(_utils.get_row_value(row, self.increment_col)) if self.increment_col is not None else '1'
-        return min_val, max_val, incr_val
-
-@dataclass
-class NumberDataSource(_NumericDataSource):
-    """
-    Lookup table for number parameter default options
-
-    Attributes:
-        connection_name: Name of the connection to use defined in connections.py
-        table_or_query: Either the name of the table to use, or a query to run
-        min_value_col: The column name of the minimum value
-        max_value_col: The column name of the maximum value
-        increment_col: The column name of the increment value. Defaults to column of 1's if None
-        default_value_col: The column name of the default value. Defaults to min_value_col if None
-        parent_id_col: The column name of the parent option id that the default value belongs to
-    """
-    default_value_col: Optional[str] = None
-    parent_id_col: Optional[str] = None
-    connection_name: str = c.DEFAULT_DB_CONN
-
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.NumberParameter:
-        """
-        Method to convert the associated DataSourceParameter into a NumberParameter
-
-        Parameters:
-            ds_param: The parameter to convert
-            df: The dataframe containing the parameter options data
-
-        Returns:
-            The converted parameter
-        """
-        self._validate_parameter_class(ds_param, [p.NumberParameter])
-
-        def _get_default_value(row: pd.Series) -> str:
-            return str(_utils.get_row_value(row, self.default_value_col)) if self.default_value_col is not None \
-                else str(_utils.get_row_value(row, self.min_value_col))
-        
-        def _create_num_param_option(row: pd.Series) -> po.NumberParameterOption:
-            min_value, max_value, increment = self._convert_helper(row)
-            return po.NumberParameterOption(min_value, max_value, increment, _get_default_value(row), 
-                                            self._get_parent(row))
-
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            min_value, max_value, increment = self._convert_helper(row)
-            return p.NumberParameter(ds_param.name, ds_param.label, min_value, max_value, increment, 
-                                     _get_default_value(row), is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(_create_num_param_option(row) for _, row in df.iterrows())
-            return p.NumberParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                                is_hidden=ds_param.is_hidden)
-
-
-@dataclass
-class NumRangeDataSource(_NumericDataSource):
-    """
-    Lookup table for number range parameter default options
-
-    Attributes:
-        connection_name: Name of the connection to use defined in connections.py
-        table_or_query: Either the name of the table to use, or a query to run
-        min_value_col: The column name of the minimum value
-        max_value_col: The column name of the maximum value
-        increment_col: The column name of the increment value. Defaults to column of 1's if None
-        default_lower_value_col: The column name of the default lower value. Defaults to min_value_col if None
-        default_upper_value_col: The column name of the default upper value. Defaults to max_value_col if None
-        parent_id_col: The column name of the parent option id that the default value belongs to
-    """
-    default_lower_value_col: Optional[str] = None
-    default_upper_value_col: Optional[str] = None
-    parent_id_col: Optional[str] = None
-    connection_name: str = c.DEFAULT_DB_CONN
-
-    def convert(self, ds_param: p.DataSourceParameter, df: pd.DataFrame) -> p.NumRangeParameter:
-        """
-        Method to convert the associated DataSourceParameter into a NumRangeParameter
-
-        Parameters:
-            ds_param: The parameter to convert
-            df: The dataframe containing the parameter options data
-
-        Returns:
-            The converted parameter
-        """
-        self._validate_parameter_class(ds_param, [p.NumRangeParameter])
-
-        def _get_default_lower_upper_values(row: pd.Series) -> Tuple[str, str]:
-            lower_value_col = self.default_lower_value_col if self.default_lower_value_col is not None \
-                else self.min_value_col
-            upper_value_col = self.default_upper_value_col if self.default_upper_value_col is not None \
-                else self.max_value_col
-            lower_value = str(_utils.get_row_value(row, lower_value_col))
-            upper_value = str(_utils.get_row_value(row, upper_value_col))
-            return lower_value, upper_value
-        
-        def _create_range_param_option(row: pd.Series) -> po.NumRangeParameterOption:
-            min_value, max_value, increment = self._convert_helper(row)
-            lower_value, upper_value = _get_default_lower_upper_values(row)
-            return po.NumRangeParameterOption(min_value, max_value, increment, lower_value, upper_value, 
-                                           self._get_parent(row)) 
-
-        if ds_param.parent is None:
-            row = df.iloc[0]
-            min_value, max_value, increment = self._convert_helper(row)
-            lower_value, upper_value = _get_default_lower_upper_values(row)
-            return p.NumRangeParameter(ds_param.name, ds_param.label, min_value, max_value, increment, 
-                                    lower_value, upper_value, is_hidden=ds_param.is_hidden)
-        else:
-            all_options = tuple(_create_range_param_option(row) for _, row in df.iterrows())
-            return p.NumRangeParameter.WithParent(ds_param.name, ds_param.label, all_options, ds_param.parent,
-                                                  is_hidden=ds_param.is_hidden)
+from ._data_sources import (
+    SourceEnum,
+    SelectDataSource, 
+    DateDataSource, 
+    DateRangeDataSource,
+    NumberDataSource, 
+    NumberRangeDataSource, 
+    TextDataSource
+)
+
+__all__ = [
+    "SourceEnum", "SelectDataSource", "DateDataSource", "DateRangeDataSource", 
+    "NumberDataSource", "NumberRangeDataSource", "TextDataSource"
+]

squirrels/parameter_options.py

@@ -1,189 +1,13 @@
-from typing import Iterable, Optional, Union
-from dataclasses import dataclass, field
-from decimal import Decimal, InvalidOperation as InvalidDecimalConversion
-from datetime import datetime
-
-from squirrels._utils import ConfigurationError
-
-Number = Union[Decimal, int, str]
-
-
-@dataclass
-class ParameterOption:
-    """
-    Abstract class (or type) for parameter options
-    """
-    def __post_init__(self) -> None:
-        if not hasattr(self, "parent_option_ids"):
-            self.parent_option_ids = frozenset()
-        
-        self.parent_option_ids = frozenset(
-            {self.parent_option_id} \
-            if hasattr(self, "parent_option_id") and self.parent_option_id is not None \
-            else self.parent_option_ids
-        )
-
-    def is_valid(self, selected_parent_option_ids: Optional[Iterable[str]] = None):
-        """
-        Checks if this option is valid given the selected parent options.
-        
-        Parameters:
-            selected_parent_option_ids: List of selected option ids from the parent parameter
-        
-        Returns:
-            True if valid, False otherwise
-        """
-        if selected_parent_option_ids is not None:
-            return not self.parent_option_ids.isdisjoint(selected_parent_option_ids)
-        else:
-            return True
-
-
-@dataclass
-class SelectParameterOption(ParameterOption):
-    """
-    Parameter option for a select parameter
-
-    Attributes:
-        identifier: Unique identifier for this option that never changes over time
-        label: Human readable label that gets shown as a dropdown option
-        is_default: True if this is a default option, False otherwise
-        parent_option_id: Identifier of the parent option, or None if this is a top-level option
-        parent_option_ids: Set of parent option ids (only used if parent_option_id is None), or an empty set if this is a top-level option
-    """
-    identifier: str
-    label: str
-    is_default: bool = False
-    parent_option_id: Optional[str] = field(default=None, repr=False)
-    parent_option_ids: Iterable[str] = frozenset()
-
-    def to_dict(self):
-        return {'id': self.identifier, 'label': self.label}
-
-
-@dataclass
-class DateParameterOption(ParameterOption):
-    """
-    Parameter option for default dates if it varies based on selection of another parameter
-
-    Attributes:
-        default_date: Default date for this option
-        date_format: Format of the default date, default is '%Y-%m-%d'
-        parent_option_id: Identifier of the parent option, or None if this is a top-level option
-        parent_option_ids: Set of parent option ids (only used if parent_option_id is None), or an empty set if this is a top-level option
-    """
-    default_date: Union[str, datetime]
-    date_format: str = '%Y-%m-%d'
-    parent_option_id: Optional[str] = field(default=None, repr=False)
-    parent_option_ids: Iterable[str] = frozenset()
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        self.default_date = self._validate_date(self.default_date) \
-            if isinstance(self.default_date, str) else self.default_date
-    
-    def _validate_date(self, date_str: str) -> datetime:
-        try:
-            return datetime.strptime(date_str, self.date_format)
-        except ValueError as e:
-            raise ConfigurationError(f'Invalid format for date "{date_str}".') from e
-
-
-@dataclass
-class _NumericParameterOption(ParameterOption):
-    """
-    Abstract class (or type) for numeric parameter options
-    """
-    min_value: Decimal
-    max_value: Decimal
-    increment: Decimal
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        try:
-            self.min_value = Decimal(self.min_value)
-            self.max_value = Decimal(self.max_value)
-            self.increment = Decimal(self.increment)
-        except InvalidDecimalConversion as e:
-            raise ConfigurationError(f'Could not convert either min, max, or increment to number') from e
-        
-        if self.min_value > self.max_value:
-            raise ConfigurationError(f'The min_value "{self.min_value}" must be less than or equal to ' + 
-                'the max_value "{self.max_value}"')
-        if (self.max_value - self.min_value) % self.increment != 0:
-            raise ConfigurationError(f'The increment "{self.increment}" must fit evenly between ' + 
-                'the min_value "{self.min_value}" and max_value "{self.max_value}"')
-
-    def _value_in_range(self, value: Decimal, min_value: Decimal) -> bool:
-        return min_value <= value <= self.max_value
-    
-    def _value_on_increment(self, value: Decimal, min_value: Decimal) -> bool:
-        diff = (value - min_value)
-        return diff >= 0 and diff % self.increment == 0
-
-    def _validate_value(self, value: Number, min_value: Optional[Decimal] = None) -> Decimal:
-        min_value = self.min_value if min_value is None else min_value
-        try:
-            value = Decimal(value)
-        except InvalidDecimalConversion as e:
-            raise ConfigurationError(f'Could not convert "{value}" to number', e)
-        
-        if not self._value_in_range(value, min_value):
-            raise ConfigurationError(f'The selected value "{value}" is outside of bounds ' +
-                '"{min_value}" and "{self.max_value}"')
-        if not self._value_on_increment(value, min_value):
-            raise ConfigurationError(f'The difference between selected value "{value}" and lower value ' +
-                '"{min_value}" must be a multiple of increment "{self.increment}"')
-        return value
-
-
-@dataclass
-class NumberParameterOption(_NumericParameterOption):
-    """
-    Parameter option for default numbers if it varies based on selection of another parameter
-
-    Attributes:
-        min_value: Minimum selectable value
-        max_value: Maximum selectable value
-        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
-        parent_option_id: Identifier of the parent option, or None if this is a top-level option
-        parent_option_ids: Set of parent option ids (only used if parent_option_id is None), or an empty set if this is a top-level option
-    """
-    default_value: Decimal
-    parent_option_id: Optional[str] = field(default=None, repr=False)
-    parent_option_ids: Iterable[str] = frozenset()
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        self.default_value = self._validate_value(self.default_value)
-
-
-@dataclass
-class NumRangeParameterOption(_NumericParameterOption):
-    """
-    Parameter option for default numeric ranges if it varies based on selection of another parameter
-    
-    Attributes:
-        min_value: Minimum selectable value
-        max_value: Maximum selectable value
-        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
-        parent_option_id: Identifier of the parent option, or None if this is a top-level option
-        parent_option_ids: Set of parent option ids (only used if parent_option_id is None), or an empty set if this is a top-level option
-    """
-    default_lower_value: Decimal
-    default_upper_value: Decimal
-    parent_option_id: Optional[str] = field(default=None, repr=False)
-    parent_option_ids: Iterable[str] = frozenset()
-
-    def __post_init__(self) -> None:
-        super().__post_init__()
-        self.default_lower_value = self._validate_value(self.default_lower_value)
-        self.default_upper_value = self._validate_value(self.default_upper_value, self.default_lower_value)
-
-
-# Types:
-NumericParameterOption = Union[NumberParameterOption, NumRangeParameterOption]
+from ._parameter_options import (
+    SelectParameterOption, 
+    DateParameterOption, 
+    DateRangeParameterOption,
+    NumberParameterOption, 
+    NumberRangeParameterOption, 
+    TextParameterOption
+)
+
+__all__ = [
+    "SelectParameterOption", "DateParameterOption", "DateRangeParameterOption", 
+    "NumberParameterOption", "NumberRangeParameterOption", "TextParameterOption"
+]