squirrels 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

squirrels/_parameter_sets.py

@@ -2,15 +2,14 @@ from __future__ import annotations
 from typing import Optional, Sequence
 from dataclasses import dataclass, field
 from collections import OrderedDict
-import concurrent.futures, pandas as pd
+import time, concurrent.futures, pandas as pd
 
-from . import _utils as u, _constants as c, parameters as p, _parameter_configs as pc, _py_module as pm, _api_response_models as arm
+from . import _utils as u, _constants as c, parameters as p, _parameter_configs as _pc, _py_module as pm, _api_response_models as arm
 from .arguments.init_time_args import ParametersArgs
-from ._manifest import ManifestIO, ParametersConfig
-from ._connection_set import ConnectionSetIO
-from ._seeds import SeedsIO
+from ._manifest import ParametersConfig, ManifestConfig
+from ._connection_set import ConnectionSet, ConnectionsArgs
+from ._seeds import Seeds
 from .user_base import User
-from ._timer import timer, time
 
 
 @dataclass
@@ -31,25 +30,25 @@ class ParameterSet:
 
 
 @dataclass
-class _ParameterConfigsSet:
+class ParameterConfigsSet:
     """
     Pool of parameter configs, can create multiple for unit testing purposes
     """
-    _data: dict[str, pc.ParameterConfig] = field(default_factory=OrderedDict)
-    _data_source_params: dict[str, pc.DataSourceParameterConfig] = field(default_factory=dict)
+    _data: dict[str, _pc.ParameterConfigBase] = field(default_factory=OrderedDict)
+    _data_source_params: dict[str, _pc.DataSourceParameterConfig] = field(default_factory=dict)
         
-    def get(self, name: Optional[str]) -> Optional[pc.ParameterConfig]:
+    def get(self, name: Optional[str]) -> Optional[_pc.ParameterConfigBase]:
         try:
             return self._data[name] if name is not None else None
         except KeyError as e:
             raise u.ConfigurationError(f'Unable to find parameter named "{name}"') from e
 
-    def add(self, param_config: pc.ParameterConfigBase) -> None:
+    def add(self, param_config: _pc.ParameterConfigBase) -> None:
         self._data[param_config.name] = param_config
-        if isinstance(param_config, pc.DataSourceParameterConfig):
+        if isinstance(param_config, _pc.DataSourceParameterConfig):
             self._data_source_params[param_config.name] = param_config
     
-    def _get_all_ds_param_configs(self) -> Sequence[pc.DataSourceParameterConfig]:
+    def _get_all_ds_param_configs(self) -> Sequence[_pc.DataSourceParameterConfig]:
         return list(self._data_source_params.values())
 
     def __convert_datasource_params(self, df_dict: dict[str, pd.DataFrame]) -> None:
@@ -60,11 +59,12 @@ class _ParameterConfigsSet:
                 name = stack[-1]
                 if name not in done:
                     param = self._data_source_params.get(name, self.get(name))
+                    assert param is not None
                     parent_name = param.parent_name
                     if parent_name is not None and parent_name not in done:
                         stack.append(parent_name)
                         continue
-                    if isinstance(param, pc.DataSourceParameterConfig):
+                    if isinstance(param, _pc.DataSourceParameterConfig):
                         if name not in df_dict:
                             raise u.ConfigurationError(f'No reference data found for parameter "{name}"')
                         self._data[name] = param.convert(df_dict[name])
@@ -73,12 +73,12 @@ class _ParameterConfigsSet:
     
     def __validate_param_relationships(self) -> None:
         for param_config in self._data.values():
-            assert isinstance(param_config, pc.ParameterConfig)
+            assert isinstance(param_config, _pc.ParameterConfig)
             parent_name = param_config.parent_name
             parent = self.get(parent_name)
             if parent:
