squirrels 0.1.1.post1__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

squirrels/dateutils.py

@@ -1,10 +1,11 @@
-from typing import Sequence
+from typing import Sequence, Type
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import date as Date, datetime
 from dateutil.relativedelta import relativedelta
+from abc import ABCMeta, abstractmethod
 from enum import Enum
 
-from squirrels import _utils
+from . import _utils as u
 
 
 class DayOfWeek(Enum):
@@ -31,13 +32,13 @@ class Month(Enum):
     December = 12
 
 
-@dataclass
-class DateModifier:
+class DateModifier(metaclass=ABCMeta):
     """
     Interface for all Date modification classes, and declares a "modify" method
     """
 
-    def modify(self, date: datetime) -> datetime:
+    @abstractmethod
+    def modify(self, date: Date) -> Date:
         """
         Method to be overwritten, modifies the input date
 
@@ -47,19 +48,21 @@ class DateModifier:
         Returns:
             The modified date.
         """
-        raise _utils.AbstractMethodCallError(self.__class__, "modify")
+        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):
+    def __init__(self, idx: int) -> None:
+        super().__init__()
+        self.idx = idx
         if self.idx == 0:
-            raise _utils.ConfigurationError("For constructors of class names that start with DayIdxOf_, idx cannot be zero")
+            raise u.ConfigurationError(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
 
 
@@ -73,21 +76,23 @@ class DayIdxOfMonthsCycle(_DayIdxOfCalendarUnit):
         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: Month = Month.January
+    _num_months_in_cycle: int
+    _first_month_of_cycle: Month
 
-    def __post_init__(self):
-        super().__post_init__()
-        if 12 % self.num_months_in_cycle != 0:
-            raise _utils.ConfigurationError("Value X 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 __init__(self, idx: int, num_months_in_cycle: int, first_month_of_cycle: Month = Month.January) -> None:
+        super().__init__(idx)
+        self._num_months_in_cycle = num_months_in_cycle
+        self._first_month_of_cycle = first_month_of_cycle
+        if 12 % self._num_months_in_cycle != 0:
+            raise u.ConfigurationError(f"Value X 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: datetime) -> datetime:
-        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
+    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 = datetime(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)
+        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)
 
 
@@ -128,8 +133,11 @@ class DayIdxOfMonth(_DayIdxOfCalendarUnit):
         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: datetime) -> datetime:
-        first_day = datetime(date.year, date.month, 1)
+    def __init__(self, idx: int) -> None:
+        super().__init__(idx)
+
+    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)
 
@@ -143,24 +151,26 @@ class DayIdxOfWeek(_DayIdxOfCalendarUnit):
         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: DayOfWeek = DayOfWeek.Monday
+    _first_day_of_week: DayOfWeek
 
-    def __post_init__(self):
-        super().__post_init__()
-        self.first_dow_num = self.first_day_of_week.value
+    def __init__(self, idx: int, first_day_of_week: DayOfWeek = DayOfWeek.Monday) -> None:
+        super().__init__(idx)
+        self._first_day_of_week = first_day_of_week
+        self.first_dow_num = self._first_day_of_week.value
     
-    def modify(self, date: datetime) -> datetime:
+    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
+    def __init__(self, offset: int) -> None:
+        super().__init__()
+        self.offset = offset
 
 
 @dataclass
@@ -172,7 +182,10 @@ class OffsetYears(_OffsetUnits):
         offset: The number of years to offset the input date.
     """
 
-    def modify(self, date: datetime) -> datetime:
+    def __init__(self, offset: int) -> None:
+        super().__init__(offset)
+
+    def modify(self, date: Date) -> Date:
         return date + relativedelta(years=self.offset)
     
 
@@ -185,7 +198,10 @@ class OffsetMonths(_OffsetUnits):
         offset: The number of months to offset the input date.
     """
 
-    def modify(self, date: datetime) -> datetime:
+    def __init__(self, offset: int) -> None:
+        super().__init__(offset)
+
+    def modify(self, date: Date) -> Date:
         return date + relativedelta(months=self.offset)
 
 
