squirrels 0.1.0rc1__tar.gz → 0.1.0rc2__tar.gz

{squirrels-0.1.0rc1 → squirrels-0.1.0rc2}/LICENSE

@@ -19,3 +19,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+ 

squirrels-0.1.0rc2/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: squirrels
+Version: 0.1.0rc2
+Summary: Python Package for Configuring SQL Generating APIs
+Author: Tim Huang
+Author-email: tim.yuting@hotmail.com
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Squirrels
+
+Squirrels is an API framework for creating REST APIs that generate sql queries & dataframes dynamically from query parameters. 
+
+## Setup
+
+First, install the library and all dependencies **in an independent virtual environment**.
+
+```bash
+# activate virtual environment...
+pip install -e .
+```
+
+To confirm that the setup worked, run this to show the help page for all squirrels CLI commands:
+
+```bash
+squirrels -h
+```
+
+## Testing
+
+```
+python setup.py pytest
+```
+
+## Documentation
+
+Check the documentation website [here](https://squirrels-nest.github.io/squirrels-docs/) or get started [here](https://squirrels-nest.github.io/squirrels-docs/getting-started/) to learn how to use the squirrels library to make an API project.
+
+## Developer Guide
+
+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 line utility is doing, start from the `_command_line.py` file as your entry point.
+
+The library version is maintained in both the `setup.py` file (for the next release or release-candidate version) and the `squirrels/version.py` file (for the next release version only).
+
+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 at the top level.
+
+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`.
+
+## License
+
+Squirrels is released under the MIT license.
+
+See the file LICENSE for more details.

squirrels-0.1.0rc2/README.md

@@ -0,0 +1,46 @@
+# Squirrels
+
+Squirrels is an API framework for creating REST APIs that generate sql queries & dataframes dynamically from query parameters. 
+
+## Setup
+
+First, install the library and all dependencies **in an independent virtual environment**.
+
+```bash
+# activate virtual environment...
+pip install -e .
+```
+
+To confirm that the setup worked, run this to show the help page for all squirrels CLI commands:
+
+```bash
+squirrels -h
+```
+
+## Testing
+
+```
+python setup.py pytest
+```
+
+## Documentation
+
+Check the documentation website [here](https://squirrels-nest.github.io/squirrels-docs/) or get started [here](https://squirrels-nest.github.io/squirrels-docs/getting-started/) to learn how to use the squirrels library to make an API project.
+
+## Developer Guide
+
+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 line utility is doing, start from the `_command_line.py` file as your entry point.
+
+The library version is maintained in both the `setup.py` file (for the next release or release-candidate version) and the `squirrels/version.py` file (for the next release version only).
+
+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 at the top level.
+
+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`.
+
+## License
+
+Squirrels is released under the MIT license.
+
+See the file LICENSE for more details.

squirrels-0.1.0rc2/setup.py

@@ -0,0 +1,42 @@
+from setuptools import setup, find_packages
+import os
+
+# The directory containing this file
+HERE = os.path.abspath(os.path.dirname(__file__))
+
+# Get the long description from the README file
+with open(os.path.join(HERE, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+# Recursively get package data
+def package_files(directory):
+    paths = []
+    for (path, directories, filenames) in os.walk(directory):
+        for filename in filenames:
+            paths.append(os.path.join('..', path, filename))
+    return paths
+
+extra_files = package_files(os.path.join('squirrels', 'package_data'))
+
+setup(
+    name='squirrels',
+    version='0.1.0rc2',
+    packages=find_packages(),
+    description='Python Package for Configuring SQL Generating APIs',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author='Tim Huang',
+    author_email='tim.yuting@hotmail.com',
+    license='MIT',
+    install_requires=[
+        'openpyxl', 'inquirer', 'pwinput', 'cachetools', 'fastapi', 'uvicorn', 
+        'Jinja2', 'GitPython', 'sqlalchemy', 'pandas', 'pyyaml'
+    ],
+    setup_requires=['pytest-runner==6.0.0'],
+    tests_require=['pytest==7.2.0'],
+    test_suite='tests',
+    package_data= {'squirrels': extra_files},
+    entry_points= {
+        'console_scripts': ['squirrels=squirrels._command_line:main']
+    }
+)

squirrels-0.1.0rc2/squirrels/__init__.py

@@ -0,0 +1,19 @@
+from .param_configs.parameter_options import SelectParameterOption, DateParameterOption, NumberParameterOption, NumRangeParameterOption
+from .param_configs.parameters import WidgetType, Parameter, SingleSelectParameter, MultiSelectParameter, DateParameter, NumberParameter, NumRangeParameter
+from .param_configs.data_sources import SelectionDataSource, DateDataSource, NumberDataSource, NumRangeDataSource, DataSourceParameter
+from .param_configs.parameter_set import ParameterSet
+from .connection_set import ConnectionSet
+from .version import __version__, major_version, minor_version, patch_version
+
+def get_credential(key: str):
+    """
+    Gets the username and password that was set through "$squirrels set-credential [key]"
+
+    Parameters:
+        key (str): The credential key
+    
+    Returns:
+        Credential: Object with attributes "username" and "password"
+    """
+    from .credentials_manager import squirrels_config_io
+    return squirrels_config_io.get_credential(key)

squirrels-0.1.0rc2/squirrels/_command_line.py

@@ -0,0 +1,105 @@
+from typing import List, Tuple, Optional
+from argparse import ArgumentParser
+import sys, time, pwinput
+sys.path.append('.')
+
+from squirrels import constants as c, __version__
+from squirrels import module_loader as ml, manifest as mf, credentials_manager as cm, connection_set as cs
+from squirrels.api_server import ApiServer
+from squirrels.renderer import RendererIOWrapper
+from squirrels.initializer import Initializer
+from squirrels.timed_imports import timer
+
+
+def _prompt_user_pw(args_values: Optional[List[str]]) -> Tuple[str, str]:
+    if args_values is not None:
+        user, pw = args_values
+    else:
+        user = input("Enter username: ")
+        pw = pwinput.pwinput("Enter password: ")
+    return user, pw
+
+
+def main():
+    """
+    Main entry point for the squirrels command line utilities.
+    """
+    start = time.time()
+    parser = ArgumentParser(description="Command line utilities from the squirrels python package")
+    parser.add_argument('-v', '--version', action='store_true', help='Show the version and exit')
+    parser.add_argument('--verbose', action='store_true', help='Enable verbose output')
+    subparsers = parser.add_subparsers(title='commands', dest='command')
+
+    init_parser = subparsers.add_parser(c.INIT_CMD, help='Initialize a squirrels project')
+    init_parser.add_argument('--no-overwrite', action='store_true', help="Don't overwrite files if they already exist")
+    init_parser.add_argument('--core', action='store_true', help='Include all core files')
+    init_parser.add_argument('--context', action='store_true', help=f'Include the {c.CONTEXT_FILE} file')
+    init_parser.add_argument('--selections-cfg', action='store_true', help=f'Include the {c.SELECTIONS_CFG_FILE} file')
+    init_parser.add_argument('--db-view', type=str, choices=['sql', 'py'], help='Create database view as sql (default) or python file')
+    init_parser.add_argument('--final-view', type=str, choices=['sql', 'py'], help='Include final view as sql or python file')
+    init_parser.add_argument('--sample-db', type=str, choices=['seattle-weather'], help='Sample sqlite database to include')
+
+    subparsers.add_parser(c.LOAD_MODULES_CMD, help='Load all the modules specified in squirrels.yaml from git')
+
+    def _add_profile_argument(parser: ArgumentParser):
+        parser.add_argument('key', type=str, help='Key to the database connection credential')
+
+    subparsers.add_parser(c.GET_CREDS_CMD, help='Get all database connection credential keys')
+
+    set_cred_parser = subparsers.add_parser(c.SET_CRED_CMD, help='Set a database connection credential key')
+    _add_profile_argument(set_cred_parser)
+    set_cred_parser.add_argument('--values', type=str, nargs=2, help='The username and password')
+
+    delete_cred_parser = subparsers.add_parser(c.DELETE_CRED_CMD, help='Delete a database connection credential key')
+    _add_profile_argument(delete_cred_parser)
+
+    test_parser = subparsers.add_parser(c.TEST_CMD, help='For a given dataset, create outputs for parameter API response and rendered sql queries')
+    test_parser.add_argument('dataset', type=str, help='Name of dataset (provided in squirrels.yaml) to test. Results are written in an "outputs" folder')
+    test_parser.add_argument('-c', '--cfg', type=str, help="Configuration file for parameter selections. Path is relative to the dataset's folder")
+    test_parser.add_argument('-d', '--data', type=str, help="Excel file with lookup data to avoid making a database connection. Path is relative to the dataset's folder")
+    test_parser.add_argument('-r', '--runquery', action='store_true', help='Runs all database queries and final view, and produce the results as csv files')
+
+    run_parser = subparsers.add_parser(c.RUN_CMD, help='Run the builtin API server')
+    run_parser.add_argument('--no-cache', action='store_true', help='Do not cache any api results')
+    run_parser.add_argument('--debug', action='store_true', help='In debug mode, all "hidden parameters" show in the parameters response')
+    run_parser.add_argument('--host', type=str, default='127.0.0.1')
+    run_parser.add_argument('--port', type=int, default=8000)
+
+    args, _ = parser.parse_known_args()
+    timer.verbose = args.verbose
+    timer.add_activity_time('parsing arguments', start)
+
+    if args.version:
+        print(__version__)
+    elif args.command == c.INIT_CMD:
+        Initializer(not args.no_overwrite).init_project(args)
+    elif args.command == c.LOAD_MODULES_CMD:
+        manifest = mf.from_file()
+        ml.load_modules(manifest)
+    elif args.command == c.GET_CREDS_CMD: 
+        cm.squirrels_config_io.print_all_credentials()
+    elif args.command == c.SET_CRED_CMD:
+        user, pw = _prompt_user_pw(args.values)
+        cm.squirrels_config_io.set_credential(args.key, user, pw)
+    elif args.command == c.DELETE_CRED_CMD:
+        cm.squirrels_config_io.delete_credential(args.key)
+    elif args.command in [c.RUN_CMD, c.TEST_CMD]:
+        manifest = mf.from_file()
+        conn_set = cs.from_file(manifest)
+        if args.command == c.RUN_CMD:
+            server = ApiServer(manifest, conn_set, args.no_cache, args.debug)
+            server.run(args)
+        elif args.command == c.TEST_CMD:
+            rendererIO = RendererIOWrapper(args.dataset, manifest, conn_set, args.data)
+            rendererIO.write_outputs(args.cfg, args.runquery)
+        conn_set.dispose()
+    elif args.command is None:
+        print(f'Command is missing. Enter "squirrels -h" for help.')
+    else:
+        print(f'Error: No such command "{args.command}". Enter "squirrels -h" for help.')
+    
+    timer.report_times()
+
+
+if __name__ == '__main__':
+    main()

squirrels-0.1.0rc2/squirrels/api_server.py

@@ -0,0 +1,128 @@
+from typing import Dict, List, Tuple, Set
+from fastapi import FastAPI, Request
+from fastapi.datastructures import QueryParams
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from cachetools.func import ttl_cache
+import os, json
+
+from squirrels import major_version, constants as c, utils
+from squirrels.manifest import Manifest
+from squirrels.connection_set import ConnectionSet
+from squirrels.renderer import RendererIOWrapper, Renderer
+
+
+class ApiServer:
+    def __init__(self, manifest: Manifest, conn_set: ConnectionSet, no_cache: bool, debug: bool) -> None:
+        """
+        Constructor for ApiServer
+
+        Parameters:
+            manifest (Manifest): Manifest object produced from squirrels.yaml
+            conn_set (ConnectionSet): Set of all connection pools defined in connections.py
+            no_cache (bool): Whether to disable caching
+            debug (bool): Set to True to show "hidden" parameters in the /parameters endpoint response
+        """
+        self.manifest = manifest
+        self.conn_set = conn_set
+        self.no_cache = no_cache
+        self.debug = debug
+        
+        self.datasets = manifest.get_all_dataset_names()
+        self.renderers: Dict[str, Renderer] = {}
+        for dataset in self.datasets:
+            rendererIO = RendererIOWrapper(dataset, manifest, conn_set)
+            self.renderers[dataset] = rendererIO.renderer
+        
+    def _get_parameters_helper(self, dataset: str, query_params: Set[Tuple[str, str]]) -> Dict:
+        if len(query_params) > 1:
+            raise utils.InvalidInputError("The /parameters endpoint takes at most 1 query parameter")
+        renderer = self.renderers[dataset]
+        parameters = renderer.apply_selections(dict(query_params), updates_only = True)
+        return parameters.to_dict(self.debug)
+    
+    def _get_results_helper(self, dataset: str, query_params: Set[Tuple[str, str]]) -> Dict:
+        renderer = self.renderers[dataset]
+        _, _, _, _, df = renderer.load_results(dict(query_params))
+        return json.loads(df.to_json(orient='table', index=False))
+    
+    def _apply_dataset_api_function(self, api_function, dataset: str, raw_query_params: QueryParams):
+        dataset = utils.normalize_name(dataset)
+        query_params = set()
+        for key, val in raw_query_params.items():
+            query_params.add((utils.normalize_name(key), val))
+        query_params = frozenset(query_params)
+        return api_function(dataset, query_params)
+    
+    def run(self, uvicorn_args: List[str]) -> None:
+        """
+        Runs the API server with uvicorn for CLI "squirrels run"
+
+        Parameters:
+            uvicorn_args (List[str]): List of arguments to pass to uvicorn.run. Currently only supports "host" and "port"
+        """
+        app = FastAPI()
+
+        squirrels_version_path = f'/squirrels{major_version}'
+        config_base_path = utils.normalize_name_for_api(self.manifest.get_base_path())
+        base_path = squirrels_version_path + config_base_path
+
+        static_dir = utils.join_paths(os.path.dirname(__file__), 'package_data', 'static')
+        app.mount('/static', StaticFiles(directory=static_dir), name='static')
+
+        templates_dir = utils.join_paths(os.path.dirname(__file__), 'package_data', 'templates')
+        templates = Jinja2Templates(directory=templates_dir)
+
+        # Parameters API
+        parameters_path = base_path + '/{dataset}/parameters'
+        
+        parameters_cache_size = self.manifest.get_setting(c.PARAMETERS_CACHE_SIZE_SETTING, 1024)
+        parameters_cache_ttl = self.manifest.get_setting(c.PARAMETERS_CACHE_TTL_SETTING, 24*60*60)
+
+        @ttl_cache(maxsize=parameters_cache_size, ttl=parameters_cache_ttl)
+        def get_parameters_cachable(*args):
+            return self._get_parameters_helper(*args)
+        
+        @app.get(parameters_path, response_class=JSONResponse)
+        async def get_parameters(dataset: str, request: Request):
+            api_function = self._get_parameters_helper if self.no_cache else get_parameters_cachable
+            return self._apply_dataset_api_function(api_function, dataset, request.query_params)
+
+        # Results API
+        results_path = base_path + '/{dataset}'
+
+        results_cache_size = self.manifest.get_setting(c.RESULTS_CACHE_SIZE_SETTING, 128)
+        results_cache_ttl = self.manifest.get_setting(c.RESULTS_CACHE_TTL_SETTING, 60*60)
+
+        @ttl_cache(maxsize=results_cache_size, ttl=results_cache_ttl)
+        def get_results_cachable(*args):
+            return self._get_results_helper(*args)
+        
+        @app.get(results_path, response_class=JSONResponse)
+        async def get_results(dataset: str, request: Request):
+            api_function = self._get_results_helper if self.no_cache else get_results_cachable
+            return self._apply_dataset_api_function(api_function, dataset, request.query_params)
+        
+        # Catalog API
+        @app.get(base_path, response_class=JSONResponse)
+        async def get_catalog():
+            datasets_info = []
+            for dataset in self.datasets:
+                dataset_normalized = utils.normalize_name_for_api(dataset)
+                datasets_info.append({
+                    'dataset': dataset,
+                    'label': self.manifest.get_dataset_label(dataset),
+                    'parameters_path': parameters_path.format(dataset=dataset_normalized),
+                    'result_path': results_path.format(dataset=dataset_normalized)
+                })
+            return {'project_variables': self.manifest.get_proj_vars(), 'resource_paths': datasets_info}
+        
+        # Squirrels UI
+        @app.get('/', response_class=HTMLResponse)
+        async def get_ui(request: Request):
+            return templates.TemplateResponse('index.html', {'request': request, 'base_path': base_path})
+        
+        # Run API server
+        import uvicorn
+        uvicorn.run(app, host=uvicorn_args.host, port=uvicorn_args.port)

squirrels-0.1.0rc2/squirrels/connection_set.py

@@ -0,0 +1,65 @@
+from typing import Dict, Union
+from importlib.machinery import SourceFileLoader
+from sqlalchemy import Engine, Pool
+import sqlite3
+
+from squirrels import manifest as mf, constants as c
+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:
+        self._conn_pools = conn_pools
+    
+    def get_connection_pool(self, conn_name: str) -> ConnectionPool:
+        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 get_dataframe_from_query(self, conn_name: str, query: str) -> pd.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)
+            data = cur.fetchall()
+            columns = [x[0] for x in cur.description]
+            df = pd.DataFrame(data, columns=columns)
+        finally:
+            conn.close()
+
+        return df
+
+    def dispose(self) -> None:
+        for pool in self._conn_pools.values():
+            pool.dispose()
+
+
+def from_file(manifest: mf.Manifest) -> ConnectionSet:
+    module = SourceFileLoader(c.CONNECTIONS_FILE, c.CONNECTIONS_FILE).load_module()
+    proj_vars = manifest.get_proj_vars()
+    try:
+        return module.main(proj_vars)
+    except Exception as e:
+        raise ConfigurationError(f'Error in the {c.CONNECTIONS_FILE} file') from e
+
+
+def sqldf(query: str, df_by_db_views: Dict[str, pd.DataFrame]) -> pd.DataFrame:
+    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-0.1.0rc2/squirrels/constants.py

@@ -0,0 +1,53 @@
+# Squirrels CLI commands
+INIT_CMD = 'init'
+LOAD_MODULES_CMD = 'load-modules'
+GET_CREDS_CMD = 'get-all-credentials'
+SET_CRED_CMD = 'set-credential'
+DELETE_CRED_CMD = 'delete-credential'
+TEST_CMD = 'test'
+RUN_CMD = 'run'
+
+# Manifest file keys
+DB_CONNECTION_KEY = 'db_connection'
+MODULES_KEY = 'modules'
+DATASET_LABEL_KEY = 'label'
+DATASETS_KEY = 'datasets'
+HEADERS_KEY = 'headers'
+DATABASE_VIEWS_KEY = 'database_views'
+DB_VIEW_NAME_KEY = 'name'
+DB_VIEW_FILE_KEY = 'file'
+FINAL_VIEW_KEY = 'final_view'
+BASE_PATH_KEY = 'base_path'
+SETTINGS_KEY = 'settings'
+
+# Database credentials keys
+CREDENTIALS_KEY = 'credentials'
+USERNAME_KEY = 'username'
+PASSWORD_KEY = 'password'
+
+# Folder/File names
+MANIFEST_FILE = 'squirrels.yaml'
+PROJ_VARS_FILE = 'project_vars.yaml'
+CONNECTIONS_FILE = 'connections.py'
+OUTPUTS_FOLDER = 'outputs'
+MODULES_FOLDER = 'modules'
+DATASETS_FOLDER = 'datasets'
+PARAMETERS_FILE = 'parameters.py'
+PARAMETERS_OUTPUT = 'parameters.json'
+DATABASE_VIEW_SQL_FILE = 'database_view1.sql.j2'
+DATABASE_VIEW_PY_FILE = 'database_view1.py'
+FINAL_VIEW_SQL_NAME = 'final_view.sql.j2'
+FINAL_VIEW_PY_NAME = 'final_view.py'
+FINAL_VIEW_OUT_STEM = 'final_view'
+CONTEXT_FILE = 'context.py'
+SELECTIONS_CFG_FILE = 'selections.cfg'
+
+# Dataset setting names
+PARAMETERS_CACHE_SIZE_SETTING = 'parameters.cache.size'
+PARAMETERS_CACHE_TTL_SETTING = 'parameters.cache.ttl'
+RESULTS_CACHE_SIZE_SETTING = 'results.cache.size'
+RESULTS_CACHE_TTL_SETTING = 'results.cache.ttl'
+
+# Selection cfg sections
+PARAMETERS_SECTION = 'parameters'
+HEADERS_SECTION = 'headers'

squirrels-0.1.0rc2/squirrels/credentials_manager.py

@@ -0,0 +1,87 @@
+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()