pyrandyos 1.1.0a1__tar.gz

pyrandyos-1.1.0a1/.gitignore

@@ -0,0 +1,15 @@
+build/
+dist/
+*.egg-info/
+*.egg
+*.py[cod]
+__pycache__/
+*~
+~$*
+
+docs/
+.vscode/settings.json
+.coverage
+.conda
+logs/
+tmp/

pyrandyos-1.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Randy Eckman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+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.

pyrandyos-1.1.0a1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: pyrandyos
+Version: 1.1.0a1
+Summary: Library of common functions for Python applications
+Project-URL: Homepage, https://github.com/emanspeaks/pyrandyos
+Project-URL: Issues, https://github.com/emanspeaks/pyrandyos/issues
+Author-email: Randy Eckman <emanspeaks@gmail.com>
+Maintainer-email: Randy Eckman <emanspeaks@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pyside2
+Requires-Dist: pywin32
+Requires-Dist: tqdm
+Requires-Dist: types-pyside2
+Provides-Extra: qdarkstyle
+Requires-Dist: qdarkstyle; extra == 'qdarkstyle'
+Description-Content-Type: text/markdown
+
+# PyRandyOS
+
+Library of common functions for Python applications
+
+## Licenses
+
+### Icons
+
+This repo uses icons taken from other open source icon libraries.  Links to their licensing info are maintained alongside the URLs for the icon fonts in [`pyrandyos/gui/icons/iconfont/sources.py`](pyrandyos/gui/icons/iconfont/sources.py), where the paths to the license files are with respect to the repo root at the given URL.