@@ -198,7 +214,10 @@ class OffsetWeeks(_OffsetUnits):
         offset: The number of weeks to offset the input date.
     """
 
-    def modify(self, date: datetime) -> datetime:
+    def __init__(self, offset: int) -> None:
+        super().__init__(offset)
+
+    def modify(self, date: Date) -> Date:
         return date + relativedelta(weeks=self.offset)
 
 
@@ -211,7 +230,10 @@ class OffsetDays(_OffsetUnits):
         offset: The number of days to offset the input date.
     """
 
-    def modify(self, date: datetime) -> datetime:
+    def __init__(self, offset: int) -> None:
+        super().__init__(offset)
+
+    def modify(self, date: Date) -> Date:
         return date + relativedelta(days=self.offset)
 
 
@@ -223,13 +245,14 @@ class DateModPipeline(DateModifier):
     Attributes:
         modifiers: The list of DateModifier's to apply in sequence.
     """
-    date_modifiers: Sequence[DateModifier]
+    _date_modifiers: Sequence[DateModifier]
 
-    def __post_init__(self):
-        self.date_modifiers = tuple(self.date_modifiers)
+    def __init__(self, date_modifiers: Sequence[DateModifier]) -> None:
+        super().__init__()
+        self._date_modifiers = tuple(date_modifiers)
     
-    def modify(self, date: datetime) -> datetime:
-        for modifier in self.date_modifiers:
+    def modify(self, date: Date) -> Date:
+        for modifier in self._date_modifiers:
             date = modifier.modify(date)
         return date
     
@@ -244,7 +267,7 @@ class DateModPipeline(DateModifier):
         Returns:
             A new sequence of DateModifier
         """
-        joined_modifiers = self.date_modifiers + tuple(date_modifiers)
+        joined_modifiers = self._date_modifiers + tuple(date_modifiers)
         return joined_modifiers
 
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
@@ -260,7 +283,7 @@ class DateModPipeline(DateModifier):
         joined_modifiers = self.get_joined_modifiers(date_modifiers)
         return DateModPipeline(joined_modifiers)
     
-    def get_date_list(self, start_date: datetime, step: _OffsetUnits) -> Sequence[datetime]:
+    def get_date_list(self, start_date: Date, step: _OffsetUnits) -> 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.
@@ -278,7 +301,7 @@ class DateModPipeline(DateModifier):
             A list of datetime objects
         """
         if step.offset == 0:
-            raise _utils.ConfigurationError("The length of 'step' must not be zero")
+            raise u.ConfigurationError(f"The length of 'step' must not be zero")
         
         output = []
         end_date = self.modify(start_date)
@@ -291,16 +314,16 @@ class DateModPipeline(DateModifier):
         return output
 
 
-@dataclass
-class _DateRepresentationModifier:
+class _DateRepresentationModifier(metaclass=ABCMeta):
     """
     Abstract class for modifying other representations of dates (such as string or unix timestemp)
     """
     def __init__(self, date_modifiers: Sequence[DateModifier]):
         self.date_modifier = DateModPipeline(date_modifiers)
 
+    @abstractmethod
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
-        raise _utils.AbstractMethodCallError(self.__class__, "with_more_modifiers")
+        pass
 
 
 @dataclass
@@ -312,9 +335,12 @@ class DateStringModifier(_DateRepresentationModifier):
         date_modifier: The DateModifier to apply on datetime objects
         date_format: Format of the output date string. Default is '%Y-%m-%d'
     """
+    _date_modifiers: Sequence[DateModifier]
+    _date_format: str
+
     def __init__(self, date_modifiers: Sequence[DateModifier], date_format: str = '%Y-%m-%d'):
         super().__init__(date_modifiers)
-        self.date_format = date_format
+        self._date_format = date_format
 
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
         """
@@ -327,11 +353,11 @@ class DateStringModifier(_DateRepresentationModifier):
             A new DateStringModifier
         """
         joined_modifiers = self.date_modifier.get_joined_modifiers(date_modifiers)
