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

squirrels/user_base.py

@@ -0,0 +1,58 @@
+from typing import Any
+from dataclasses import dataclass
+
+
+@dataclass
+class User:
+    """
+    Base class for extending the custom User model class
+
+    Attributes:
+        username: The identifier for the user
+        is_internal: Setting this to True lets the user access "private" datasets
+    """
+    username: str
+    is_internal: bool
+
+    def __init__(self, username: str, *, is_internal: bool = False, **kwargs):
+        """
+        Constructor for the User base class
+
+        Parameters:
+            ...see Attributes of User
+        """
+        self.username = username
+        self.is_internal = is_internal
+    
+    def __hash__(self) -> int:
+        return hash(self.username)
+    
+    def set_attributes(self, user_dict: dict[str, Any]) -> None:
+        """
+        Can be overwritten in "auth.py" to introduce custom attributes. Does nothing by default
+        """
+        pass
+    
+    def with_attributes(self, user_dict: dict[str, Any]):
+        self.set_attributes(user_dict)
+        return self
+    
+    @classmethod
+    def _FromDict(cls, user_dict: dict[str, Any]):
+        user = cls(username="TBA")
+        for key, val in user_dict.items():
+            setattr(user, key, val)
+        return user
+
+
+@dataclass
+class WrongPassword:
+    """
+    Return this object if the username was found but the password was incorrect
+
+    This ensures that if the username exists as a real user, we won't continue to use the environcfg.yml file to authenticate
+
+    Attributes:
+        username: The identifier for the user
+    """
+    username: str

