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

squirrels/_parameter_set.py

@@ -1,151 +0,0 @@
-from __future__ import annotations
-from typing import Sequence, Dict, Any
-from collections import OrderedDict
-
-from squirrels import data_sources as d, parameters as p
-from squirrels._timed_imports import pandas as pd
-
-
-class ParameterSetBase:
-    def __init__(self) -> None:
-        """
-        Constructor for ParameterSetBase, the base class for ParameterSet. Similar to ParameterSet but without 
-        a separate collection for DataSourceParameter's, and does not pre-set the parameters in constructor.
-        """
-        self._parameters_dict: OrderedDict[str, p.Parameter] = OrderedDict()
-    
-    def add_parameter(self, parameter: p.Parameter) -> None:
-        """
-        Adds a parameter to the "parameter collection"
-
-        Parameters:
-            parameter: The parameter to add
-        """
-        self._parameters_dict[parameter.name] = parameter
-
-    def get_parameter(self, param_name: str) -> p.Parameter:
-        """
-        Gets the Parameter object given the parameter name
-
-        Parameters:
-            param_name: The parameter name
-        
-        Returns:
-            The Parameter object corresponding to the parameter name
-        """
-        if param_name in self._parameters_dict:
-            return self._parameters_dict[param_name]
-        else:
-            raise KeyError(f'No such parameter exists called "{param_name}"')
-    
-    def __getitem__(self, param_name: str) -> p.Parameter:
-        return self.get_parameter(param_name)
-    
-    def get_parameters_as_ordered_dict(self) -> OrderedDict[str, p.Parameter]:
-        """
-        Returns the inner dictionary of the "parameter collection"
-
-        Returns:
-            A dictionary where key are the assigned names and values are the Parameter objects
-        """
-        return OrderedDict(self._parameters_dict)
-    
-    def merge(self, other: ParameterSetBase) -> ParameterSetBase:
-        """
-        Merges the "parameter collection" of this and another ParameterSetBase
-
-        Parameters:
-            other: The other ParameterSetBase
-        
-        Returns:
-            A new copy of the ParameterSetBase as a result of the merge
-        """
-        new_param_set = ParameterSetBase()
-        new_param_set._parameters_dict = OrderedDict(self._parameters_dict)
-        new_param_set._parameters_dict.update(other._parameters_dict)
-        return new_param_set
-
-    def to_json_dict(self, debug: bool = False) -> Dict[str, Any]:
-        """
-        Converts this object, and all parameters contained, into a JSON dictionary
-
-        Parameters:
-            debug: Set to True to make the "hidden" parameters show as part of the result
-
-        Returns:
-            A collection of parameters as a JSON dictionary used for the "parameters" endpoint
-        """
-        parameters = []
-        for x in self._parameters_dict.values():
-            if not x.is_hidden or debug:
-                parameters.append(x.to_json_dict())
-        
-        output = {
-            "response_version": 0, 
-            "parameters": parameters
-        }
-        return output
-
-
-class ParameterSet(ParameterSetBase):
-    def __init__(self, parameters: Sequence[p.Parameter]):
-        """
-        Constructor for ParameterSet, a wrapper class for a sequence of parameters, 
-        and stores the DataSourceParameters as a separate field as well
-
-        Parameters:
-            parameters: A sequence of parameters
-        """
-        super().__init__()
-        self._data_source_params: OrderedDict[str, p.DataSourceParameter] = OrderedDict()
-        for param in parameters:
-            self._parameters_dict[param.name] = param
-            if isinstance(param, p.DataSourceParameter):
-                self._data_source_params[param.name] = param
-    
-    def merge(self, other: ParameterSetBase) -> ParameterSet:
-        """
-        Merges this object with another ParameterSet (by combining the parameters) to create a new ParameterSet.
-
-        The _parameters_dict are merged (with the other ParameterSet taking precedence when a name exist in both dict),
-        while the _data_source_params are only taken from this object. This object and the other ParameterSet remain
-        unchanged.
-
-        Parameters:
-            other: The other parameter set
-        
-        Returns:
-            A new ParameterSet that contains all the parameters from this and the other parameter set.
-        """
-        new_param_set_base = super().merge(other)
-        new_param_set = ParameterSet(())
-        new_param_set._parameters_dict = new_param_set_base._parameters_dict
-        new_param_set._data_source_params = self._data_source_params
-        return new_param_set
-
-    def get_datasources(self) -> Dict[str, d.DataSource]:
-        """
-        Gets all the DataSource objects as values to a dictionary where keys are the DataSource parameter names.
-
-        Each DataSource object represents a lookup table with table name, connection name, corresponding columns to ID, label, etc.
-
-        Returns:
-            A dictionary where keys are the names of DataSourceParameter's and values are the corresponding DataSource.
-        """
-        new_dict = {}
-        for param_name, ds_param in self._data_source_params.items():
-            new_dict[param_name] = ds_param.data_source
-        return new_dict
-
-    def convert_datasource_params(self, df_dict: Dict[str, pd.DataFrame]) -> None:
-        """
-        Changes all the DataSourceParameters into other Parameter types. The _data_source_params field gets cleared.
-
-        Parameters:
-            df_dict: A dictionary of DataSourceParameter name to the pandas DataFrame of the lookup table data.
-        """
-        # Done sequentially since parents must be converted first before children
-        for key, ds_param in self._data_source_params.items():
-            ds_param.parent = self.get_parameter(ds_param.parent.name) if ds_param.parent is not None else None
-            self._parameters_dict[key] = ds_param.convert(df_dict[key])
-        self._data_source_params.clear()