-        return DateStringModifier(joined_modifiers, self.date_format)
+        return DateStringModifier(joined_modifiers, self._date_format)
     
-    def _get_input_date_obj(self, date_str: str, input_format: str = None) -> datetime:
-        input_format = self.date_format if input_format is None else input_format
-        return datetime.strptime(date_str, input_format)
+    def _get_input_date_obj(self, date_str: str, input_format: str = 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) -> str:
         """
@@ -345,7 +371,7 @@ class DateStringModifier(_DateRepresentationModifier):
             The resulting date string
         """
         date_obj = self._get_input_date_obj(date_str, input_format)
-        return self.date_modifier.modify(date_obj).strftime(self.date_format)
+        return self.date_modifier.modify(date_obj).strftime(self._date_format)
     
     def get_date_list(self, start_date_str: str, step: DateModifier, input_format: str = None) -> Sequence[str]:
         """
@@ -367,7 +393,7 @@ class DateStringModifier(_DateRepresentationModifier):
         """
         curr_date = self._get_input_date_obj(start_date_str, input_format)
         output = self.date_modifier.get_date_list(curr_date, step)
-        return [x.strftime(self.date_format) for x in output]
+        return [x.strftime(self._date_format) for x in output]
 
 
 @dataclass
@@ -379,6 +405,8 @@ class TimestampModifier(_DateRepresentationModifier):
         date_modifier: The DateModifier to apply on datetime objects
         date_format: Format of the date string. Default is '%Y-%m-%d'
     """
+    _date_modifiers: Sequence[DateModifier]
+
     def __init__(self, date_modifiers: Sequence[DateModifier]):
         super().__init__(date_modifiers)
 
@@ -406,7 +434,8 @@ class TimestampModifier(_DateRepresentationModifier):
             The resulting timestamp
         """
         date_obj = datetime.fromtimestamp(timestamp)
-        return self.date_modifier.modify(date_obj).timestamp()
+        modified_date: datetime = self.date_modifier.modify(date_obj)
+        return modified_date.timestamp()
     
     def get_date_list(self, start_timestamp: float, step: DateModifier) -> Sequence[float]:
         """
@@ -426,5 +455,5 @@ class TimestampModifier(_DateRepresentationModifier):
             A list of timestamp as floats
         """
         curr_date = datetime.fromtimestamp(start_timestamp)
-        output = self.date_modifier.get_date_list(curr_date, step)
+        output: Sequence[datetime] = self.date_modifier.get_date_list(curr_date, step)
         return [x.timestamp() for x in output]

squirrels/package_data/base_project/Dockerfile

@@ -0,0 +1,15 @@
+# Change here to use different python version (ex. 3.12-slim for version 3.12)
+FROM python:3.11-slim
+WORKDIR /app
+
+# Needed if any python dependencies are installed from git, or for 
+#  "squirrels load-modules" if there are modules in "squirrels.yml"
+RUN apt-get update && apt-get install -y git
+
+COPY requirements-lock.txt .
+RUN pip install --no-cache-dir -r requirements-lock.txt
+
+COPY . .
+RUN squirrels load-modules
+
+CMD ["squirrels", "run", "--host", "0.0.0.0", "--port", "4465"]

squirrels/package_data/base_project/connections.yml

@@ -0,0 +1,7 @@
+## Uses SQLAlchemy URLs. More details here: https://docs.sqlalchemy.org/en/latest/core/engines.html
+db_connections:
+  - connection_name: default
+    credential_key: null
+    url: "sqlite://{username}:{password}@/./database/expenses.db" ## or use {{ sqlite_conn_str }} with the environcfg.yml file
+
+

squirrels/package_data/base_project/environcfg.yml

