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

dateutils/__init__.py

@@ -0,0 +1,6 @@
+from ._enums import DayOfWeekEnum, MonthEnum
+from ._implementation import (
+    DayIdxOfMonthsCycle, DayIdxOfYear, DayIdxOfQuarter, DayIdxOfMonth, DayIdxOfWeek,
+    OffsetYears, OffsetMonths, OffsetWeeks, OffsetDays,
+    DateModPipeline, DateStringModifier, TimestampModifier
+)

dateutils/_enums.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+
+class DayOfWeekEnum(Enum):
+    Sunday = 0
+    Monday = 1
+    Tuesday = 2
+    Wednesday = 3
+    Thursday = 4
+    Friday = 5
+    Saturday = 6
+
+class MonthEnum(Enum):
+    January = 1
+    February = 2
+    March = 3
+    April = 4
+    May = 5
+    June = 6
+    July = 7
+    August = 8
+    September = 9
+    October = 10
+    November = 11
+    December = 12

squirrels/dateutils.py → dateutils/_implementation.py

@@ -3,33 +3,8 @@ from dataclasses import dataclass
 from datetime import date as Date, datetime
 from dateutil.relativedelta import relativedelta
 from abc import ABCMeta, abstractmethod
-from enum import Enum
-
-from . import _utils as u
-
-
-class DayOfWeek(Enum):
-    Sunday = 0
-    Monday = 1
-    Tuesday = 2
-    Wednesday = 3
-    Thursday = 4
-    Friday = 5
-    Saturday = 6
-
-class Month(Enum):
-    January = 1
-    February = 2
-    March = 3
-    April = 4
-    May = 5
-    June = 6
-    July = 7
-    August = 8
-    September = 9
-    October = 10
-    November = 11
-    December = 12
+
+from ._enums import DayOfWeekEnum, MonthEnum
 
 
 class DateModifier(metaclass=ABCMeta):
@@ -54,20 +29,21 @@ class DateModifier(metaclass=ABCMeta):
         return datetype(year, month, day)
 
 
-class _DayIdxOfCalendarUnit(DateModifier):
+@dataclass
+class DayIdxOfCalendarUnit(DateModifier):
     """
     Interface for adjusting a date to some day of calendar unit
     """
-    def __init__(self, idx: int) -> None:
-        super().__init__()
-        self.idx = idx
+    idx: int
+
+    def __post_init__(self) -> None:
         if self.idx == 0:
-            raise u.ConfigurationError(f"For constructors of class names that start with DayIdxOf_, idx cannot be zero")
+            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):
+class DayIdxOfMonthsCycle(DayIdxOfCalendarUnit):
     """
     DateModifier class to get the idx-th day of a cycle of months for an input date
 
@@ -76,23 +52,21 @@ 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
+    num_months_in_cycle: int
+    first_month_of_cycle: MonthEnum = MonthEnum.January
 
-    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 __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
+        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)
+        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)
 
 
@@ -106,7 +80,7 @@ class DayIdxOfYear(DayIdxOfMonthsCycle):
         first_month_of_year: The first month of year. Default is January
     """
 
-    def __init__(self, idx: int, first_month_of_year: Month = Month.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)
 
 
@@ -120,12 +94,12 @@ class DayIdxOfQuarter(DayIdxOfMonthsCycle):
         first_month_of_quarter: The first month of first quarter. Default is January
     """
 
-    def __init__(self, idx: int, first_month_of_quarter: Month = Month.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):
+class DayIdxOfMonth(DayIdxOfCalendarUnit):
     """
     DateModifier class to get the idx-th day of month of an input date
 
@@ -133,9 +107,6 @@ 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 __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)
@@ -143,7 +114,7 @@ class DayIdxOfMonth(_DayIdxOfCalendarUnit):
 
 
 @dataclass