-                if not isinstance(param_config, pc.SelectionParameterConfig):
-                    if not isinstance(parent, pc.SingleSelectParameterConfig):
+                if not isinstance(param_config, _pc.SelectionParameterConfig):
+                    if not isinstance(parent, _pc.SingleSelectParameterConfig):
                         raise u.ConfigurationError(f'Only single-select parameters can be parents of non-select parameters. ' +
                                                    f'Parameter "{parent_name}" is the parent of non-select parameter ' +
                                                    f'"{param_config.name}" but "{parent_name}" is not a single-select parameter.')
@@ -92,7 +92,7 @@ class _ParameterConfigsSet:
                                                        f'among the options of non-select parameter "{param_config.name}".')
                         seen.update(lookup_keys)
                 
-                if not isinstance(parent, pc.SelectionParameterConfig):
+                if not isinstance(parent, _pc.SelectionParameterConfig):
                     raise u.ConfigurationError(f'Only selection parameters can be parents. Parameter "{parent_name}" is the parent of ' +
                                                f'"{param_config.name}" but "{parent_name}" is not a selection parameter.')
                 
@@ -107,7 +107,7 @@ class _ParameterConfigsSet:
         *, updates_only: bool = False, request_version: Optional[int] = None
     ) -> ParameterSet:
         if dataset_params is None:
-            dataset_params = self._data.keys()
+            dataset_params = list(self._data.keys())
         
         parameters_by_name: dict[str, p.Parameter] = {}
         params_to_process = selections.keys() if selections and updates_only else dataset_params
@@ -119,6 +119,7 @@ class _ParameterConfigsSet:
                 children = []
                 if curr_name not in parameters_by_name:
                     param_conf = self.get(curr_name)
+                    assert isinstance(param_conf, _pc.ParameterConfig)
                     parent_name = param_conf.parent_name
                     if parent_name is None:
                         parent = None
@@ -127,9 +128,10 @@ class _ParameterConfigsSet:
                         continue
                     else:
                         parent = parameters_by_name.get(parent_name)
+                    assert isinstance(parent, p._SelectionParameter) or parent is None
                     param = param_conf.with_selection(selections.get(curr_name), user, parent)
                     parameters_by_name[curr_name] = param
-                    if isinstance(param_conf, pc.SelectionParameterConfig):
+                    if isinstance(param_conf, _pc.SelectionParameterConfig):
                         children = list(x for x in param_conf.children.keys() if x in dataset_params)
                 stack.pop()
                 stack.extend(children)
@@ -137,21 +139,24 @@ class _ParameterConfigsSet:
         ordered_parameters = OrderedDict((key, parameters_by_name[key]) for key in dataset_params if key in parameters_by_name)
         return ParameterSet(ordered_parameters)
     
-    def get_all_api_field_info(self) -> dict[str, pc.APIParamFieldInfo]:
-        return {param: config.get_api_field_info() for param, config in self._data.items()}
+    def get_all_api_field_info(self) -> dict[str, _pc.APIParamFieldInfo]:
+        api_field_infos = {}
+        for param, config in self._data.items():
+            assert isinstance(config, _pc.ParameterConfig)
+            api_field_infos[param] = config.get_api_field_info()
+        return api_field_infos
 
 
 class ParameterConfigsSetIO:
     """
-    Static class for the singleton object of __ParameterConfigsPoolData
+    Static class for the singleton object of ParameterConfigsSet
     """
-    args: ParametersArgs
-    obj: _ParameterConfigsSet
+    obj: ParameterConfigsSet # this is static (set in load_from_file) to simplify development experience for pyconfigs/parameters.py
     
     @classmethod
