squirrels 0.5.0b2__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

dateutils/_implementation.py

@@ -0,0 +1,409 @@
+from typing import Sequence, Type
+from dataclasses import dataclass
+from datetime import date as Date, datetime
+from dateutil.relativedelta import relativedelta
+from abc import ABCMeta, abstractmethod
+
+from ._enums import DayOfWeekEnum, MonthEnum
+
+
+class DateModifier(metaclass=ABCMeta):
+    """
+    Interface for all Date modification classes, and declares a "modify" method
+    """
+
+    @abstractmethod
+    def modify(self, date: Date) -> Date:
+        """
+        Method to be overwritten, modifies the input date
+
+        Arguments:
+            date: The input date to modify.
+
+        Returns:
+            The modified date.
+        """
+        pass
+
+    def _get_date(self, datetype: Type, year: int, month: int, day: int) -> Date:
+        return datetype(year, month, day)
+
+
+@dataclass
+class DayIdxOfCalendarUnit(DateModifier):
+    """
+    Interface for adjusting a date to some day of calendar unit
+    """
+    idx: int
+
+    def __post_init__(self) -> None:
+        if self.idx == 0:
+            raise ValueError(f"For constructors of class names that start with DayIdxOf_, idx cannot be zero")
+        self.incr = self.idx - 1 if self.idx > 0 else self.idx
+
+
+@dataclass
+class DayIdxOfMonthsCycle(DayIdxOfCalendarUnit):
+    """
+    DateModifier class to get the idx-th day of a cycle of months for an input date
+
+    Attributes:
+        idx: 1 for first, 2 for second, etc. Or, -1 for last, -2 for second last, etc. Must not be 0
+        num_months_in_cycle: 2 for one 6th of year, 3 for Quarter, 4 for one 3rd of year, 6 for half year, 12 for full year. Must fit evenly in 12
+        first_month_of_cycle: The first month of months cycle of year. Default is January
+    """
+    num_months_in_cycle: int
+    first_month_of_cycle: MonthEnum = MonthEnum.January
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if 12 % self.num_months_in_cycle != 0:
+            raise ValueError(f"Argument 'num_months_in_cycle' must fit evenly in 12")
+        self.first_month_of_first_cycle = (self.first_month_of_cycle.value - 1) % self.num_months_in_cycle + 1
+
+    def modify(self, date: Date) -> Date:
+        current_cycle = (date.month - self.first_month_of_first_cycle) % 12 // self.num_months_in_cycle
+        first_month_of_curr_cycle = current_cycle * self.num_months_in_cycle + self.first_month_of_first_cycle
+        year = date.year if date.month >= first_month_of_curr_cycle else date.year - 1
+        first_day = self._get_date(type(date), year, first_month_of_curr_cycle, 1)
+        ref_date = first_day if self.idx > 0 else first_day + relativedelta(months=self.num_months_in_cycle)
+        return ref_date + relativedelta(days=self.incr)
+
+
+@dataclass
+class DayIdxOfYear(DayIdxOfMonthsCycle):
+    """
+    DateModifier class to get the idx-th day of year of an input date
+
+    Attributes:
+        idx: 1 for first, 2 for second, etc. Or, -1 for last, -2 for second last, etc. Must not be 0
+        first_month_of_year: The first month of year. Default is January
+    """
+
+    def __init__(self, idx: int, first_month_of_year: MonthEnum = MonthEnum.January):
+        super().__init__(idx, num_months_in_cycle=12, first_month_of_cycle=first_month_of_year)
+
+
+@dataclass
+class DayIdxOfQuarter(DayIdxOfMonthsCycle):
+    """
+    DateModifier class to get the idx-th day of quarter of an input date
+
+    Attributes:
+        idx: 1 for first, 2 for second, etc. Or, -1 for last, -2 for second last, etc. Must not be 0
+        first_month_of_quarter: The first month of first quarter. Default is January
+    """
+
+    def __init__(self, idx: int, first_month_of_quarter: MonthEnum = MonthEnum.January):
+        super().__init__(idx, num_months_in_cycle=3, first_month_of_cycle=first_month_of_quarter)
+
+
+@dataclass
+class DayIdxOfMonth(DayIdxOfCalendarUnit):
+    """
+    DateModifier class to get the idx-th day of month of an input date
+
+    Attributes:
+        idx: 1 for first, 2 for second, etc. Or, -1 for last, -2 for second last, etc. Must not be 0
+    """
+
+    def modify(self, date: Date) -> Date:
+        first_day = self._get_date(type(date), date.year, date.month, 1)
+        ref_date = first_day if self.idx > 0 else first_day + relativedelta(months=1)
+        return ref_date + relativedelta(days=self.incr)
+
+
+@dataclass
+class DayIdxOfWeek(DayIdxOfCalendarUnit):
+    """
+    DateModifier class to get the idx-th day of week of an input date
+
+    Attributes:
+        idx: 1 for first, 2 for second, etc. Or, -1 for last, -2 for second last, etc. Must not be 0
+        first_day_of_week: The day of week identified as the "first". Default is Monday
+    """
+    first_day_of_week: DayOfWeekEnum = DayOfWeekEnum.Monday
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.first_dow_num = self.first_day_of_week.value
+    
+    def modify(self, date: Date) -> Date:
+        distance_from_first_day = (1 + date.weekday() - self.first_dow_num) % 7
+        total_incr = -distance_from_first_day + (7 if self.idx < 0 else 0) + self.incr
+        return date + relativedelta(days=total_incr)
+
+
+@dataclass
+class OffsetUnits(DateModifier):
+    """
+    Abstract DateModifier class to offset an input date by some number of some calendar unit
+    """
+    offset: int
+
+
+@dataclass
+class OffsetYears(OffsetUnits):
+    """
+    DateModifier class to offset an input date by some number of years
+
+    Attributes:
+        offset: The number of years to offset the input date.
+    """
+
+    def modify(self, date: Date) -> Date:
+        return date + relativedelta(years=self.offset)
+    
+
+@dataclass
+class OffsetMonths(OffsetUnits):
+    """
+    DateModifier class to offset an input date by some number of months
+
+    Attributes:
+        offset: The number of months to offset the input date.
+    """
+
+    def modify(self, date: Date) -> Date:
+        return date + relativedelta(months=self.offset)
+
+
+@dataclass
+class OffsetWeeks(OffsetUnits):
+    """
+    DateModifier class to offset an input date by some number of weeks
+
+    Attributes:
+        offset: The number of weeks to offset the input date.
+    """
+
+    def modify(self, date: Date) -> Date:
+        return date + relativedelta(weeks=self.offset)
+
+
+@dataclass
+class OffsetDays(OffsetUnits):
+    """
+    DateModifier class to offset an input date by some number of days
+
+    Attributes:
+        offset: The number of days to offset the input date.
+    """
+
+    def modify(self, date: Date) -> Date:
+        return date + relativedelta(days=self.offset)
+
+
+@dataclass
+class DateModPipeline(DateModifier):
+    """
+    DateModifier class to apply a list of date modifiers to an input date
+
+    Attributes:
+        modifiers: The list of DateModifier's to apply in sequence.
+    """
+    date_modifiers: Sequence[DateModifier]
+
+    def modify(self, date: Date) -> Date:
+        for modifier in self.date_modifiers:
+            date = modifier.modify(date)
+        return date
+    
+    def get_joined_modifiers(self, date_modifiers: Sequence[DateModifier]) -> Sequence[DateModifier]:
+        """
+        Create a new sequence of DateModifier by joining the date modifiers in this class 
+        with the input date_modifiers
+
+        Arguments:
+            date_modifiers: The new date modifier sequence to join
+
+        Returns:
+            A new sequence of DateModifier
+        """
+        joined_modifiers = tuple(self.date_modifiers) + tuple(date_modifiers)
+        return joined_modifiers
+
+    def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
+        """
+        Create a new DateModPipeline with more date modifiers
+
+        Arguments:
+            date_modifiers: The additional date modifiers to add
+
+        Returns:
+            A new DateModPipeline
+        """
+        joined_modifiers = self.get_joined_modifiers(date_modifiers)
+        return DateModPipeline(joined_modifiers)
+    
+    def get_date_list(self, start_date: Date, step: DateModifier) -> Sequence[Date]:
+        """
+        This method modifies the input date, and returns all dates from the input date to the modified date, 
+        incremented by a DateModifier step.
+
+        If the step is positive and start date is less than end date, then it'll return an increasing list of
+        dates starting from the start date. If the step is negative and start date is greater than end date, 
+        then it'll return a decreasing list of dates starting from the start date. Otherwise, an empty list
+        is returned.
+
+        Arguments:
+            start_date: The input date (it's the first date in the output list if step moves towards end date)
+            step: The increment to take (specified as an offset DateModifier). Offset cannot be zero
+
+        Returns:
+            A list of datetime objects
+        """
+        assert isinstance(step, OffsetUnits)
+        if step.offset == 0:
+            raise ValueError(f"The length of 'step' must not be zero")
+        
+        output: Sequence[Date] = []
+        end_date = self.modify(start_date)
+        curr_date = start_date
+        is_not_done_positive_step = lambda: curr_date <= end_date and step.offset > 0
+        is_not_done_negative_step = lambda: curr_date >= end_date and step.offset < 0
+        while is_not_done_positive_step() or is_not_done_negative_step():
+            output.append(curr_date)
+            curr_date = step.modify(curr_date)
+        return output
+
+
+@dataclass
+class DateRepresentationModifier(metaclass=ABCMeta):
+    """
+    Abstract class for modifying other representations of dates (such as string or unix timestemp)
+    """
+    date_modifiers: Sequence[DateModifier]
+
+    def __post_init__(self) -> None:
+        self.date_mod_pipeline = DateModPipeline(self.date_modifiers)
+
+    @abstractmethod
+    def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
+        pass
+
+
+@dataclass
+class DateStringModifier(DateRepresentationModifier):
+    """
+    Class to modify a string representation of a date given a DateModifier
+
+    Attributes:
+        date_modifier: The DateModifier to apply on datetime objects
+        date_format: Format of the output date string. Default is '%Y-%m-%d'
+    """
+    date_format: str = '%Y-%m-%d'
+
+    def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
+        """
+        Create a new DateStringModifier with more date modifiers
+
+        Arguments:
+            date_modifiers: The additional date modifiers to add
+
+        Returns:
+            A new DateStringModifier
+        """
+        joined_modifiers = self.date_mod_pipeline.get_joined_modifiers(date_modifiers)
+        return DateStringModifier(joined_modifiers, self.date_format)
+    
+    def _get_input_date_obj(self, date_str: str, input_format: str | None = None) -> Date:
+        input_format = self.date_format if input_format is None else input_format
+        return datetime.strptime(date_str, input_format).date()
+
+    def modify(self, date_str: str, input_format: str | None = None) -> str:
+        """
+        Modifies the input date string with the date modifiers
+
+        Arguments:
+            date_str: The input date string
+            input_format: The input date format. Defaults to the same as output date format
+        
+        Returns:
+            The resulting date string
+        """
+        date_obj = self._get_input_date_obj(date_str, input_format)
+        return self.date_mod_pipeline.modify(date_obj).strftime(self.date_format)
+    
+    def get_date_list(self, start_date_str: str, step: DateModifier, input_format: str | None = None) -> Sequence[str]:
+        """
+        This method modifies the input date string, and returns all dates as strings from the input date 
+        to the modified date, incremented by a DateModifier step.
+
+        If the step is positive and start date is less than end date, then it'll return an increasing list of
+        dates starting from the start date. If the step is negative and start date is greater than end date, 
+        then it'll return a decreasing list of dates starting from the start date. Otherwise, an empty list
+        is returned.
+
+        Arguments:
+            start_date_str: The input date string (it's the first date in the output list if step moves towards end date)
+            step: The increment to take (specified as an offset DateModifier). Offset cannot be zero
+            input_format: The input date format. Defaults to the same as output date format
+
+        Returns:
+            A list of date strings
+        """
+        assert isinstance(step, OffsetUnits)
+        curr_date = self._get_input_date_obj(start_date_str, input_format)
+        output = self.date_mod_pipeline.get_date_list(curr_date, step)
+        return [x.strftime(self.date_format) for x in output]
+
+
+@dataclass
+class TimestampModifier(DateRepresentationModifier):
+    """
+    Class to modify a numeric representation of a date (as Unix/Epoch/POSIX timestamp) given a DateModifier
+
+    Attributes:
+        date_modifier: The DateModifier to apply on datetime objects
+        date_format: Format of the date string. Default is '%Y-%m-%d'
+    """
+
+    def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
+        """
+        Create a new TimestampModifier with more date modifiers
+
+        Arguments:
+            date_modifiers: The additional date modifiers to add
+
+        Returns:
+            A new TimestampModifier
+        """
+        joined_modifiers = self.date_mod_pipeline.get_joined_modifiers(date_modifiers)
+        return TimestampModifier(joined_modifiers)
+
+    def modify(self, timestamp: float) -> float:
+        """
+        Modifies the input timestamp with the date modifiers
+
+        Arguments:
+            timestamp: The input timestamp as float
+        
+        Returns:
+            The resulting timestamp
+        """
+        date_obj = datetime.fromtimestamp(timestamp).date()
+        modified_date = self.date_mod_pipeline.modify(date_obj)
+        modified_datetime = datetime.combine(modified_date, datetime.min.time())
+        return modified_datetime.timestamp()
+    
+    def get_date_list(self, start_timestamp: float, step: DateModifier) -> Sequence[float]:
+        """
+        This method modifies the input timestamp, and returns all dates as timestampes/floats from the input date 
+        to the modified date, incremented by a DateModifier step.
+
+        If the step is positive and start date is less than end date, then it'll return an increasing list of
+        dates starting from the start date. If the step is negative and start date is greater than end date, 
+        then it'll return a decreasing list of dates starting from the start date. Otherwise, an empty list
+        is returned.
+
+        Arguments:
+            start_timestamp: The input timestamp as float (it's the first date in the output list if step moves towards end date)
+            step: The increment to take (specified as an offset DateModifier). Offset cannot be zero
+
+        Returns:
+            A list of timestamp as floats
+        """
+        curr_date = datetime.fromtimestamp(start_timestamp).date()
+        output = self.date_mod_pipeline.get_date_list(curr_date, step)
+        return [datetime.combine(x, datetime.min.time()).timestamp() for x in output]