pyrandyos-1.1.0a1/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyrandyos"
+dynamic = ["version"]
+description = "Library of common functions for Python applications"
+readme = "readme.md"
+authors = [
+  {name = "Randy Eckman", email = "emanspeaks@gmail.com"},
+]
+maintainers = [
+  {name = "Randy Eckman", email = "emanspeaks@gmail.com"},
+]
+dependencies = [
+  "pywin32",
+  "tqdm",
+  "pyside2",
+  "types-pyside2",
+  "pandas",
+  "numpy",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+qdarkstyle = ["qdarkstyle"]
+
+[tool.hatch.version]
+path = "pyrandyos/version.py"
+
+[tool.hatch.build]
+include = [
+  "pyrandyos/**/*.py",
+  "pyrandyos/gui/styles/assets",
+  "pyrandyos/gui/icons/assets",
+]
+
+[project.urls]
+Homepage = "https://github.com/emanspeaks/pyrandyos"
+Issues = "https://github.com/emanspeaks/pyrandyos/issues"
+
+[tool.coverage.report]
+# ignore_errors = true
+
+# Regexes for lines to exclude from consideration
+exclude_also = [
+  # Don't complain about missing debug-only code:
+  # "def __repr__",
+  # "if self\\.debug",
+
+  # Don't complain if tests don't hit defensive assertion code:
+  "raise AssertionError",
+  "raise NotImplementedError",
+
+  # Don't complain if non-runnable code isn't run:
+  # "if 0:",
+  "if __name__ == .__main__.:",
+
+  # Don't complain about abstract methods, they aren't run:
+  "@(abc\\.)?abstractmethod",
+
+  'if TYPE_CHECKING:',
+  'if IS_WIN_CTYPES:'
+]
+
+[tool.coverage.run]
+branch = true
+# https://github.com/nedbat/coveragepy/issues/1392#issuecomment-1149310741
+omit = [
+    "shibokensupport/*",
+    "pyscript",
+    "signature_bootstrap.py",
+    "tests/*",
+]

pyrandyos-1.1.0a1/pyrandyos/__init__.py

@@ -0,0 +1,2 @@
+from .version import __version__  # noqa: F401
+from .app import PyRandyOSApp  # noqa: F401

pyrandyos-1.1.0a1/pyrandyos/__main__.py

@@ -0,0 +1,14 @@
+import sys
+
+
+args = sys.argv[1:]
+if args[0] == 'log_func_call':
+    from .tools.add_log_func_call_decorators import main as main_log_func_call
+    if len(args) > 1:
+        config_path = args[1]
+        main_log_func_call(['.'], config_path=config_path)
+    else:
+        main_log_func_call(['.'])
+
+else:
+    raise ValueError(f"Unknown command: {args[0]}")

pyrandyos-1.1.0a1/pyrandyos/_testing/__init__.py

@@ -0,0 +1,4 @@
+from ._pyrandyos_testing import (  # noqa: F401
+    _is_pyrandyos_unittest,
+    _is_running_in_ci,
+)

pyrandyos-1.1.0a1/pyrandyos/_testing/_pyrandyos_testing.py

@@ -0,0 +1,13 @@
+from os import environ
+
+# these constants are only relevant to testing, do not add to constants
+ENV_CI_RUNNING = 'CI'
+ENV_PYRANDYOS_UNITTEST_ACTIVE = 'PYRANDYOS_UNITTEST_ACTIVE'
+
+
+def _is_pyrandyos_unittest():
+    return bool(environ.get(ENV_PYRANDYOS_UNITTEST_ACTIVE))
+
+
+def _is_running_in_ci():
+    return bool(environ.get(ENV_CI_RUNNING))

pyrandyos-1.1.0a1/pyrandyos/_testing/debug.py

@@ -0,0 +1,35 @@
+import sys
+
+
+def is_debug_enabled():
+    # see https://stackoverflow.com/a/77627047/13230486
+    try:
+        if sys.gettrace() is not None:
+            return True
+    except AttributeError:
+        pass
+
+    try:
+        if sys.monitoring.get_tool(sys.monitoring.DEBUGGER_ID) is not None:
+            return True
+    except AttributeError:
+        pass
+
+    return False
+
+
+def hide_splash():
+    from pyrandyos.gui.gui_app import get_gui_app
+    gui_app = get_gui_app()
+    if gui_app and gui_app.splash:
+        splash = gui_app.splash.gui_view.qtobj
+        if splash.isVisible():
+            splash.hide()
+            if is_debug_enabled():
+                print("Splash screen hidden, debugger is enabled")
+            else:
+                print("Splash screen hidden")
+        else:
+            print("Splash screen is already hidden")
+    else:
+        print("No splash screen to hide")

pyrandyos-1.1.0a1/pyrandyos/app.py

@@ -0,0 +1,187 @@
+import sys
+from pathlib import Path
+from tempfile import gettempdir
+
+from .logging import (
+    log_info, Logger, log_func_call, DEBUGLOW2, set_trace_logging,
+    set_func_call_logging,
+)
+from .config import AppConfig
+from .config.keys import (
+    BASE_LOG_PATH_KEY, APP_NAME_KEY, get_log_dir_keys, APP_PKG_DIR_KEY,
+    APP_ASSETS_DIR_KEY, APP_PKG_VERSION_KEY, TMP_DIR_KEY, LOCAL_CFG_KEY
+)
+from .config.local import process_local_config
+
+from .utils.constants import DEFAULT_GROUP, DEFAULT_DIR_MODE
+from .utils.log import setup_logging, create_log_file
+from .utils.main import MainContext
+from .utils.system import mkdir_chgrp
+from .utils.stack import (
+    top_package_dir_path, top_module_and_name, set_show_traceback_locals
+)
+
+
+class PyRandyOSApp(AppConfig):
+    # abstract class attributes
+    APP_NAME: str
+    APP_LOG_PREFIX: str
+
+    # class attributes with fallback defaults
+    APP_PATH_KEYS: tuple[str] = ()
+    APP_LOG_DIR_KEYS: tuple[str] = ()
+    APP_GLOBAL_DEFAULTS = {}
+    APP_LOCAL_DEFAULTS = {}
+    APP_ASSETS_DIR: str | Path = None
+    "path to be resolved when config is processed; may use variable expansion"
+
+    use_local_config: bool = None
+
+    @classmethod
+    @log_func_call
+    def main(cls, *args, **kwargs):
+        raise NotImplementedError
+
+    @classmethod
+    @log_func_call
+    def init_main(cls, config: dict | str | Path = None,
+                  setup_log: bool = False, logfile: Path = None,
+                  logger: Logger = None, **kwargs):
+        "returns True if a local config is present and loaded, else False"
+        # log = logger or get_logger()
+        cls.set_logger(logger)
+        cls.init_parse_config(config, kwargs)
+
+        # setup logging first if necessary:
+        if setup_log:
+            (
+                logdir,
+                ts_name,
+                append,
+                cli_log_level,
+                file_log_level,
+                log_trace_enabled,
+                tb_locals_enabled,
+                log_func_call_enabled,
+            ) = cls.expand_log_config()
+            logfile = logfile or create_log_file(logdir, ts_name, append,
+                                                 cls.APP_LOG_PREFIX)
+
+            set_trace_logging(log_trace_enabled)
+            set_func_call_logging(log_func_call_enabled)
+            set_show_traceback_locals(tb_locals_enabled)
+            setup_logging(logfile, cli_log_level, file_log_level)
+
+        # start logging and process the rest of the configuration data
+        cls.set(BASE_LOG_PATH_KEY, logfile)
+        cls.set(APP_PKG_VERSION_KEY, cls.get_package_version())
+        pkgdir = cls.get_package_dir()
+        cls.set(APP_PKG_DIR_KEY, pkgdir)
+        assets_dir = cls.get_assets_dir()
+        if assets_dir:
+            cls.set(APP_ASSETS_DIR_KEY, assets_dir)
+
+        appname = cls.APP_NAME
+        cls.set(APP_NAME_KEY, appname)
+        log_info(f"Starting {appname}")
+        cls.process_config()
+
+        use_local_config = process_local_config(app_path_keys=cls.APP_PATH_KEYS)  # noqa: E501
+        cls.use_local_config = use_local_config
+        return use_local_config
+
+    @classmethod
+    @log_func_call
+    def process_config(cls, skip_expansion: str | list[str] = 'skip_expand',
+                       config: dict = None):
+        return super().process_config(skip_expansion, config,
+                                      app_path_keys=cls.APP_PATH_KEYS)
+
+    @classmethod
+    @log_func_call
+    def init_parse_config(cls, indata: dict | str | Path = None,
+                          overrides: dict = None, defaults: dict = None):
+        global_defaults = dict()
+        global_defaults.update(cls.APP_GLOBAL_DEFAULTS)
+        return super().init_parse_config(indata, overrides, defaults,
+                                         global_defaults,
+                                         cls.APP_LOCAL_DEFAULTS)
+
+    @classmethod
+    @log_func_call
+    def run_cmdline(cls, args: list[str] = None):
+        if args is None:
+            args = sys.argv[1:]
+
+        with MainContext(cls.APP_NAME):
+            sys.exit(cls.main(*cls.preprocess_args(args)))
+
+    @classmethod
+    @log_func_call
+    def preprocess_args(cls, args: list[str]):
+        if len(args) > 0:
+            raise ValueError('too many command line arguments')
+
+        return args
+
+    @classmethod
+    @log_func_call
+    def create_log_dirs(cls, group: str = DEFAULT_GROUP,
+                        mode: int = DEFAULT_DIR_MODE):
+        for key in get_log_dir_keys(cls.APP_LOG_DIR_KEYS):
+            p: Path = cls.get(key)
+            mkdir_chgrp(p, group, mode)
+
+    @classmethod
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def mkdir_temp(cls, name: str = None, group: str = DEFAULT_GROUP,
+                   mode: int = DEFAULT_DIR_MODE):
+        tmp_dir: Path | None = cls.get(TMP_DIR_KEY)
+        if not tmp_dir:
+            try:
+                appname = cls.APP_NAME
+            except AttributeError:
+                appname = 'PyRandyOSApp'
+
+            tmp_dir = Path(gettempdir())/appname
+            if cls.global_config:
+                cls.set(TMP_DIR_KEY, tmp_dir)
+
+        if name:
+            tmp_dir = tmp_dir/name
+
+        mkdir_chgrp(tmp_dir, group, mode)
+        return tmp_dir
+
+    @classmethod
+    @log_func_call
+    def get_package_version(cls):
+        return getattr(top_module_and_name(cls)[0], '__version__')
+
+    @classmethod
+    @log_func_call
+    def get_package_dir(cls):
+        return top_package_dir_path(cls)
+
+    @classmethod
+    @log_func_call
+    def get_assets_dir(cls):
+        assetsdir = cls.get(APP_ASSETS_DIR_KEY, cls.APP_ASSETS_DIR)
+        if assetsdir:
+            return Path(assetsdir)
+
+    @classmethod
+    @log_func_call(DEBUGLOW2)
+    def get_default_win_size(cls):
+        return (cls[f'{LOCAL_CFG_KEY}.default_width'],
+                cls[f'{LOCAL_CFG_KEY}.default_height'])
+
+    @classmethod
+    @log_func_call(DEBUGLOW2)
+    def get_local_config(cls, case_insensitive: bool = None):
+        return super().get_local_config(case_insensitive=case_insensitive)
+
+    @classmethod
+    @log_func_call
+    def save_local_config(cls, case_insensitive: bool = None):
+        return super().save_local_config(cls.APP_PATH_KEYS, case_insensitive)

pyrandyos-1.1.0a1/pyrandyos/config/__init__.py

@@ -0,0 +1,2 @@
+from .appconfig import AppConfig  # noqa: F401
+from .local import get_local_config, save_local_config  # noqa: F401

pyrandyos-1.1.0a1/pyrandyos/config/appconfig.py

@@ -0,0 +1,270 @@
+from logging import Logger
+from pathlib import Path
+from copy import deepcopy
+
+from ..logging import (
+    DEBUGLOW2, log_func_call, set_trace_logging, set_func_call_logging,
+    set_global_logger, get_global_logger
+)
+from ..utils.classproperty import classproperty
+from ..utils.paths import (
+    get_expanded_pathobj, get_expanded_pureposixpath, pureposixpath_to_pathobj
+)
+from ..utils.json import load_jsonc
+from ..utils.cfgdict import (
+    config_dict_get, config_dict_set, config_dict_update,
+)
+from ..utils.constants import NODEFAULT, IS_WIN32
+from ..utils.system import build_cmd_arg_list
+from ..utils.casesafe import casesafe_is_equal, casesafe_value_in_container
+from ..utils.stack import set_show_traceback_locals
+
+from .defaults import get_defaults
+from .keys import (
+    BASE_LOG_DIR_KEY, BASE_PATH_KEY, LOG_TIMESTAMP_KEY,
+    APPEND_LOG_KEY, CLI_LOG_LEVEL_KEY, get_path_keys, BASE_LOG_PATH_KEY,
+    FILE_LOG_LEVEL_KEY, ABS_BASE_PATH_KEY, LOG_TRACE_ENABLED_KEY,
+    SHOW_TRACEBACK_LOCALS_KEY, LOG_FUNC_CALL_ENABLED_KEY,
+)
+from .expandutils import expand_key_recursively
+
+_GLOBAL_CFG: dict = None
+
+
+class AppConfigType(type):
+    # this is really just here for VSCode syntax highlighting because the real
+    # class won't necessarily have access to this as a metaclass.
+    # Don't overthink this.  Just make sure it's set in AppConfig and
+    # its subclasses.
+    CONFIG_CASE_INSENSITIVE: bool
+
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def get_case(cls, case_insensitive: bool = None):
+        return (cls.CONFIG_CASE_INSENSITIVE if case_insensitive is None
+                else case_insensitive)
+
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def __contains__(cls, item):
+        return casesafe_value_in_container(_GLOBAL_CFG, item, cls.get_case())
+
+
+class AppConfig(metaclass=AppConfigType):
+    CONFIG_CASE_INSENSITIVE: bool = IS_WIN32
+
+    @log_func_call
+    def __init__(self):
+        # Class is intended as a singleton
+        if type(self) is AppConfig:  # pragma: no cover
+            raise NotImplementedError('Singleton class should not be '
+                                      'instantiated')
+
+    @classproperty
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def log(cls):
+        return get_global_logger()
+
+    @classmethod
+    @log_func_call
+    def set_logger(cls, log: Logger):
+        set_global_logger(log)
+
+    @classmethod
+    @log_func_call
+    def set(cls, key: str, value, case_insensitive: bool = None):
+        config_dict_set(_GLOBAL_CFG, key, value,
+                        cls.get_case(case_insensitive))
+
+    @classmethod
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def __class_getitem__(cls, key: str):
+        return config_dict_get(_GLOBAL_CFG, key,
+                               case_insensitive=cls.get_case())
+
+    @classmethod
+    @log_func_call
+    def set_global_config(cls, config: dict):
+        log = get_global_logger()
+        log.debug('setting global config')
+        global _GLOBAL_CFG
+        _GLOBAL_CFG = config
+
+    @classmethod
+    @log_func_call(DEBUGLOW2)
+    def get_global_config(cls):
+        return _GLOBAL_CFG
+
+    @classproperty
+    @log_func_call(DEBUGLOW2)
+    def global_config(cls):
+        return cls.get_global_config()
+
+    @global_config.setter
+    @log_func_call
+    def global_config(cls, config: dict):
+        cls.set_global_config(config)
+
+    @classmethod
+    @log_func_call(DEBUGLOW2, trace_only=True)
+    def get(cls, key: str, default=NODEFAULT,
+            case_insensitive: bool = None):
+        """
+        If the global app config has been set, returns the value for the
+        given key if present, else returns the default if provided.
+        When no global app config is set, returns None.
+
+        If the key contains '.', it assumes that the key is a dot-delimited
+        list of keys of nested dicts or lists, and will recursively drill down
+        through the config dict to return the ultimate value.
+
+        Args:
+            key (str): key to get from dict or dot-delimited list of keys
+            default (Any, optional): Value to return if key not found.
+                Defaults to NODEFAULT, which raises a KeyError if key is
+                not found.
+
+        Raises:
+            KeyError: key not found in `config` or its nested children
+
+        Returns:
+            Any: value for key or default value (if provided) or None if the
+                global app config is not set.
+        """
+        if _GLOBAL_CFG:
+            return config_dict_get(_GLOBAL_CFG, key, default,
+                                   cls.get_case(case_insensitive))
+
+    @classmethod
+    @log_func_call
+    def update(cls, data: dict, case_insensitive: bool = None):
+        config_dict_update(_GLOBAL_CFG, data, cls.get_case(case_insensitive))
+
+    @classmethod
+    @log_func_call
+    def build_cmd_args_from_config(cls, key: str):
+        return build_cmd_arg_list(cls[key])
+
+    @classmethod
+    @log_func_call
+    def process_config(cls, skip_expansion: str | list[str] = 'skip_expand',
+                       config: dict = None, app_path_keys: tuple[str] = (),
+                       case_insensitive: bool = None):
+        config = config or _GLOBAL_CFG
+        case = cls.get_case(case_insensitive)
+        skip_expansion = skip_expansion or ()
+        if isinstance(skip_expansion, str):
+            skip_expansion = (skip_expansion,)
+
+        for k in config.keys():
+            # print(k)
+            expand_key_recursively(config, k, skip_expansion,
+                                   case_insensitive=case)
+
+        base_path = get_expanded_pathobj(config[BASE_PATH_KEY], config, case)
+        config_dict_set(config, BASE_PATH_KEY, base_path, case)
+        config_dict_set(config, ABS_BASE_PATH_KEY, base_path.absolute(), case)
+        for k in get_path_keys(app_path_keys):
+            if casesafe_is_equal(k, BASE_PATH_KEY):
+                continue
+
+            v = config_dict_get(config, k, None, case)
+            if v:
+                config_dict_set(config, k, cls.handle_path(v, base_path))
+
+        set_trace_logging(config_dict_get(config, LOG_TRACE_ENABLED_KEY,
+                                          case_insensitive=case))
+        set_func_call_logging(config_dict_get(config,
+                                              LOG_FUNC_CALL_ENABLED_KEY,
+                                              case_insensitive=case))
+        set_show_traceback_locals(config_dict_get(config,
+                                                  SHOW_TRACEBACK_LOCALS_KEY,
+                                                  case_insensitive=case))
+        return config
+
+    @classmethod
+    @log_func_call
+    def get_base_logpath(cls):
+        return config_dict_get(_GLOBAL_CFG, BASE_LOG_PATH_KEY,
+                               case_insensitive=cls.get_case())
+
+    @classmethod
+    @log_func_call
+    def init_parse_config(cls, indata: dict | str | Path = None,
+                          overrides: dict = None, defaults: dict = None,
+                          app_global_defaults: dict = {},
+                          app_local_defaults: dict = {},
+                          case_insensitive: bool = None):
+        defaults = defaults or get_defaults(cls, app_global_defaults,
+                                            app_local_defaults)
+
+        config = deepcopy(defaults)
+        if indata:
+            config_dict_update(config, indata if isinstance(indata, dict)
+                               else load_jsonc(indata), case_insensitive)
+
+        if overrides:
+            config_dict_update(config, overrides, case_insensitive)
+
+        global _GLOBAL_CFG
+        _GLOBAL_CFG = config
+
+    @classmethod
+    @log_func_call
+    def expand_log_config(cls, skip_expansion: str | list[str] = None):
+        # An abbreviated function to get the log path quickly before further
+        # expansions so further error messages can be logged.
+        # All of these keys are hardcoded, so we don't need to worry about case
+        config = _GLOBAL_CFG
+        expand_key_recursively(config, BASE_PATH_KEY, skip_expansion)
+        expand_key_recursively(config, BASE_LOG_DIR_KEY, skip_expansion)
+        expand_key_recursively(config, LOG_TIMESTAMP_KEY, skip_expansion)
+        expand_key_recursively(config, APPEND_LOG_KEY, skip_expansion)
+        expand_key_recursively(config, CLI_LOG_LEVEL_KEY, skip_expansion)
+        expand_key_recursively(config, FILE_LOG_LEVEL_KEY, skip_expansion)
+        expand_key_recursively(config, LOG_TRACE_ENABLED_KEY, skip_expansion)
+        expand_key_recursively(config, LOG_FUNC_CALL_ENABLED_KEY,
+                               skip_expansion)
+        expand_key_recursively(config, SHOW_TRACEBACK_LOCALS_KEY,
+                               skip_expansion)
+        base_path = get_expanded_pathobj(config[BASE_PATH_KEY], config)
+        logdir = config_dict_get(config, BASE_LOG_DIR_KEY)
+        timestamp_name = config_dict_get(config, LOG_TIMESTAMP_KEY)
+        append_log = config_dict_get(config, APPEND_LOG_KEY)
+        cli_log_level = config_dict_get(config, CLI_LOG_LEVEL_KEY)
+        file_log_level = config_dict_get(config, FILE_LOG_LEVEL_KEY)
+        log_trace_enabled = config_dict_get(config, LOG_TRACE_ENABLED_KEY)
+        log_func_call_enabled = config_dict_get(config,
+                                                LOG_FUNC_CALL_ENABLED_KEY)
+        tb_locals_enabled = config_dict_get(config, SHOW_TRACEBACK_LOCALS_KEY)
+        return (cls.handle_path(logdir, base_path), timestamp_name,
+                append_log, cli_log_level, file_log_level, log_trace_enabled,
+                tb_locals_enabled, log_func_call_enabled)
+
+    @classmethod
+    @log_func_call
+    def handle_path(cls, x: str, base_path: Path,
+                    case_insensitive: bool = None) -> Path:
+        newppp = get_expanded_pureposixpath(x, _GLOBAL_CFG, case_insensitive)
+        newpath = pureposixpath_to_pathobj(newppp)
+
+        # any relative paths are assumed to be wrt base path for now
+        newpathstr = str(newpath)
+        if not newpath.is_absolute() and newpathstr[0] != '$':
+            if x[:2] in ('./', '.\\'):
+                newpath = get_expanded_pathobj(newpath)
+            else:
+                newpath = base_path/newpath
+
+        return newpath
+
+    @staticmethod
+    @log_func_call
+    def get_local_config(base: dict = None, case_insensitive: bool = None):
+        from .local import get_local_config as _getlocal
+        return _getlocal(base, case_insensitive)
+
+    @staticmethod
+    @log_func_call
+    def save_local_config(app_path_keys: tuple = (),
+                          case_insensitive: bool = None):
+        from .local import save_local_config as _savelocal
+        _savelocal(app_path_keys, case_insensitive)