-    def _GetDfDictFromDataSources(cls) -> dict[str, pd.DataFrame]:
-        def get_dataframe(ds_param_config: pc.DataSourceParameterConfig) -> tuple[str, pd.DataFrame]:
-            return ds_param_config.name, ds_param_config.get_dataframe(ConnectionSetIO.obj, SeedsIO.obj)
+    def _get_df_dict_from_data_sources(cls, default_conn_name: str, seeds: Seeds, conn_set: ConnectionSet) -> dict[str, pd.DataFrame]:
+        def get_dataframe(ds_param_config: _pc.DataSourceParameterConfig) -> tuple[str, pd.DataFrame]:
+            return ds_param_config.name, ds_param_config.get_dataframe(default_conn_name, conn_set, seeds)
         
         ds_param_configs = cls.obj._get_all_ds_param_configs()
         with concurrent.futures.ThreadPoolExecutor() as executor:
@@ -160,24 +165,30 @@ class ParameterConfigsSetIO:
         return df_dict
     
     @classmethod
-    def _AddFromDict(cls, param_config: ParametersConfig) -> None:
+    def _add_from_dict(cls, param_config: ParametersConfig) -> None:
         ptype = getattr(p, param_config.type)
         factory = getattr(ptype, param_config.factory)
         factory(**param_config.arguments)
     
     @classmethod
-    def LoadFromFile(cls) -> None:
+    def get_param_args(cls, conn_args: ConnectionsArgs) -> ParametersArgs:
+        return ParametersArgs(conn_args.proj_vars, conn_args.env_vars)
+    
+    @classmethod
+    def load_from_file(
+        cls, logger: u.Logger, base_path: str, manifest_cfg: ManifestConfig, seeds: Seeds, conn_set: ConnectionSet, param_args: ParametersArgs
+    ) -> ParameterConfigsSet:
         start = time.time()
-        cls.obj = _ParameterConfigsSet()
+        cls.obj = ParameterConfigsSet()
 
-        for param_as_dict in ManifestIO.obj.parameters:
-            cls._AddFromDict(param_as_dict)
+        for param_as_dict in manifest_cfg.parameters:
+            cls._add_from_dict(param_as_dict)
         
-        conn_args = ConnectionSetIO.args
-        cls.args = ParametersArgs(conn_args.proj_vars, conn_args.env_vars)
-        pm.run_pyconfig_main(c.PARAMETERS_FILE, {"sqrl": cls.args})
+        pm.run_pyconfig_main(base_path, c.PARAMETERS_FILE, {"sqrl": param_args})
         
-        df_dict = cls._GetDfDictFromDataSources()
+        default_conn_name = manifest_cfg.settings_obj.get_default_connection_name()
+        df_dict = cls._get_df_dict_from_data_sources(default_conn_name, seeds, conn_set)
         cls.obj._post_process_params(df_dict)
         
-        timer.add_activity_time("loading parameters", start)
+        logger.log_activity_time("loading parameters", start)
+        return cls.obj

squirrels/_py_module.py

@@ -1,5 +1,4 @@
 from typing import Type, Optional, Any
-from types import ModuleType
 import importlib.util
 
 from . import _constants as c, _utils as u
@@ -10,25 +9,26 @@ class PyModule:
         """
         Constructor for PyModule, an abstract module for a file that may or may not exist
         
-        Parameters:
+        Arguments:
             filepath (str | pathlib.Path): The file path to the python module
             is_required: If true, throw an error if the file path doesn't exist
         """
         self.filepath = str(filepath)
         try:
             spec = importlib.util.spec_from_file_location(self.filepath, self.filepath)
+            assert spec is not None and spec.loader is not None
             self.module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(self.module)
         except FileNotFoundError as e:
             if is_required:
                 raise u.ConfigurationError(f"Required file not found: '{self.filepath}'") from e