@@ -0,0 +1,29 @@
+## Note: You can copy this file to the .squirrels folder in your home directory to make 
+##   the configurations global for all squirrels projects on the current machine
+
+## Fake users for local development testing
+users:
+  johndoe:
+    is_internal: True
+    password: I<3Squirrels
+    full_name: John Doe
+    organization: org1
+  mattdoe:
+    is_internal: False
+    password: abcd5678
+    full_name: Matt Doe
+    organization: org2
+
+## Custom environment variables / secrets
+env_vars:
+  sqlite_conn_str: sqlite://{username}:{password}@/./database/expenses.db
+
+## Database credentials
+credentials:
+  db_user:
+    username: user1
+    password: pass1
+
+## Predefined secrets used by the squirrels framework
+secrets:
+  jwt_signature: ## generate a random 32 byte hex string here for jwt signatures. For instance, you can run "openssl rand -hex 32" in bash

squirrels/package_data/base_project/ignores/.dockerignore

@@ -0,0 +1,8 @@
+__pycache__
+venv/
+.git
+
+# squirrels files to ignore
+environcfg.yml
+target/
+sqrl_packages/

squirrels/package_data/base_project/ignores/.gitignore

@@ -0,0 +1,7 @@
+__pycache__
+venv/
+
+# squirrels files to ignore
+environcfg.yml
+target/
+sqrl_packages/

squirrels/package_data/base_project/models/dbviews/database_view1.py

@@ -0,0 +1,36 @@
+from textwrap import dedent
+import pandas as pd, squirrels as sr
+
+
+def main(sqrl: sr.ModelArgs) -> pd.DataFrame:
+    """
+    Create a database view model in Python by sending an external query to a database or API, and return a 
+    pandas DataFrame of the result in this function. Since the result is loaded into server memory, be mindful of 
+    the size of the results coming from the external query.
+    """
+
+    """ If working with sqlalchemy ORMs, use 'sqrl.connections' to get a connection pool / engine """
+    # from typing import Union
+    # from sqlalchemy import Engine, Pool
+    # engine1: Union[Engine, Pool] = sqrl.connections[sqrl.connection_name] ## using the pre-assigned key
+    # engine2: Union[Engine, Pool] = sqrl.connections["my_connection_name"] ## or use any defined key
+    
+    """ Example with building and running a sql query """
+    category_clause = f'AND Category IN ({sqrl.ctx["categories"]})\n' if sqrl.ctx["has_categories"] else ''
+    subcategory_clause = f'AND Subcategory IN ({sqrl.ctx["subcategories"]})\n' if sqrl.ctx["has_subcategories"] else ''
+    query = dedent(f"""
+        SELECT {sqrl.ctx["group_by_cols"]}
+            , sum(-Amount) as Total_Amount
+        FROM transactions
+        WHERE 1=1
+            {category_clause}{subcategory_clause}AND "Date" >= {sqrl.ctx["start_date"]}
+            AND "Date" <= {sqrl.ctx["end_date"]}
+            AND -Amount >= {sqrl.ctx["min_amount"]}
+            AND -Amount <= {sqrl.ctx["max_amount"]}
+        GROUP BY {sqrl.ctx["group_by_cols"]}
+    """).strip()
+
+    return sqrl.run_external_sql(query) 
+
+    """ A 'connection_name' argument is available to use a different connection key """
+    # return sqrl.run_external_sql(query, connection_name="different_key")

squirrels/package_data/base_project/models/dbviews/database_view1.sql

@@ -0,0 +1,15 @@
+SELECT {{ ctx["group_by_cols"] }}
+    , sum(-Amount) as Total_Amount
+FROM transactions
+WHERE 1=1
+{%- if ctx["has_categories"] %}
+    AND Category IN ({{ ctx["categories"] }})
+{%- endif %}
+{%- if ctx["has_subcategories"] %}
+    AND Subcategory IN ({{ ctx["subcategories"] }})
+{%- endif %}
+    AND "Date" >= {{ ctx["start_date"] }}
+    AND "Date" <= {{ ctx["end_date"] }}
+    AND -Amount >= {{ ctx["min_amount"] }}
+    AND -Amount <= {{ ctx["max_amount"] }}
+GROUP BY {{ ctx["group_by_cols"] }}

squirrels/package_data/base_project/models/federates/dataset_example.py