-class DayIdxOfWeek(_DayIdxOfCalendarUnit):
+class DayIdxOfWeek(DayIdxOfCalendarUnit):
     """
     DateModifier class to get the idx-th day of week of an input date
 
@@ -151,12 +122,11 @@ 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
+    first_day_of_week: DayOfWeekEnum = DayOfWeekEnum.Monday
 
-    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 __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
@@ -164,17 +134,16 @@ class DayIdxOfWeek(_DayIdxOfCalendarUnit):
         return date + relativedelta(days=total_incr)
 
 
-class _OffsetUnits(DateModifier):
+@dataclass
+class OffsetUnits(DateModifier):
     """
     Abstract DateModifier class to offset an input date by some number of some calendar unit
     """
-    def __init__(self, offset: int) -> None:
-        super().__init__()
-        self.offset = offset
+    offset: int
 
 
 @dataclass
-class OffsetYears(_OffsetUnits):
+class OffsetYears(OffsetUnits):
     """
     DateModifier class to offset an input date by some number of years
 
@@ -182,15 +151,12 @@ class OffsetYears(_OffsetUnits):
         offset: The number of years to offset the input date.
     """
 
-    def __init__(self, offset: int) -> None:
-        super().__init__(offset)
-
     def modify(self, date: Date) -> Date:
         return date + relativedelta(years=self.offset)
     
 
 @dataclass
-class OffsetMonths(_OffsetUnits):
+class OffsetMonths(OffsetUnits):
     """
     DateModifier class to offset an input date by some number of months
 
@@ -198,15 +164,12 @@ class OffsetMonths(_OffsetUnits):
         offset: The number of months to offset the input date.
     """
 
-    def __init__(self, offset: int) -> None:
-        super().__init__(offset)
-
     def modify(self, date: Date) -> Date:
         return date + relativedelta(months=self.offset)
 
 
 @dataclass
-class OffsetWeeks(_OffsetUnits):
+class OffsetWeeks(OffsetUnits):
     """
     DateModifier class to offset an input date by some number of weeks
 
@@ -214,15 +177,12 @@ class OffsetWeeks(_OffsetUnits):
         offset: The number of weeks to offset the input date.
     """
 
-    def __init__(self, offset: int) -> None:
-        super().__init__(offset)
-
     def modify(self, date: Date) -> Date:
         return date + relativedelta(weeks=self.offset)
 
 
 @dataclass
-class OffsetDays(_OffsetUnits):
+class OffsetDays(OffsetUnits):
     """
     DateModifier class to offset an input date by some number of days
 
@@ -230,9 +190,6 @@ class OffsetDays(_OffsetUnits):
         offset: The number of days to offset the input date.
     """
 
-    def __init__(self, offset: int) -> None:
-        super().__init__(offset)
-
     def modify(self, date: Date) -> Date:
         return date + relativedelta(days=self.offset)
 
@@ -245,14 +202,10 @@ class DateModPipeline(DateModifier):
     Attributes:
         modifiers: The list of DateModifier's to apply in sequence.
     """
-    _date_modifiers: Sequence[DateModifier]
+    date_modifiers: Sequence[DateModifier]
 
-    def __init__(self, date_modifiers: Sequence[DateModifier]) -> None:
-        super().__init__()
-        self._date_modifiers = tuple(date_modifiers)
-    
     def modify(self, date: Date) -> Date:
-        for modifier in self._date_modifiers:
+        for modifier in self.date_modifiers:
             date = modifier.modify(date)
         return date
     
@@ -267,7 +220,7 @@ class DateModPipeline(DateModifier):
         Returns:
             A new sequence of DateModifier
         """
-        joined_modifiers = tuple(self._date_modifiers) + tuple(date_modifiers)
+        joined_modifiers = tuple(self.date_modifiers) + tuple(date_modifiers)
         return joined_modifiers
 
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
@@ -300,9 +253,9 @@ class DateModPipeline(DateModifier):
         Returns:
             A list of datetime objects
         """
-        assert isinstance(step, _OffsetUnits)
+        assert isinstance(step, OffsetUnits)
         if step.offset == 0:
-            raise u.ConfigurationError(f"The length of 'step' must not be zero")
+            raise ValueError(f"The length of 'step' must not be zero")
         
         output: Sequence[Date] = []
         end_date = self.modify(start_date)
@@ -315,12 +268,15 @@ class DateModPipeline(DateModifier):
         return output
 
 
-class _DateRepresentationModifier(metaclass=ABCMeta):
+@dataclass
+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)
+    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]):
@@ -328,7 +284,7 @@ class _DateRepresentationModifier(metaclass=ABCMeta):
 
 
 @dataclass
-class DateStringModifier(_DateRepresentationModifier):
+class DateStringModifier(DateRepresentationModifier):
     """
     Class to modify a string representation of a date given a DateModifier
 
@@ -336,12 +292,7 @@ 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
+    date_format: str = '%Y-%m-%d'
 
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
         """
@@ -353,11 +304,11 @@ class DateStringModifier(_DateRepresentationModifier):
         Returns:
             A new DateStringModifier
         """
-        joined_modifiers = self.date_modifier.get_joined_modifiers(date_modifiers)
-        return DateStringModifier(joined_modifiers, self._date_format)
+        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
+        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:
@@ -372,7 +323,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_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]:
         """
@@ -392,14 +343,14 @@ class DateStringModifier(_DateRepresentationModifier):
         Returns:
             A list of date strings
         """
-        assert isinstance(step, _OffsetUnits)
+        assert isinstance(step, OffsetUnits)
         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]
+        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 TimestampModifier(DateRepresentationModifier):
     """
     Class to modify a numeric representation of a date (as Unix/Epoch/POSIX timestamp) given a DateModifier
 
@@ -407,10 +358,6 @@ 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)
 
     def with_more_modifiers(self, date_modifiers: Sequence[DateModifier]):
         """
@@ -422,7 +369,7 @@ class TimestampModifier(_DateRepresentationModifier):
         Returns:
             A new TimestampModifier
         """
-        joined_modifiers = self.date_modifier.get_joined_modifiers(date_modifiers)
+        joined_modifiers = self.date_mod_pipeline.get_joined_modifiers(date_modifiers)
         return TimestampModifier(joined_modifiers)
 
     def modify(self, timestamp: float) -> float:
@@ -436,7 +383,7 @@ class TimestampModifier(_DateRepresentationModifier):
             The resulting timestamp
         """
         date_obj = datetime.fromtimestamp(timestamp).date()
-        modified_date = self.date_modifier.modify(date_obj)
+        modified_date = self.date_mod_pipeline.modify(date_obj)
         modified_datetime = datetime.combine(modified_date, datetime.min.time())
         return modified_datetime.timestamp()
     
@@ -458,5 +405,5 @@ class TimestampModifier(_DateRepresentationModifier):
             A list of timestamp as floats
         """
         curr_date = datetime.fromtimestamp(start_timestamp).date()
-        output = self.date_modifier.get_date_list(curr_date, step)
+        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/_command_line.py

@@ -1,5 +1,5 @@
 from argparse import ArgumentParser, _SubParsersAction
-import sys, asyncio, traceback, io, os, subprocess
+import sys, asyncio, traceback, io, subprocess
 
 sys.path.append('.')
 
@@ -11,10 +11,12 @@ from ._project import SquirrelsProject
 from . import _constants as c, _utils as u
 
 
-def _run_duckdb_cli(project: SquirrelsProject):
+def _run_duckdb_cli(project: SquirrelsProject, ui: bool):
     _, target_init_path = u._read_duckdb_init_sql()
     init_args = f"-init {target_init_path}" if target_init_path else ""
     command = ['duckdb']
+    if ui:
+        command.append('-ui')
     if init_args:
         command.extend(init_args.split())
     command.extend(['-readonly', project._duckdb_venv_path])
@@ -48,21 +50,22 @@ def main():
 
     init_parser = add_subparser(subparsers, c.INIT_CMD, 'Create a new squirrels project')
     