-            self.module: Optional[ModuleType] = default_class
+            self.module = default_class
     
     def get_func_or_class(self, attr_name: str, *, default_attr: Any = None, is_required: bool = True) -> Any:
         """
         Get an attribute of the module. Usually a python function or class.
 
-        Parameters:
+        Arguments:
             attr_name: The attribute name
             default_attr: The default function or class to use if the attribute cannot be found
             is_required: If true, throw an error if the attribute cannot be found, unless default_attr is not None
@@ -42,15 +42,15 @@ class PyModule:
         return func_or_class
 
 
-def run_pyconfig_main(filename: str, kwargs: dict[str, Any] = {}) -> None:
+def run_pyconfig_main(base_path: str, filename: str, kwargs: dict[str, Any] = {}) -> None:
     """
     Given a python file in the 'pyconfigs' folder, run its main function
     
-    Parameters:
+    Arguments:
         filename: The name of the file to run main function
         kwargs: Dictionary of the main function arguments
     """
-    filepath = u.join_paths(c.PYCONFIGS_FOLDER, filename)
+    filepath = u.Path(base_path, c.PYCONFIGS_FOLDER, filename)
     module = PyModule(filepath)
     main_function = module.get_func_or_class(c.MAIN_FUNC, is_required=False)
     if main_function:

squirrels/_seeds.py

@@ -1,38 +1,39 @@
 from dataclasses import dataclass
-import os, glob, pandas as pd
+import os, time, glob, pandas as pd
 
-from ._timer import timer, time
-from ._manifest import ManifestIO
-from . import _utils as u, _constants as c
+from ._manifest import ManifestConfig
+from . import _utils as _u, _constants as c
 
 
 @dataclass
 class Seeds:
     _data: dict[str, pd.DataFrame]
+    _manifest_cfg: ManifestConfig
     
     def run_query(self, sql_query: str) -> pd.DataFrame:
-        return u.run_sql_on_dataframes(sql_query, self._data)
+        use_duckdb = self._manifest_cfg.settings_obj.do_use_duckdb()
+        return _u.run_sql_on_dataframes(sql_query, self._data, use_duckdb)
     
     def get_dataframes(self) -> dict[str, pd.DataFrame]:
         return self._data.copy()
 
 
 class SeedsIO:
-    obj: Seeds
 
     @classmethod
-    def LoadFiles(cls) -> None:
+    def load_files(cls, logger: _u.Logger, base_path: str, manifest_cfg: ManifestConfig) -> Seeds:
         start = time.time()
-        infer_schema: bool = ManifestIO.obj.settings.get(c.SEEDS_INFER_SCHEMA_SETTING, True)
-        na_values: list[str] = ManifestIO.obj.settings.get(c.SEEDS_NA_VALUES_SETTING, ["NA"])
+        infer_schema: bool = manifest_cfg.settings.get(c.SEEDS_INFER_SCHEMA_SETTING, True)
+        na_values: list[str] = manifest_cfg.settings.get(c.SEEDS_NA_VALUES_SETTING, ["NA"])
         csv_dtype = None if infer_schema else str
         
         seeds_dict = {}
-        csv_files = glob.glob(os.path.join(c.SEEDS_FOLDER, '**/*.csv'), recursive=True)
+        csv_files = glob.glob(os.path.join(base_path, c.SEEDS_FOLDER, '**/*.csv'), recursive=True)
         for csv_file in csv_files:
             file_stem = os.path.splitext(os.path.basename(csv_file))[0]
             df = pd.read_csv(csv_file, dtype=csv_dtype, keep_default_na=False, na_values=na_values)
             seeds_dict[file_stem] = df
         
-        cls.obj = Seeds(seeds_dict)
-        timer.add_activity_time("loading seed files", start)
+        seeds = Seeds(seeds_dict, manifest_cfg)
+        logger.log_activity_time("loading seed files", start)
+        return seeds

squirrels/_utils.py

@@ -1,6 +1,9 @@
 from typing import Sequence, Optional, Union, TypeVar, Callable
 from pathlib import Path
-import json, sqlite3, jinja2 as j2, pandas as pd
+from pandas.api import types as pd_types
+from datetime import datetime
+import os, time, logging, json, sqlite3, pandas as pd
+import jinja2 as j2, jinja2.nodes as j2_nodes
 
 from . import _constants as c
 
@@ -21,75 +24,114 @@ class ConfigurationError(Exception):
     """
     pass
 