@@ -0,0 +1,20 @@
+from typing import Iterable
+import pandas as pd, squirrels as sr
+
+
+def dependencies(sqrl: sr.ModelDepsArgs) -> Iterable[str]:
+    """
+    Define list of dependent models here. This will determine the dependencies first, at compile-time, 
+    before running the model.
+    """
+    return ["database_view1"]
+
+
+def main(sqrl: sr.ModelArgs) -> pd.DataFrame:
+    """
+    Create federated models by joining/processing dependent database views and/or other federated models to
+    form and return the result as a new pandas DataFrame.
+    """
+    df = sqrl.ref("database_view1")
+    group_by_cols: str = sqrl.ctx["group_by_cols_list"]
+    return df.sort_values(group_by_cols, ascending=False)

squirrels/package_data/base_project/models/federates/dataset_example.sql

@@ -0,0 +1,3 @@
+SELECT *
+FROM {{ ref("database_view1") }}
+ORDER BY {{ ctx["order_by_cols"] }}

squirrels/package_data/base_project/parameters.yml

@@ -0,0 +1,109 @@
+parameters:
+  - name: group_by
+    type: SingleSelectParameter
+    factory: Create               ## one of 'Create', 'CreateSimple', or 'CreateFromSource'
+    arguments:                    ## arguments to specify depend on values for 'type' and 'factory'
+      label: Group By
+      all_options:
+        - id: g0
+          label: Transaction
+          columns: [ID, Date]     ## custom field
+          is_default: false       ## optional, default, exists for SingleSelect or MultiSelect options only
+          user_groups: []         ## optional, default, exists for all parameter options
+          parent_option_ids: []   ## optional, default, exists for all parameter options
+        - id: g1
+          label: Date
+          columns: [Date]
+        - id: g2
+          label: Category
+          columns: [Category]
+        - id: g3
+          label: Subcategory
+          columns: [Category, Subcategory]
+      is_hidden: false            ## optional, default, exists for all parameter types
+      user_attribute: null        ## optional, default, exists for all parameter types
+      parent_name: null           ## optional, default, exists for all parameter types
+  - name: start_date
+    type: DateParameter
+    factory: Create
+    arguments:
+      label: Start Date
+      all_options:
+        - default_date: 2023-01-01
+          date_format: '%Y-%m-%d' ## optional, default, format comes from python datetime, exists for Date and DateRange parameter options
+  - name: end_date
+    type: DateParameter
+    factory: Create
+    arguments:
+      label: End Date
+      all_options:
+        - default_date: 2023-12-31
+  - name: date_range
+    type: DateRangeParameter
+    factory: Create
+    arguments:
+      label: Date Range
+      all_options:
+        - default_start_date: 2023-01-01
+          default_end_date: 2023-12-31
+  - name: category
+    type: MultiSelectParameter
+    factory: CreateFromSource
+    arguments:
+      label: Category Filter
+      data_source:
+        table_or_query: categories
+        id_col: Category_ID
+        options_col: Category
+        order_by_col: null        ## optional, default, exists for SingleSelect and MultiSelect
+        is_default_col: null      ## optional, default, exists for SingleSelect and MultiSelect
+        custom_cols: {}           ## optional, default, exists for SingleSelect and MultiSelect
+        include_all: true         ## optional, default, exists for MultiSelect only
+        order_matters: false      ## optional, default, exists for MultiSelect only
+        user_group_col: null      ## optional, default, exists for all parameters
+        connection_name: default  ## optional, default, exists for all parameters
+  - name: subcategory
+    type: MultiSelectParameter
+    factory: CreateFromSource
+    arguments:
+      label: Subcategory Filter
+      data_source:
+        table_or_query: subcategories
+        id_col: Subcategory_ID
+        options_col: Subcategory
+        parent_id_col: Category_ID  ## optional, default is null, exists for all parameter types
+      parent_name: category
+  - name: min_filter
+    type: NumberParameter
+    factory: Create
+    arguments:
+      label: Amounts Greater Than
+      all_options:
+        - min_value: 0
+          max_value: 500
+          increment: 1            ## optional, default, exists for Number and NumRange options
+          default_value: null     ## optional, default, exists for Number options only
+  - name: max_filter
+    type: NumberParameter
+    factory: CreateFromSource
+    arguments:
+      label: Amounts Less Than
+      data_source:
+        table_or_query: "SELECT 0 as min_value, max(-Amount) as max_value, 10 as increment FROM transactions WHERE Category <> 'Income'"
+        min_value_col: min_value
+        max_value_col: max_value
+        increment_col: increment      ## optional, default is null
+        default_value_col: max_value  ## optional, default is null
+        id_col: null                  ## optional, default, required for SingleSelect and MultiSelect, optional for all others
+  - name: between_filter
+    type: NumberRangeParameter
+    factory: Create
+    arguments:
+      label: Amounts Between
+      all_options:
+        - min_value: 0
+          max_value: 500
+          default_lower_value: 10   ## optional, default is null (or min_value), exists for NumRange options only
+          default_upper_value: 400  ## optional, default is null (or max_value), exists for NumRange options only
+
+