squirrels/_renderer.py

@@ -1,286 +0,0 @@
-from typing import Dict, Tuple, Optional, Union, Callable, Any
-from functools import partial
-from configparser import ConfigParser
-import concurrent.futures, os, json, time
-
-from squirrels import _constants as c, _manifest as mf, _utils
-from squirrels.connection_set import ConnectionSet, sqldf
-from squirrels.data_sources import DataSource
-from squirrels._parameter_set import ParameterSet
-from squirrels._utils import ConfigurationError
-from squirrels._timed_imports import pandas as pd, timer
-
-ContextFunc = Optional[Callable[..., Dict[str, Any]]]
-DatabaseViews = Optional[Dict[str, pd.DataFrame]]
-Query = Union[Callable[..., pd.DataFrame], str]
-
-
-class Renderer:
-    def __init__(self, dataset: str, manifest: mf.Manifest, conn_set: ConnectionSet, raw_param_set: ParameterSet, 
-                 context_func: Callable[..., Dict[str, Any]], raw_query_by_db_view: Dict[str, Query], 
-                 raw_final_view_query: Query, excel_file: Optional[pd.ExcelFile] = None):
-        self.dataset = dataset
-        self.manifest = manifest
-        self.conn_set = conn_set
-        self.context_func = context_func
-        self.raw_query_by_db_view = raw_query_by_db_view
-        self.raw_final_view_query = raw_final_view_query
-
-        start = time.time()
-        self.param_set: ParameterSet = self._convert_param_set_datasources(raw_param_set, excel_file)
-        timer.add_activity_time(f"convert datasources - dataset {dataset}", start)
-    
-    def _convert_param_set_datasources(self, param_set: ParameterSet, excel_file: Optional[pd.ExcelFile] = None) -> ParameterSet:
-        datasources = param_set.get_datasources()
-        if excel_file is not None:
-            df_dict = pd.read_excel(excel_file, None)
-            for key in datasources:
-                if key not in df_dict:
-                    raise ConfigurationError('No sheet found for parameter "{key}" in the Excel workbook')
-        else:
-            def get_dataframe_from_query(item: Tuple[str, DataSource]) -> pd.DataFrame:
-                key, datasource = item
-                df = self.conn_set.get_dataframe_from_query(datasource.connection_name, datasource.get_query())
-                return key, df
-            
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                df_dict = dict(executor.map(get_dataframe_from_query, datasources.items()))
-        
-        param_set.convert_datasource_params(df_dict)
-        return param_set
-    
-    def apply_selections(self, selections: Dict[str, str], updates_only: bool = False) -> ParameterSet:
-        start = time.time()
-        parameter_set = self.param_set
-        parameters_dict = parameter_set.get_parameters_as_ordered_dict()
-        
-        # iterating through parameters dict instead of query_params since order matters for cascading parameters
-        for param_name, parameter in parameters_dict.items():
-            if param_name in selections:
-                value = selections[param_name]
-                parameter = parameter_set.get_parameter(param_name).with_selection(value)
-                updates = parameter.get_all_dependent_params()
-                if updates_only:
-                    parameter_set = updates
-                    break
-                parameter_set = parameter_set.merge(updates)
-        timer.add_activity_time(f"apply selections - dataset {self.dataset}", start)
-        
-        return parameter_set
-
-    def _render_context(self, context_func: ContextFunc, param_set: ParameterSet) -> Dict[str, Any]:
-        try:
-            return context_func(prms=param_set.get_parameters_as_ordered_dict()) if context_func is not None else {}
-        except Exception as e:
-            raise ConfigurationError(f'Error in the {c.CONTEXT_FILE} function for dataset "{self.dataset}"') from e
-    
-    def _get_args(self, param_set: ParameterSet, context: Dict[str, Any], db_view: str = None) -> Dict:
-        if db_view is not None:
-            args = self.manifest.get_view_args(self.dataset, db_view)
-        else:
-            args = self.manifest.get_view_args(self.dataset)
-        return {
-            'prms': param_set.get_parameters_as_ordered_dict(),
-            'ctx':  context,
-            'args': args
-        }
-    
-    def _render_query_from_raw(self, raw_query: Query, args: Dict) -> Query:
-        if isinstance(raw_query, str):
-            template = _utils.j2_env.from_string(raw_query)
-            return template.render(args)
-        else:
-            return partial(raw_query, **args)
-    
-    def _render_dataframe_from_sql(self, db_view_name: str, sql_str: str, 
-                                   database_views: DatabaseViews = None) -> pd.DataFrame:
-        if database_views is not None:
-            return sqldf(sql_str, database_views)
-        else:
-            conn_name = self.manifest.get_database_view_db_connection(self.dataset, db_view_name)
-            return self.conn_set.get_dataframe_from_query(conn_name, sql_str)
-
-    def _render_dataframe_from_py_func(self, db_view_name: str, py_func: Callable[[Any], pd.DataFrame], 
-                                       database_views: DatabaseViews = None) -> pd.DataFrame:
-        if database_views is not None:
-            try:
-                return py_func(database_views=database_views)
-            except Exception as e:
-                raise ConfigurationError(f'Error in the final view python function for dataset "{self.dataset}"') from e
-        else:
-            conn_name = self.manifest.get_database_view_db_connection(self.dataset, db_view_name)
-            connection_pool = self.conn_set.get_connection_pool(conn_name)
-            try:
-                return py_func(connection_pool=connection_pool, connection_set=self.conn_set)
-            except Exception as e:
-                raise ConfigurationError(f'Error in the python function for database view "{db_view_name}" in dataset "{self.dataset}"') from e
-    
-    def _render_db_view_dataframes(self, query_by_db_view: Dict[str, Query]) -> Dict[str, pd.DataFrame]:
-        def run_single_query(item: Tuple[str, Query]) -> Tuple[str, pd.DataFrame]:
-            view_name, query = item
-            if isinstance(query, str):
-                return view_name, self._render_dataframe_from_sql(view_name, query)
-            else:
-                return view_name, self._render_dataframe_from_py_func(view_name, query)
-        
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            df_by_view_name = executor.map(run_single_query, query_by_db_view.items())
-        
-        return dict(df_by_view_name)
-    
-    def _render_final_view_dataframe(self, df_by_db_views: Dict[str, pd.DataFrame], 
-                                    final_view_query: Optional[Query]) -> pd.DataFrame:
-        if final_view_query in df_by_db_views:
-            return df_by_db_views[final_view_query]
-        elif isinstance(final_view_query, str):
-            return self._render_dataframe_from_sql("final_view", final_view_query, df_by_db_views)
-        else:
-            return self._render_dataframe_from_py_func("final_view", final_view_query, df_by_db_views)
-
-    def load_results(self, selections: Dict[str, str], run_query: bool = True) \
-        -> Tuple[ParameterSet, Dict[str, Query], Query, Dict[str, pd.DataFrame], Optional[pd.DataFrame]]:
-        
-        # apply selections and render context
-        param_set = self.apply_selections(selections)
-        start = time.time()
-        context = self._render_context(self.context_func, param_set)
-        timer.add_activity_time(f"render context - dataset {self.dataset}", start)
-
-        # render database view queries
-        start = time.time()
-        query_by_db_view = {}
-        for db_view, raw_query in self.raw_query_by_db_view.items():
-            args = self._get_args(param_set, context, db_view)
-            query_by_db_view[db_view] = self._render_query_from_raw(raw_query, args)
-        timer.add_activity_time(f"render database view queries - dataset {self.dataset}", start)
-
-        # render final view query
-        start = time.time()
-        args = self._get_args(param_set, context)
-        final_view_query = self._render_query_from_raw(self.raw_final_view_query, args)
-        timer.add_activity_time(f"render final view query - dataset {self.dataset}", start)
-
-        # render all dataframes if "run_query" is enabled
-        df_by_db_views = {}
-        final_view_df = None
-        if run_query:
-            start = time.time()
-            df_by_db_views = self._render_db_view_dataframes(query_by_db_view)
-            timer.add_activity_time(f"execute dataview view queries - dataset {self.dataset}", start)
-
-            start = time.time()
-            final_view_df = self._render_final_view_dataframe(df_by_db_views, final_view_query)
-            timer.add_activity_time(f"execute final view query - dataset {self.dataset}", start)
-        
-        return param_set, query_by_db_view, final_view_query, df_by_db_views, final_view_df
-
-
-def default_context_func(*args, **kwargs):
-    return {}
-
-
-class RendererIOWrapper:
-    def __init__(self, dataset: str, manifest: mf.Manifest, conn_set: ConnectionSet, excel_file_name: Optional[str] = None):
-        dataset_folder = manifest.get_dataset_folder(dataset)
-        parameters_path = _utils.join_paths(dataset_folder, c.PARAMETERS_FILE)
-        args = manifest.get_dataset_args(dataset)
-        parameters_module = _utils.import_file_as_module(parameters_path)
-        try:
-            parameter_set = ParameterSet(parameters_module.main(args=args))
-        except Exception as e:
-            raise ConfigurationError(f'Error in the {c.PARAMETERS_FILE} function for dataset "{dataset}"') from e
-
-        context_path = _utils.join_paths(dataset_folder, c.CONTEXT_FILE)
-        try:
-            context_module = _utils.import_file_as_module(context_path)
-            context_func = partial(context_module.main, args=args)
-        except FileNotFoundError:
-            context_func = default_context_func
-        
-        excel_file = None
-        if excel_file_name is not None:
-            excel_file_path = _utils.join_paths(dataset_folder, excel_file_name)
-            excel_file = pd.ExcelFile(excel_file_path)
-        
-        db_views = manifest.get_all_database_view_names(dataset)
-        raw_query_by_db_view = {}
-        for db_view in db_views:
-            db_view_template_path = str(manifest.get_database_view_file(dataset, db_view))
-            raw_query_by_db_view[db_view] = self._get_raw_query(db_view_template_path)
-        
-        final_view_path = str(manifest.get_dataset_final_view_file(dataset))
-        if final_view_path in db_views:
-            raw_final_view_query = final_view_path
-        else:
-            raw_final_view_query = self._get_raw_query(final_view_path)
-        
-        self.dataset_folder = dataset_folder
-        self.output_folder = _utils.join_paths(c.OUTPUTS_FOLDER, dataset)
-        self.renderer = Renderer(dataset, manifest, conn_set, parameter_set, context_func,
-                                 raw_query_by_db_view, raw_final_view_query, excel_file)
-    
-    def _get_raw_query(self, template_path: str) -> Dict[str, Query]:
-        if template_path.endswith(".py"):
-            return _utils.import_file_as_module(template_path).main
-        else:
-            with open(template_path, 'r') as f:
-                sql_template = f.read()
-            return sql_template
-
-    def _get_selections(self, selection_cfg_file: Optional[str]) -> Dict[str, str]:
-        if selection_cfg_file is not None:
-            selection_cfg_path = _utils.join_paths(self.dataset_folder, selection_cfg_file)
-            config = ConfigParser()
-            config.read(selection_cfg_path)
-            if config.has_section(c.PARAMETERS_SECTION):
-                config_section = config[c.PARAMETERS_SECTION]
-                return dict(config_section.items())
-        return {}
-
-    def _write_sql_file(self, view_name: str, query: Any):
-        if isinstance(query, str):
-            db_view_sql_output_path = _utils.join_paths(self.output_folder, view_name+'.sql')
-            with open(db_view_sql_output_path, 'w') as f:
-                f.write(query)
-    
-    def write_outputs(self, selection_cfg_file: Optional[str], run_query: bool) -> None:
-        # create output folder if it doesn't exist
-        if not os.path.exists(self.output_folder):
-            os.makedirs(self.output_folder)
-        
-        # clear everything in output folder
-        files = os.listdir(self.output_folder)
-        for file in files:
-            file_path = _utils.join_paths(self.output_folder, file)
-            os.remove(file_path)
-        
-        # apply selections and render outputs
-        selections = self._get_selections(selection_cfg_file)
-        result = self.renderer.load_results(selections, run_query)
-        param_set, query_by_db_view, final_view_query, df_by_db_views, final_view_df = result
-        
-        # write the parameters response
-        param_set_dict = param_set.to_json_dict()
-        parameter_json_output_path = _utils.join_paths(self.output_folder, c.PARAMETERS_OUTPUT)
-        with open(parameter_json_output_path, 'w') as f:
-            json.dump(param_set_dict, f, indent=4)
-        
-        # write the rendered sql queries for database views
-        for db_view, query in query_by_db_view.items():
-            self._write_sql_file(db_view, query)
-
-        # write the rendered sql query for final view
-        if final_view_query not in query_by_db_view:
-            self._write_sql_file(c.FINAL_VIEW_OUT_STEM, final_view_query)
-        
-        # Run the sql queries and write output
-        if run_query:
-            for db_view, df in df_by_db_views.items():
-                csv_file = _utils.join_paths(self.output_folder, db_view+'.csv')
-                df.to_csv(csv_file, index=False)
-            
-            final_csv_path = _utils.join_paths(self.output_folder, c.FINAL_VIEW_OUT_STEM+'.csv')
-            final_view_df.to_csv(final_csv_path, index=False)
-
-            final_json_path = _utils.join_paths(self.output_folder, c.FINAL_VIEW_OUT_STEM+'.json')
-            final_view_df.to_json(final_json_path, orient='table', index=False, indent=4)