dateutils/types.py

@@ -0,0 +1,6 @@
+from ._implementation import (
+    DateModifier,
+    DayIdxOfCalendarUnit,
+    OffsetUnits,
+    DateRepresentationModifier
+)

squirrels/__init__.py

@@ -1,23 +1,17 @@
 from ._version import __version__
 
-from .arguments.init_time_args import ConnectionsArgs, ParametersArgs, BuildModelArgs
-from .arguments.run_time_args import AuthLoginArgs, AuthTokenArgs, ContextArgs, ModelArgs, DashboardArgs
+from .arguments import *
 
-from .parameter_options import SelectParameterOption, DateParameterOption, DateRangeParameterOption
-from .parameter_options import NumberParameterOption, NumberRangeParameterOption, TextParameterOption
+from .connections import *
 
-from .parameters import SingleSelectParameter, MultiSelectParameter, DateParameter, DateRangeParameter
-from .parameters import NumberParameter, NumberRangeParameter, TextParameter, TextValue
+from .parameter_options import *
 
-from .data_sources import SelectDataSource, DateDataSource, DateRangeDataSource
-from .data_sources import NumberDataSource, NumberRangeDataSource, TextDataSource
+from .parameters import *
 
-from .dashboards import PngDashboard, HtmlDashboard
+from .data_sources import *
 