squirrels-0.2.0.dev0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.1
+Name: squirrels
+Version: 0.2.0.dev0
+Summary: Squirrels - API Framework for Data Analytics
+Home-page: https://squirrels-nest.github.io/squirrels-docs/
+License: MIT
+Author: Tim Huang
+Author-email: tim.yuting@hotmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: cachetools (>=5.3.2,<6.0.0)
+Requires-Dist: cryptography (>=41.0.7,<42.0.0)
+Requires-Dist: fastapi (>=0.104.1,<0.105.0)
+Requires-Dist: gitpython (>=3.1.40,<4.0.0)
+Requires-Dist: inquirer (>=3.1.4,<4.0.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: pandas (>=2.1.4,<3.0.0)
+Requires-Dist: python-jose (>=3.3.0,<4.0.0)
+Requires-Dist: python-multipart (>=0.0.6,<0.0.7)
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: sqlalchemy (>=2.0.23,<3.0.0)
+Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0)
+Project-URL: Documentation, https://squirrels-nest.github.io/squirrels-docs/
+Project-URL: Repository, https://github.com/squirrels-nest/squirrels
+Description-Content-Type: text/markdown
+
+# Squirrels
+
+Squirrels is an API framework that lets you create REST APIs for dynamic data analytics!
+
+**Documentation**: <a href="https://squirrels-nest.github.io/squirrels-docs" target="_blank">https://squirrels-nest.github.io/squirrels-docs</a>
+
+**Source Code**: <a href="https://github.com/squirrels-nest/squirrels" target="_blank">https://github.com/squirrels-nest/squirrels</a>
+
+## Table of Contents
+
+- [Main Features](#main-features)
+- [License](#license)
+- [Contributing to squirrels](#contributing-to-squirrels)
+    - [Setup](#setup)
+    - [Testing](#testing)
+    - [Project Structure](#project-structure)
+
+## Main Features
+
+Here are a few of the things that squirrels can do:
+
+- Connect to any database by specifying its sqlalchemy url without code (in `squirrels.yml`) or by using its native connector library in python (in `connections.py`).
+- Configure API routes without code (in `squirrels.yml`) for all datasets.
+- Configure parameter widgets (types include single-select, multi-select, date, number, etc.) for your datasets (in `parameters.py`).
+- Use Jinja SQL templates (just like dbt!) or python functions (that return a pandas dataframe) to define dynamic query logic based on parameter selections.
+- Query multiple databases and join the results together in a final view in one API endpoint/dataset!
+- Test your API endpoints with an interactive UI or by a command line that generates rendered sql queries and results (for a given set of parameter selections).
+- Define authentication logic (in `auth.py`) and authorize privacy scope per dataset (in `squirrels.yml`). The user's attributes can even be used in your query logic!
+
+## License
+
+Squirrels is released under the MIT license.
+
+See the file LICENSE for more details.
+
+## Contributing to squirrels
+
+The sections below describe how to set up your local environment for squirrels development and run unit tests. A high level overview of the project structure is also provided.
+
+### Setup
+
+This project requires python version 3.9 or above to be installed. It also uses the python build tool `poetry` which can be installed as follows.
+
+**Linux, MacOS, Windows (WSL):**
+
+```bash
+curl -sSL https://install.python-poetry.org | python3 -
+```
+
+**Windows (Powershell):**
+
+```bash
+(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -
+```
+
+Then, to install all dependencies, run:
+
+```
+poetry install
+```
+
+And activate the virtual environment created by poetry with:
+
+```
+poetry shell
+```
+
+To confirm that the setup worked, run the following to show the help page for all squirrels CLI commands:
+
+```bash
+squirrels -h
+```
+
+You can enter `exit` to exit the virtual environment shell. You can also run `poetry run squirrels -h` to run squirrels commands without activating the virtual environment.
+
+### Testing
+
+In poetry's virtual environment, run `pytest`.
+
+### Project Structure
+
+From the root of the git repo, the source code can be found in the `squirrels` folder and unit tests can be found in the `tests` folder.
+
+To understand what a specific squirrels command is doing, start from the `_command_line.py` file as your entry point.
+
+The library version is maintained in both the `pyproject.toml` and the `squirrels/__init__.py` files.
+
+When a user initializes a squirrels project using `squirrels init`, the files are copied from the `squirrels/package_data/base_project` folder. The contents in the `database` subfolder were constructed from the scripts in the `database_elt` folder.
+
+For the Squirrels UI activated by `squirrels run`, the HTML, CSS, and Javascript files can be found in the `static` and `templates` subfolders of `squirrels/package_data`.
+

squirrels-0.2.0.dev0.dist-info/RECORD

@@ -0,0 +1,56 @@
+squirrels/__init__.py,sha256=SpcfLD5xBY5xxbf00E1Mpo7Ty57P4fm1yXBRaX0S2Rw,756
+squirrels/_api_server.py,sha256=bg6dslizgzNerVUl7uxSL2fsl7ldItWHIeXzDxZ1rQA,14552
+squirrels/_authenticator.py,sha256=77hcm6vPsxIboaa1JaglJ3_Rnh24zYvMjy-OYCtJaos,3569
+squirrels/_command_line.py,sha256=i6e9A2bHRYqiVXNunr02wIWUWOV7uTzXEHhwaW420rM,5727
+squirrels/_connection_set.py,sha256=tg27ZgHnRbFssVltaaSlmtc7rHyu1jz3EJ2aoMkgvMc,3410
+squirrels/_constants.py,sha256=_sUSLmd-cGW6k0tUmdx23bfHKOesK19zk_1U3Ymdm8M,3944
+squirrels/_environcfg.py,sha256=YR2mJ9s4wSxsxdJmd17Gk2WjslsBkpvJYnLx4RYgWPU,2743
+squirrels/_initializer.py,sha256=bGEiKQ_4q1oXpV11HkwzgY8kdHkRl0L5gcE_wbo31wI,7812
+squirrels/_manifest.py,sha256=R9SZNCcAJlBqNW2gkcvKzqFV5LUs5m5RN2tDlMpfP3M,7757
+squirrels/_models.py,sha256=3tfx4oDfvI46tjXrv2WqcWGq2TEdVRWNnBPWOX1jUSo,20641
+squirrels/_package_loader.py,sha256=-EZ8qsmp6QEdZyHUKYi5e4OPOx3EnL2rxr1IYe1NwEI,1020
+squirrels/_parameter_configs.py,sha256=vFoziu8sP_EA03Kazr0-WpQK3LalHud-zUzy5TzD_AY,16925
+squirrels/_parameter_sets.py,sha256=3NPQmB-1gqbmfBoMwCDWDUCChNa4zNZ74zihXA-mUYM,9041
+squirrels/_py_module.py,sha256=dFoOt53WUtDdZHR-ePbLTnQSNTqe0k_AjT-BOOmpAHc,2559
+squirrels/_timer.py,sha256=gwsp5pDjOJZoAGv8LiCsr7B3av5EYeGGCVHUzWUfiiQ,1398
+squirrels/_utils.py,sha256=7JA5ZOJMkTAktT4r9QbOCwBrtbcsqtFIdiE-_Th09RA,5262
+squirrels/_version.py,sha256=ySOetuKYm0mnm1J9-D3IcEZkf4kFrP8SVDKX97awBxo,109
+squirrels/arguments/init_time_args.py,sha256=EiK5O4JSLMWJLbcrzwOP8UTLCWIb4GRdLNAV_WmQu94,706
+squirrels/arguments/run_time_args.py,sha256=ZmQtX06FeuG3s5yo6BzdRonEgohVy0XQcDOfHl9THdI,2728
+squirrels/data_sources.py,sha256=0BnCXcZg-IjccCwNialPXnFl-o8qbt9j_M3fjGUcC0U,25557
+squirrels/dateutils.py,sha256=o-jQ0p3wGKomzFVn59qDdaadLtzKPeyXyKSfm0GMQPs,16487
+squirrels/package_data/base_project/Dockerfile,sha256=kJHFKeQ7V5rHK5twGBPSFGkHIPvakpYpiCujhcO_-iU,484
+squirrels/package_data/base_project/connections.yml,sha256=0xAnpOKoEsDVWjsznh8y9YMBxSfDtDnmLQbNVq34GdU,299
+squirrels/package_data/base_project/database/expenses.db,sha256=MzNEY2WFJBGZJiyCH-NGgj8epg0idbMH-fdOnQIFcqQ,36864
+squirrels/package_data/base_project/database/seattle_weather.db,sha256=PldWB7PLY_ltY-OWxN9ALcFEdiVDaP3Kef0I2k7WPso,188416
+squirrels/package_data/base_project/environcfg.yml,sha256=c_5YRPMFfHzNNpqBnjpdxeKmR1qNS0jQL1buINPWsd4,852
+squirrels/package_data/base_project/ignores/.dockerignore,sha256=sY6T-_UtTVw1jFBOfiMQ8XFS9191YqEotxYPCEsdNJ4,90
+squirrels/package_data/base_project/ignores/.gitignore,sha256=lY0WxUkktLwaEhtyh5ynLTlg1ucigzMV7x6rifn734g,85
+squirrels/package_data/base_project/models/dbviews/database_view1.py,sha256=1ZMbuwi4k-n-_7Eyavo43w0SO3aX_X--BmO6Sfbw2nw,1750
+squirrels/package_data/base_project/models/dbviews/database_view1.sql,sha256=uTo-SoRn5TgNQ3R_sqcxCoNDJg1w7TBW44Lt6r1zfns,492
+squirrels/package_data/base_project/models/federates/dataset_example.py,sha256=7OGgPS-m1nkRhF3JfF8T1XEEM-gJL2RGfthZe-Ct0pk,686
+squirrels/package_data/base_project/models/federates/dataset_example.sql,sha256=cH9rVjXEJIFcxqZpW8dCvHLf_c-YwDuiGlcjoTIy6CM,78
+squirrels/package_data/base_project/parameters.yml,sha256=v0ujjvm2VWSyt5u02fiGqRCrQMN3gZKT89tHk2f8Imc,4445
+squirrels/package_data/base_project/pyconfigs/auth.py,sha256=kQA21ZU_ZnejyhHuOcRLegMhaHW-DS5XF0-eqyMxZEI,1701
+squirrels/package_data/base_project/pyconfigs/connections.py,sha256=sjmyB7zD4P8yUVNchiuZcVOR4EdTJfo_ALux9w-lri8,1277
+squirrels/package_data/base_project/pyconfigs/context.py,sha256=zYOql0Ebn2nA43mUwtz2g6LsnYHUujlDWUL2zu2Df1M,2087
+squirrels/package_data/base_project/pyconfigs/parameters.py,sha256=9_D75x3okFxTU7uQoF7n1jUnrl-__A9kw5UBx-c2QAE,3057
+squirrels/package_data/base_project/seeds/mocks/category.csv,sha256=MoYsx7tSek-JdLvDb2YlYE2vP1dKhZMq_QrQYssmRxI,35
+squirrels/package_data/base_project/seeds/mocks/max_filter.csv,sha256=H34nwpvZVEhfTOgIJZez_UJ8N3nslxkh3CCSYUgs6w0,38
+squirrels/package_data/base_project/seeds/mocks/subcategory.csv,sha256=ok0lPm-S4_HT-Oe1damne5_pYFHf_yveNzUqY8I4kCs,105
+squirrels/package_data/base_project/squirrels.yml.j2,sha256=QfCzwnEApJmBdx-6wJpoWhNLH6Eoeajmw3-cnf6hJE8,1417
+squirrels/package_data/base_project/tmp/.gitignore,sha256=XImoqcWvJY0C0L_TWCx1ljvqU7qh9fUTJmK4ACCmNFI,13
+squirrels/package_data/static/favicon.ico,sha256=369AMckPCruYh3O2PnSLLmy8kLvTwhoaS_uu2pP6Tqs,4638
+squirrels/package_data/static/script.js,sha256=7OyjoE5Q7KOmxbWkcM17DFE3w-Y8hSsSTcmQW4cww28,11564
+squirrels/package_data/static/style.css,sha256=vs_TXZrd_2CAicCc-BKlU1OArA8-Rxe2iQGtCJUn0N8,2744
+squirrels/package_data/static/widgets.js,sha256=llmDCNxd_nasTO8B9RgJEAMY-X9jzIvi8LhKhgEaipQ,3612
+squirrels/package_data/templates/index.html,sha256=oqTewKPx2Mr9-inWPJt786K6L5qwiNYr1iPTFYjZ27E,3428
+squirrels/package_data/templates/index2.html,sha256=LzYDWTYAhgrfRL6AqjcYRLXfYY9W0_xckehIE-38Qr8,941
+squirrels/parameter_options.py,sha256=qu-qJzYizyLlk3FVSlQkSWpsjYufsL00AVffLABEpJE,15626
+squirrels/parameters.py,sha256=_knDtwF0aDP-hC52oDyIj11CAHcJT8m3Ydw2tUiJdDc,31568
+squirrels/user_base.py,sha256=1LAUPMHMtON8ohJRsG73QmeKqnPPszFAixyQI4k7-iA,1560
+squirrels-0.2.0.dev0.dist-info/LICENSE,sha256=rW94rBQiFGQtHU_v2IQJbvg715cQF-bXup4pEJVFHXA,1067
+squirrels-0.2.0.dev0.dist-info/METADATA,sha256=BHBZSDclfKoY4H7CexnxluQZ4bhChQUCC3PjbMohH44,5174
+squirrels-0.2.0.dev0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+squirrels-0.2.0.dev0.dist-info/entry_points.txt,sha256=5ZwITOayR4jFq3eIf_SIfFaS5l_1lqxvg0u_WVb56xM,58
+squirrels-0.2.0.dev0.dist-info/RECORD,,

{squirrels-0.1.1.post1.dist-info → squirrels-0.2.0.dev0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any
-

squirrels-0.2.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+squirrels=squirrels._command_line:main
+

squirrels/_credentials_manager.py

@@ -1,87 +0,0 @@
-from typing import Dict
-from dataclasses import dataclass
-from configparser import ConfigParser
-import os, json
-
-from squirrels._utils import ConfigurationError
-from squirrels import _constants as c, _utils
-
-_SQUIRRELS_CFG_PATH = _utils.join_paths(os.path.expanduser('~'), '.squirrelscfg')
-
-
-@dataclass
-class Credential:
-    username: str
-    password: str
-    
-    def __str__(self) -> str:
-        redacted_pass = '*'*len(self.password)
-        return f'username={self.username}, password={redacted_pass}'
-
-
-class SquirrelsConfigParser(ConfigParser):
-    def _get_creds_section(self):
-        section_name: str = c.CREDENTIALS_KEY
-        if not self.has_section(section_name):
-            self.add_section(section_name)
-        return self[section_name]
-    
-    def _json_str_to_credential(self, json_str: str) -> Credential:
-        cred_dict = json.loads(json_str)
-        return Credential(cred_dict[c.USERNAME_KEY], cred_dict[c.PASSWORD_KEY])
-    
-    def get_credential(self, key: str) -> Credential:
-        section = self._get_creds_section()
-        try:
-            value = section[key]
-        except KeyError as e:
-            raise ConfigurationError(f'Credential key "{key}" has not been set. To set it, use $ squirrels set-credential {key}')
-        return self._json_str_to_credential(value)
-
-    def get_all_credentials(self) -> Dict[str, Credential]:
-        section = self._get_creds_section()
-        result = {}
-        for key, value in section.items():
-            result[key] = self._json_str_to_credential(value)
-        return result
-
-    def set_credential(self, key: str, credential: Credential) -> ConfigParser:
-        section = self._get_creds_section()
-        section[key] = json.dumps(credential.__dict__)
-        return self
-    
-    def delete_credential(self, key: str) -> ConfigParser:
-        section = self._get_creds_section()
-        section.pop(key)
-        return self
-
-
-class SquirrelsConfigIOWrapper:
-    def __init__(self) -> None:
-        self.config = SquirrelsConfigParser()
-        self.config.read(_SQUIRRELS_CFG_PATH)
-
-    def get_credential(self, key: str) -> Credential:
-        return self.config.get_credential(key)
-
-    def print_all_credentials(self) -> None:
-        credentials_dict = self.config.get_all_credentials()
-        for key, cred in credentials_dict.items():
-            print(f'{key}:', cred)
-
-    def _write_config(self) -> None:
-        with open(_SQUIRRELS_CFG_PATH, 'w') as f:
-            self.config.write(f)
-
-    def set_credential(self, key: str, user: str, pw: str) -> None:
-        credential = Credential(user, pw)
-        self.config.set_credential(key, credential)
-        print(f'Credential key "{key}" set to: {credential}')
-        self._write_config()
-
-    def delete_credential(self, key: str) -> None:
-        self.config.delete_credential(key)
-        print(f'Credential key "{key}" has been deleted')
-        self._write_config()
-
-squirrels_config_io = SquirrelsConfigIOWrapper()

squirrels/_module_loader.py

@@ -1,37 +0,0 @@
-from typing import List, Tuple
-from squirrels import _constants as c, _manifest as mf
-import git, shutil, os, stat
-
-
-def parse_module_repo_strings(repo_strings: List[str]) -> List[Tuple[str]]:
-    output = []
-    for repo in repo_strings:
-        try:
-            url, tag = repo.split('@')
-        except ValueError:
-            raise RuntimeError(f'cannot split git repo "{repo}" into url and tag/branch... format must be like "url@tag"')
-        
-        try:
-            name, url = url.split('=')
-        except ValueError:
-            name = url.split('/')[-1].replace('.git', '')
-
-        output.append((name, url, tag))
-    
-    return output
-
-
-def load_modules(manifest: mf.Manifest) -> None:
-    repo_strings: List[str] = manifest.get_modules()
-
-    # Recreate the modules directory if it exists
-    if os.path.exists(c.MODULES_FOLDER):
-        def del_rw(action, name, exc):
-            os.chmod(name, stat.S_IWRITE)
-            os.remove(name)
-        shutil.rmtree(c.MODULES_FOLDER, onerror=del_rw)
-    os.mkdir(c.MODULES_FOLDER)
-    
-    module_repos = parse_module_repo_strings(repo_strings)
-    for name, url, tag in module_repos:
-        git.Repo.clone_from(url, f"modules/{name}", branch=tag, depth=1)

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()