-    init_parser.add_argument('name', nargs='?', type=str, help='The name of the project')
-    init_parser.add_argument('-o', '--overwrite', action='store_true', help="Overwrite files that already exist")
-    init_parser.add_argument('--core', action='store_true', help='Include all core files')
+    init_parser.add_argument('name', nargs='?', type=str, help='The name of the project folder to create. Ignored if --curr-dir is used')
+    init_parser.add_argument('--curr-dir', action='store_true', help='Create the project in the current directory')
+    init_parser.add_argument('--use-defaults', action='store_true', help='Use default values for unspecified options (except project folder name) instead of prompting for input')
     init_parser.add_argument('--connections', type=str, choices=c.CONF_FORMAT_CHOICES, help=f'Configure database connections as yaml (default) or python')
     init_parser.add_argument('--parameters', type=str, choices=c.CONF_FORMAT_CHOICES, help=f'Configure parameters as python (default) or yaml')
     init_parser.add_argument('--build', type=str, choices=c.FILE_TYPE_CHOICES, help='Create build model as sql (default) or python file')
     init_parser.add_argument('--federate', type=str, choices=c.FILE_TYPE_CHOICES, help='Create federated model as sql (default) or python file')
-    init_parser.add_argument('--dashboard', action='store_true', help=f'Include a sample dashboard file')
+    init_parser.add_argument('--dashboard', type=str, choices=['y', 'n'], help=f'Include (y) or exclude (n, default) a sample dashboard file')
+    init_parser.add_argument('--admin-password', type=str, help='The password for the admin user. If --use-defaults is used, then a random password is generated')
 
     def with_file_format_options(parser: ArgumentParser):
         help_text = "Create model as sql (default) or python file"
         parser.add_argument('--format', type=str, choices=c.FILE_TYPE_CHOICES, default=c.SQL_FILE_TYPE, help=help_text)
         return parser
     
-    get_file_help_text = "Get a sample file for the squirrels project. If the file name already exists, it will be prefixed with a timestamp."
+    get_file_help_text = "Get a sample file for the squirrels project. If the file name already exists, it will be suffixed with a timestamp."
     get_file_parser = add_subparser(subparsers, c.GET_FILE_CMD, get_file_help_text)
     get_file_subparsers = get_file_parser.add_subparsers(title='file_name', dest='file_name')
     add_subparser(get_file_subparsers, c.DOTENV_FILE, f'Get sample {c.DOTENV_FILE} and {c.DOTENV_FILE}.example files')
@@ -104,6 +107,7 @@ def main():
     build_parser.add_argument('--stage', type=str, help='If the venv file is in use, stage the duckdb file to replace the venv later')
 
     duckdb_parser = add_subparser(subparsers, c.DUCKDB_CMD, 'Run the duckdb command line tool')
+    duckdb_parser.add_argument('--ui', action='store_true', help='Run the duckdb local UI')
 
     run_parser = add_subparser(subparsers, c.RUN_CMD, 'Run the API server')
     run_parser.add_argument('--build', action='store_true', help='Build the virtual data environment (with duckdb) first before running the API server')
@@ -116,7 +120,7 @@ def main():
     if args.version:
         print(__version__)
     elif args.command == c.INIT_CMD:
-        Initializer(project_name=args.name, overwrite=args.overwrite).init_project(args)
+        Initializer(project_name=args.name, use_curr_dir=args.curr_dir).init_project(args)
     elif args.command == c.GET_FILE_CMD:
         Initializer().get_file(args)
     elif args.command is None:
@@ -131,7 +135,7 @@ def main():
                 asyncio.run(task)
                 print()
             elif args.command == c.DUCKDB_CMD:
-                _run_duckdb_cli(project)
+                _run_duckdb_cli(project, args.ui)
             elif args.command == c.RUN_CMD:
                 if args.build:
                     task = project.build(full_refresh=True)