-class FileExecutionError(ConfigurationError):
+class FileExecutionError(Exception):
     def __init__(self, message: str, error: Exception, *args) -> None:
-        new_message = message + f"\n... Produced error message `{error}` (scroll up for more details on handled exception)"
+        t = "  "
+        new_message = f"\n" + message + f"\n{t}Produced error message:\n{t}{t}{error} (see above for more details on handled exception)"
         super().__init__(new_message, *args)
+        self.error = error
+
+
+## Other utility classes
+
+class Logger(logging.Logger):
+    def log_activity_time(self, activity: str, start_timestamp: float, *, request_id: str | None = None) -> None:
+        end_timestamp = time.time()
+        time_taken = round((end_timestamp-start_timestamp) * 10**3, 3)
+        data = { "activity": activity, "start_timestamp": start_timestamp, "end_timestamp": end_timestamp, "time_taken_ms": time_taken }
+        info = { "request_id": request_id } if request_id else {}
+        self.debug(f'Time taken for "{activity}": {time_taken}ms', extra={"data": data, "info": info})
+
+
+class EnvironmentWithMacros(j2.Environment):
+    def __init__(self, logger: logging.Logger, loader: j2.FileSystemLoader, *args, **kwargs):
+        super().__init__(*args, loader=loader, **kwargs)
+        self._logger = logger
+        self._macros = self._load_macro_templates(logger)
+
+    def _load_macro_templates(self, logger: logging.Logger) -> str:
+        macros_dirs = self._get_macro_folders_from_packages()
+        macro_templates = []
+        for macros_dir in macros_dirs:
+            for root, _, files in os.walk(macros_dir):
+                files: list[str]
+                for filename in files:
+                    if any(filename.endswith(x) for x in [".sql", ".j2", ".jinja", ".jinja2"]):
+                        filepath = Path(root, filename)
+                        logger.info(f"Loaded macros from: {filepath}")
+                        with open(filepath, 'r') as f:
+                            content = f.read()
+                        macro_templates.append(content)
+        return '\n'.join(macro_templates)
+    
+    def _get_macro_folders_from_packages(self) -> list[Path]:
+        assert isinstance(self.loader, j2.FileSystemLoader)
+        packages_folder = Path(self.loader.searchpath[0], c.PACKAGES_FOLDER)
+        
+        subdirectories = []
+        if os.path.exists(packages_folder):
+            for item in os.listdir(packages_folder):
+                item_path = Path(packages_folder, item)
+                if os.path.isdir(item_path):
+                    subdirectories.append(Path(item_path, c.MACROS_FOLDER))
+        
+        subdirectories.append(Path(self.loader.searchpath[0], c.MACROS_FOLDER))
+        return subdirectories
 
+    def _parse(self, source: str, name: str | None, filename: str | None) -> j2_nodes.Template:
+        source = self._macros + source
+        return super()._parse(source, name, filename)
 
-## Utility functions/variables
-
-def join_paths(*paths: FilePath) -> Path:
-    """
-    Joins paths together.
-
-    Parameters:
-        paths (str | pathlib.Path): The paths to join.
 
-    Returns:
-        (pathlib.Path) The joined path.
-    """
-    return Path(*paths)
+## Utility functions/variables
 
+def log_activity_time(logger: logging.Logger, activity: str, start_timestamp: float, *, request_id: str | None = None) -> None:
+    end_timestamp = time.time()
+    time_taken = round((end_timestamp-start_timestamp) * 10**3, 3)
+    data = { "activity": activity, "start_timestamp": start_timestamp, "end_timestamp": end_timestamp, "time_taken_ms": time_taken }
+    info = { "request_id": request_id } if request_id else {}
+    logger.debug(f'Time taken for "{activity}": {time_taken}ms', extra={"data": data, "info": info})
 