squirrels/_timed_imports.py

@@ -1,37 +0,0 @@
-from typing import Dict, List
-import time
-
-
-class Timer:
-    def __init__(self, verbose: bool = False):
-        self.times: Dict[str, List[float]] = dict()
-        self.verbose = verbose
-    
-    def add_activity_time(self, activity: str, start: float):
-        if self.verbose:
-            time_taken = (time.time()-start) * 10**3
-            times_list = self.times.setdefault(activity, list())
-            times_list.append(time_taken)
-            print(f'Time taken for "{activity}": {time_taken}ms')
-    
-    def report_times(self):
-        if self.verbose:
-            for activity, times_list in self.times.items():
-                total_time = sum(times_list)
-                avg_time = total_time / len(times_list)
-                print()
-                print(f'Time statistics for "{activity}":')
-                print(f'  Total time: {total_time}ms')
-                print(f'  Average time: {avg_time}ms')
-
-timer = Timer()
-
-
-start = time.time()
-import pandas
-from pandas.api import types as pd_types
-timer.add_activity_time("import pandas", start)
-
-start = time.time()
-import jinja2
-timer.add_activity_time("import jinja", start)

squirrels/connection_set.py

@@ -1,126 +0,0 @@
-from typing import Dict, Union
-from importlib.machinery import SourceFileLoader
-from sqlalchemy import Engine, Pool
-import sqlite3
-
-from squirrels import _constants as c, _manifest as mf
-from squirrels._timed_imports import pandas as pd
-from squirrels._utils import ConfigurationError
-
-ConnectionPool = Union[Engine, Pool]
-
-
-class ConnectionSet:
-    def __init__(self, conn_pools: Dict[str, ConnectionPool]) -> None:
-        """
-        Constructor for ConnectionSet, a wrapper class around a collection of Connection Pools or Sqlalchemy Engines
-
-        Parameters:
-            conn_pools: A dictionary of connection pool name to the corresponding Pool or Engine from sqlalchemy
-        """
-        self._conn_pools = conn_pools
-    
-    def get_connection_pool(self, conn_name: str = "default") -> ConnectionPool:
-        """
-        Gets to sqlalchemy Pool or Engine from the database connection name
-
-        Parameters:
-            conn_name: Name of Pool or Engine. If not provided, defaults to "default"
-        
-        Returns:
-            A sqlalchemy Pool or Engine
-        """
-        try:
-            connection_pool = self._conn_pools[conn_name]
-        except KeyError as e:
-            raise ConfigurationError(f'Connection name "{conn_name}" was not configured') from e
-        return connection_pool
-    
-    def __getitem__(self, conn_name: str) -> ConnectionPool:
-        """
-        Same as get_connection_pool
-        """
-        return self.get_connection_pool(conn_name)
-    
-    def get_dataframe_from_query(self, conn_name: str, query: str) -> pd.DataFrame:
-        """
-        Runs a SQL query on a database connection name, and returns the results as pandas DataFrame
-
-        Parameters:
-            conn_name: Name of Pool or Engine
-            query: The SQL query to run
-        
-        Returns:
-            A pandas DataFrame
-        """
-        connector = self.get_connection_pool(conn_name)
-        if isinstance(connector, Pool):
-            conn = connector.connect()
-        elif isinstance(connector, Engine):
-            conn = connector.raw_connection()
-        else:
-            raise TypeError(f'Type for connection name "{conn_name}" not supported')
-        
-        try:
-            cur = conn.cursor()
-            cur.execute(query)
-            df = pd.DataFrame(data=cur.fetchall(), columns=[x[0] for x in cur.description])
-        finally:
-            conn.close()
-
-        return df
-
-    def _dispose(self) -> None:
-        """
-        Disposes of all the connection pools in this ConnectionSet
-        """
-        for pool in self._conn_pools.values():
-            pool.dispose()
-
-
-def _from_file(manifest: mf.Manifest) -> ConnectionSet:
-    """
-    Takes the DB Connections from both the squirrels.yaml and connections.py files and merges them
-    into a single ConnectionSet
-
-    Parameters:
-        manifest: The object of Manifest class, the interface for the squirrels.yaml file
-    
-    Returns:
-        A ConnectionSet with the DB connections from both squirrels.yaml and connections.py
-    """
-    connections = manifest.get_db_connections()
-    try:
-        module = SourceFileLoader(c.CONNECTIONS_FILE, c.CONNECTIONS_FILE).load_module()
-    except FileNotFoundError:
-        module = None
-    
-    if module is not None:
-        proj_vars = manifest.get_proj_vars()
-        try:
-            conn_from_py_file = module.main(proj_vars)
-        except Exception as e:
-            raise ConfigurationError(f'Error in the {c.CONNECTIONS_FILE} file') from e
-    else:
-        conn_from_py_file = {}
-    return ConnectionSet({**connections, **conn_from_py_file})
-
-
-def sqldf(query: str, df_by_db_views: Dict[str, pd.DataFrame]) -> pd.DataFrame:
-    """
-    Uses a dictionary of dataframes to execute a SQL query in an in-memory sqlite database
-
-    Parameters:
-        query: The SQL query to run using sqlite
-        df_by_db_views: A dictionary of table names to their pandas Dataframe
-    
-    Returns:
-        The result as a pandas Dataframe from running the query
-    """
-    conn = sqlite3.connect(":memory:")
-    try:
-        for db_view, df in df_by_db_views.items():
-            df.to_sql(db_view, conn, index=False)
-        return pd.read_sql(query, conn)
-    finally:
-        conn.close()