-from ._auth import BaseUser
+from .dashboards import *
 
-from ._manifest import ConnectionProperties, ConnectionType
+from .types import *
 
 from ._project import SquirrelsProject
-
-from .dataset_result import DatasetResult

squirrels/_api_server.py

@@ -17,9 +17,9 @@ from ._version import __version__, sq_major_version
 from ._manifest import PermissionScope
 from ._auth import BaseUser, AccessToken, UserField
 from ._parameter_sets import ParameterSet
-from .dashboards import Dashboard
+from ._dashboard_types import Dashboard
 from ._project import SquirrelsProject
-from .dataset_result import DatasetResult
+from ._dataset_types import DatasetResult
 from ._parameter_configs import APIParamFieldInfo
 
 mimetypes.add_type('application/javascript', '.js')
@@ -189,17 +189,17 @@ class ApiServer:
                 traceback.print_exception(exc.error, file=buffer)
                 buffer.write(str(exc))
                 response = JSONResponse(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected error occurred", "blame": "Squirrels project"}
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected server error occurred", "blame": "Squirrels project"}
                 )
             except ConfigurationError as exc:
                 traceback.print_exc(file=buffer)
                 response = JSONResponse(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected error occurred", "blame": "Squirrels project"}
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected server error occurred", "blame": "Squirrels project"}
                 )
             except Exception as exc:
                 traceback.print_exc(file=buffer)
                 response = JSONResponse(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected error occurred", "blame": "Squirrels framework"}
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={"message": f"An unexpected server error occurred", "blame": "Squirrels framework"}
                 )
             
             err_msg = buffer.getvalue()