-_j2_env = j2.Environment(loader=j2.FileSystemLoader('.'))
 
-def render_string(raw_str: str, **kwargs: dict) -> str:
+def render_string(raw_str: str, *, base_path: str = ".", **kwargs) -> str:
     """
     Given a template string, render it with the given keyword arguments
 
-    Parameters:
+    Arguments:
         raw_str: The template string
         kwargs: The keyword arguments
 
     Returns:
         The rendered string
     """
-    template = _j2_env.from_string(raw_str)
+    j2_env = j2.Environment(loader=j2.FileSystemLoader(base_path))
+    template = j2_env.from_string(raw_str)
     return template.render(kwargs)
 
 
-T = TypeVar('T')
-def __process_file_handler(file_handler: Callable[[FilePath], T], filepath: FilePath, is_required: bool) -> Optional[T]:
-    try:
-        return file_handler(filepath)
-    except FileNotFoundError as e:
-        if is_required:
-            raise ConfigurationError(f"Required file not found: '{str(filepath)}'") from e
-
-
-def read_file(filepath: FilePath, *, is_required: bool = True) -> Optional[str]:
+def read_file(filepath: FilePath) -> str:
     """
     Reads a file and return its content if required
 
-    Parameters:
+    Arguments:
         filepath (str | pathlib.Path): The path to the file to read
         is_required: If true, throw error if file doesn't exist
 
     Returns:
         Content of the file, or None if doesn't exist and not required
     """
-    def file_handler(filepath: FilePath):
+    try:
         with open(filepath, 'r') as f:
             return f.read()
-    return __process_file_handler(file_handler, filepath, is_required)
+    except FileNotFoundError as e:
+        raise ConfigurationError(f"Required file not found: '{str(filepath)}'") from e
 
 
 def normalize_name(name: str) -> str:
     """
     Normalizes names to the convention of the squirrels manifest file.
 
-    Parameters:
+    Arguments:
         name: The name to normalize.
 
     Returns:
@@ -102,7 +144,7 @@ def normalize_name_for_api(name: str) -> str:
     """
     Normalizes names to the REST API convention.
 
-    Parameters:
+    Arguments:
         name: The name to normalize.
 
     Returns:
@@ -115,7 +157,7 @@ def load_json_or_comma_delimited_str_as_list(input_str: Union[str, Sequence]) ->
     """
     Given a string, load it as a list either by json string or comma delimited value
 
-    Parameters:
+    Arguments:
         input_str: The input string
     
     Returns:
@@ -143,7 +185,7 @@ def process_if_not_none(input_val: Optional[X], processor: Callable[[X], Y]) ->
     """
     Given a input value and a function that processes the value, return the output of the function unless input is None
 
-    Parameters:
+    Arguments:
         input_val: The input value
         processor: The function that processes the input value
     
@@ -155,42 +197,60 @@ def process_if_not_none(input_val: Optional[X], processor: Callable[[X], Y]) ->
     return processor(input_val)
 
 
-def use_duckdb() -> bool:
-    """
-    Determines whether to use DuckDB instead of SQLite for embedded database
-
-    Returns:
-        A boolean
-    """
-    from ._manifest import ManifestIO
-    return (ManifestIO.obj.settings.get(c.IN_MEMORY_DB_SETTING, c.SQLITE) == c.DUCKDB)
-
-
-def run_sql_on_dataframes(sql_query: str, dataframes: dict[str, pd.DataFrame]) -> pd.DataFrame:
+def run_sql_on_dataframes(sql_query: str, dataframes: dict[str, pd.DataFrame], do_use_duckdb: bool) -> pd.DataFrame:
     """
     Runs a SQL query against a collection of dataframes
 
-    Parameters:
+    Arguments:
         sql_query: The SQL query to run
         dataframes: A dictionary of table names to their pandas Dataframe
     
     Returns:
         The result as a pandas Dataframe from running the query
     """