squirrels/package_data/base_project/.gitignore

@@ -1,4 +0,0 @@
-__pycache__
-/outputs
-/modules
-/venv

squirrels/package_data/base_project/connections.py

@@ -1,21 +0,0 @@
-from typing import Dict, Union, Any
-from sqlalchemy import create_engine, Engine, Pool, QueuePool
-
-from squirrels import get_credential
-
-
-# Note: all connections must be shareable across multiple thread. No writes will occur on them
-def main(proj: Dict[str, Any], *p_args, **kwargs) -> Dict[str, Union[Engine, Pool]]:
-
-    # ## Example of getting the username and password set with "$ squirrels set-credential [key]"
-    # cred = get_credential('my_key')
-    # # Use cred.username and cred.password to access the username and password
-
-    # Create a connection pool / engine
-    pool = create_engine('sqlite:///./database/sample_database.db')
-
-    # ## Example of using QueuePool instead for a custom db connector:
-    # connection_creator = lambda: sqlite3.connect('./database/sample_database.db', check_same_thread=False)
-    # pool = QueuePool(connection_creator)
-    
-    return {'default': pool}

squirrels/package_data/base_project/datasets/sample_dataset/context.py

@@ -1,8 +0,0 @@
-from typing import Dict, Any
-import squirrels as sr
-
-
-def main(prms: Dict[str, sr.Parameter], args: Dict[str, Any], *p_args, **kwargs) -> Dict[str, Any]:
-    limit_parameter: sr.NumberParameter = prms['upper_bound']
-    limit: str = limit_parameter.get_selected_value()
-    return {'limit': limit}