squirrels/{arguments/init_time_args.py → _arguments/_init_time_args.py}

@@ -88,14 +88,14 @@ class BuildModelArgs(_WithConnectionDictArgs):
 
     def run_sql_on_dataframes(self, sql_query: str, *, dataframes: dict[str, pl.LazyFrame] | None = None, **kwargs) -> pl.DataFrame:
         """
-        Uses a dictionary of dataframes to execute a SQL query in an embedded in-memory database (sqlite or duckdb based on setting)
+        Uses a dictionary of dataframes to execute a SQL query in an embedded in-memory DuckDB database
 
         Arguments:
             sql_query: The SQL query to run
             dataframes: A dictionary of table names to their polars LazyFrame. If None, uses results of dependent models
         
         Returns:
-            The result as a polars LazyFrame from running the query
+            The result as a polars DataFrame from running the query
         """
         if dataframes is None:
             dataframes = {x: self.ref(x) for x in self._dependencies}

squirrels/{arguments/run_time_args.py → _arguments/_run_time_args.py}

@@ -1,31 +1,9 @@
 from typing import Callable, Any, Coroutine
 import polars as pl
 
-from .init_time_args import _WithConnectionDictArgs, ParametersArgs, BuildModelArgs, ConnectionsArgs
+from ._init_time_args import ParametersArgs, BuildModelArgs
 from .._auth import BaseUser