-    do_use_duckdb = use_duckdb()
     if do_use_duckdb:
         import duckdb
-        conn = duckdb.connect()
+        duckdb_conn = duckdb.connect()
     else:
         conn = sqlite3.connect(":memory:")
     
     try:
         for name, df in dataframes.items():
             if do_use_duckdb:
-                conn.execute(f"CREATE TABLE {name} AS FROM df")
+                duckdb_conn.execute(f"CREATE TABLE {name} AS FROM df")
             else:
                 df.to_sql(name, conn, index=False)
         
-        return conn.execute(sql_query).df() if do_use_duckdb else pd.read_sql(sql_query, conn)
+        return duckdb_conn.execute(sql_query).df() if do_use_duckdb else pd.read_sql(sql_query, conn)
     finally:
-        conn.close()
+        duckdb_conn.close() if do_use_duckdb else conn.close()
+
+
+def df_to_json0(df: pd.DataFrame, dimensions: list[str] | None = None) -> dict:
+    """
+    Convert a pandas DataFrame to the response format that the dataset result API of Squirrels outputs.
+
+    Arguments:
+        df: The dataframe to convert into an API response
+        dimensions: The list of declared dimensions. If None, all non-numeric columns are assumed as dimensions
+
+    Returns:
+        The response of a Squirrels dataset result API
+    """
+    in_df_json = json.loads(df.to_json(orient='table', index=False))
+    out_fields = []
+    non_numeric_fields = []
+    for in_column in in_df_json["schema"]["fields"]:
+        col_name: str = in_column["name"]
+        out_column = { "name": col_name, "type": in_column["type"] }
+        out_fields.append(out_column)
+        
+        if not pd_types.is_numeric_dtype(df[col_name].dtype):
+            non_numeric_fields.append(col_name)
+    
+    out_dimensions = non_numeric_fields if dimensions is None else dimensions
+    dataset_json = {
+        "schema": { "fields": out_fields, "dimensions": out_dimensions },
+        "data": in_df_json["data"]
+    }
+    return dataset_json

squirrels/_version.py

@@ -1,3 +1,3 @@
-from . import __version__
+__version__ = '0.4.0'
 
 sq_major_version, sq_minor_version, sq_patch_version = __version__.split('.')[:3]

squirrels/arguments/init_time_args.py

@@ -1,32 +1,38 @@
-from typing import Optional, Callable, Any
+from typing import Callable, Any
 from dataclasses import dataclass
 
 
 @dataclass
 class BaseArguments:
-    proj_vars: dict[str, Any]
-    env_vars: dict[str, Any]
+    _proj_vars: dict[str, Any]
+    _env_vars: dict[str, Any]
+
+    @property
+    def proj_vars(self) -> dict[str, Any]:
+        return self._proj_vars.copy()
+    
+    @property
+    def env_vars(self) -> dict[str, Any]:
+        return self._env_vars.copy()
 
 
 @dataclass
 class ConnectionsArgs(BaseArguments):
-    _get_credential: Callable[[str], tuple[str, str]]
-
-    def __post_init__(self):
-        self.get_credential = self._get_credential
+    _get_credential: Callable[[str | None], tuple[str, str]]
 
-    def get_credential(self, key: Optional[str]) -> tuple[str, str]:
+    def get_credential(self, key: str | None) -> tuple[str, str]:
         """
-        Return (username, password) tuple configured for credentials key in environcfg.yaml
+        Return (username, password) tuple configured for credentials key in env.yaml
 
         If key is None, returns tuple of empty strings ("", "")
 
-        Parameters:
+        Arguments:
             key: The credentials key
         
         Returns:
             A tuple of 2 strings
         """
+        return self._get_credential(key)
 
 
 @dataclass