squirrels/package_data/base_project/pyconfigs/auth.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Union, Any
+from squirrels import User as UserBase, WrongPassword
+
+
+class User(UserBase):
+    def set_attributes(self, user_dict: dict[str, Any]) -> None:
+        """
+        Use this method to add custom attributes in the User model that don't exist in UserBase (username, is_internal, etc.)
+        """
+        self.organization = user_dict["organization"]
+
+
+def get_user_if_valid(username: str, password: str) -> Union[User, WrongPassword, None]:
+    """
+    This function allows the squirrels framework to know how to authenticate input username and password.
+
+    Return:
+        - User instance - if username and password are correct
+        - WrongPassword(username) - if username exists but password is incorrect
+        - None - if the username doesn't exist (and continue username search among "fake users" in environcfg.yml)
+    """
+    mock_users_db = {
+        "johndoe": {
+            "username": "johndoe",
+            "is_admin": True,
+            "organization": "org1",
+            "hashed_password": str(hash("I<3Squirrels"))
+        },
+        "mattdoe": {
+            "username": "mattdoe",
+            "is_admin": False,
+            "organization": "org2",
+            "hashed_password": str(hash("abcd5678"))
+        }
+    }
+
+    if username in mock_users_db:
+        user_dict = mock_users_db[username]
+        hashed_pwd = user_dict["hashed_password"]
+        if str(hash(password)) == hashed_pwd:
+            is_admin = user_dict["is_admin"]
+            user = User(username, is_internal=is_admin)
+            return user.with_attributes(user_dict)
+        else:
+            return WrongPassword(username)
+    return None

squirrels/package_data/base_project/pyconfigs/connections.py

@@ -0,0 +1,28 @@
+from typing import Union
+from sqlalchemy import create_engine, Engine, Pool
+import squirrels as sr
+
+
+def main(connections: dict[str, Union[Engine, Pool]], sqrl: sr.ConnectionsArgs) -> None:
+    """
+    Define connections by adding sqlalchemy engines or connection pools to the dictionary "connections".
+    Note that all connections in a pool should be shareable across threads. No writes should be occuring on them.
+    """
+    
+    """ Example of getting the username and password """
+    # username, password = sqrl.get_credential('my_key')
+
+    """ SQLAlchemy URL for a connection pool / engine """
+    conn_str = 'sqlite:///./database/expenses.db' 
+
+    """ Can also leverage the environcfg.yml file for connection details """
+    # conn_str_raw: str = sqrl.env_vars["sqlite_conn_str"]
+    # conn_str = conn_str_raw.format(username=username, password=password) 
+    
+    """ Assigning names to connection pool / engine """
+    connections["default"] = create_engine(conn_str)
+
+    """ Example of using QueuePool to use a custom db connector without a SQLAlchemy URL """
+    # from sqlalchemy import QueuePool
+    # connection_creator = lambda: sqlite3.connect("./database/expenses.db", check_same_thread=False)
+    # connections["default"] = QueuePool(connection_creator)