-from ..parameters import Parameter, TextValue
-
-
-class AuthLoginArgs(_WithConnectionDictArgs):
-
-    def __init__(
-        self, conn_args: ConnectionsArgs, _connections: dict[str, Any], 
-        username: str, 
-        password: str
-    ):
-        super().__init__(conn_args.project_path, conn_args.proj_vars, conn_args.env_vars, _connections)
-        self.username = username
-        self.password = password
-
-
-class AuthTokenArgs(_WithConnectionDictArgs):
-
-    def __init__(
-        self, conn_args: ConnectionsArgs, _connections: dict[str, Any], 
-        token: str
-    ):
-        super().__init__(conn_args.project_path, conn_args.proj_vars, conn_args.env_vars, _connections)
-        self.token = token
+from .._parameters import Parameter, TextValue
 
 
 class ContextArgs(ParametersArgs):
@@ -57,7 +35,7 @@ class ContextArgs(ParametersArgs):
         return self._traits.copy()
 
     @property
-    def placeholders(self) -> dict[str, Any]:
+    def _placeholders_copy(self) -> dict[str, Any]:
         """
         A dictionary of placeholder name to placeholder value
         """
@@ -103,7 +81,7 @@ class ModelArgs(BuildModelArgs, ContextArgs):
         self.user = ctx_args.user
         self._prms = ctx_args.prms
         self._traits = ctx_args.traits