squirrels/package_data/base_project/datasets/sample_dataset/database_view1.py

@@ -1,23 +0,0 @@
-from typing import Dict, Any
-import pandas as pd
-
-import squirrels as sr
-
-
-def main(connection_set: sr.ConnectionSet, 
-         prms: Dict[str, sr.Parameter], ctx: Dict[str, Any], args: Dict[str, Any], 
-         *p_args, **kwargs) -> pd.DataFrame:
-    # pool = connection_set.get_connection_pool("default")
-    # conn = pool.connect() # use this to get a DBAPI connection from a Pool or sqlalchemy connection from an Engine
-    # conn = pool.raw_connection() # use this to get a DBAPI connection from an Engine
-    
-    df = pd.DataFrame({
-        'dim1': ['a', 'b', 'c', 'd', 'e', 'f'], 
-        'metric1': [1, 2, 3, 4, 5, 6], 
-        'metric2': [2, 4, 5, 1, 7, 3]
-    })
-    limit_parameter: sr.NumberParameter = prms['upper_bound']
-    limit = limit_parameter.get_selected_value() 
-    # limit: str = ctx['limit'] # use this instead if context.py is defined
-
-    return df.query(f'metric1 <= {limit}')

squirrels/package_data/base_project/datasets/sample_dataset/database_view1.sql.j2

@@ -1,7 +0,0 @@
--- %USE some_db -- TBA: this line is optional when connecting to the "default" db_connection
-
--- note: if context.py is defined, you can use "ctx['limit']" instead of "prms['number_example'].get_selected_value()"
-SELECT dim1, avg(metric1) as metric1, avg(metric2) as metric2
-FROM fact_table
-WHERE metric1 <= {{ prms['upper_bound'].get_selected_value() }}
-GROUP BY dim1