-        self._placeholders = ctx_args.placeholders
+        self._placeholders = ctx_args._placeholders_copy
         self._connections = build_model_args.connections
         self._dependencies = build_model_args.dependencies
         self._ref = build_model_args.ref

squirrels/_auth.py

@@ -282,8 +282,8 @@ class Authenticator(_t.Generic[User]):
                 if not update_user:
                     raise InvalidInputError(101, f"User '{username}' already exists")
                 
-                if username == c.ADMIN_USERNAME:
-                    raise InvalidInputError(24, "Changing the admin user is not permitted")
+                if username == c.ADMIN_USERNAME and user_data.get("is_admin") is False:
+                    raise InvalidInputError(24, "Setting the admin user to non-admin is not permitted")
                 new_user = self.DbUser(password_hash=existing_user.password_hash, **user_data)
                 session.delete(existing_user)
             else:

squirrels/_connection_set.py

@@ -4,8 +4,8 @@ from sqlalchemy import Engine
 import time, polars as pl
 
 from . import _utils as u, _constants as c, _py_module as pm
-from .arguments.init_time_args import ConnectionsArgs
-from ._manifest import ManifestConfig, ConnectionProperties, ConnectionType
+from ._arguments._init_time_args import ConnectionsArgs
+from ._manifest import ManifestConfig, ConnectionProperties, ConnectionTypeEnum
 
 
 @dataclass
@@ -31,11 +31,11 @@ class ConnectionSet:
     def run_sql_query_from_conn_name(self, query: str, conn_name: str, placeholders: dict = {}) -> pl.DataFrame:
         conn = self.get_connection(conn_name)
         try:
-            if isinstance(conn, ConnectionProperties) and (conn.type == ConnectionType.CONNECTORX or conn.type == ConnectionType.ADBC):
+            if isinstance(conn, ConnectionProperties) and (conn.type == ConnectionTypeEnum.CONNECTORX or conn.type == ConnectionTypeEnum.ADBC):
                 if len(placeholders) > 0:
                     raise u.ConfigurationError(f"Connection '{conn_name}' is a ConnectorX or ADBC connection, which does not support placeholders")
                 df = pl.read_database_uri(query, conn.uri, engine=conn.type.value)
-            elif isinstance(conn, ConnectionProperties) and conn.type == ConnectionType.SQLALCHEMY:
+            elif isinstance(conn, ConnectionProperties) and conn.type == ConnectionTypeEnum.SQLALCHEMY:
                 with conn.engine.connect() as connection:
                     df = pl.read_database(query, connection, execute_options={"parameters": placeholders})
             else:
@@ -52,7 +52,7 @@ class ConnectionSet:
             if isinstance(conn, Engine):
                 conn.dispose()
             elif isinstance(conn, ConnectionProperties):
-                if conn.type == ConnectionType.SQLALCHEMY:
+                if conn.type == ConnectionTypeEnum.SQLALCHEMY:
                     conn.engine.dispose()
             elif hasattr(conn, 'close'):
                 conn.close()

squirrels/_constants.py

@@ -33,7 +33,7 @@ SQRL_CONNECTIONS_DEFAULT_NAME_USED = 'SQRL_CONNECTIONS__DEFAULT_NAME_USED'
 SQRL_DUCKDB_VENV_DB_FILE_PATH = 'SQRL_DUCKDB_VENV__DB_FILE_PATH'
 
 # Folder/File names
-PACKAGE_DATA_FOLDER = 'package_data'
+PACKAGE_DATA_FOLDER = '_package_data'
 BASE_PROJECT_FOLDER = 'base_project'
 
 GLOBAL_ENV_FOLDER = '.squirrels'