config2py 0.1.35__py3-none-any.whl → 0.1.37__py3-none-any.whl

config2py/__init__.py

@@ -13,6 +13,7 @@ from config2py.tools import (
 )
 from config2py.base import get_config, user_gettable, sources_chainmap
 from config2py.util import (
+    envvar,  # os.environ, but with dict display override to hide secrets
     ask_user_for_input,
     get_app_data_folder,
     get_configs_folder_for_app,

config2py/base.py

@@ -94,7 +94,7 @@ GetConfigEgress = Callable[[KT, VT], VT]
 
 def is_not_none_nor_empty(x):
     if isinstance(x, str):
-        return x != ''
+        return x != ""
     else:
         return x is not None
 
@@ -211,7 +211,7 @@ def get_config(
     value = chain_map.get(key, not_found)
     if value is not_found:
         if default is no_default:
-            raise ConfigNotFound(f'Could not find config for key: {key}')
+            raise ConfigNotFound(f"Could not find config for key: {key}")
         else:
             value = default
     if egress is not None:
@@ -299,11 +299,11 @@ class FuncBasedGettableContainer:
             v = self.getter(k)
         except self.config_not_found_exceptions as e:
             raise KeyError(
-                f'There was an exception when computing key: {k} with the function '
-                f'{self.getter}. The exception was: {e}'
+                f"There was an exception when computing key: {k} with the function "
+                f"{self.getter}. The exception was: {e}"
             )
         if not self.val_is_valid(v):
-            raise KeyError(f'Value for key {k} is not valid: {v}')
+            raise KeyError(f"Value for key {k} is not valid: {v}")
         return v
 
     # TODO: Is this used to indicate that the getter couldn't find a key.
@@ -317,10 +317,10 @@ class FuncBasedGettableContainer:
 
     def __iter__(self):
         raise TypeError(
-            f'Iteration is NOT ACTUALLY implemented for {type(self).__name__}. '
-            'The reason we still stuck it in the class is because python will '
-            'automatically try to use __getitem__ on 0, 1, ... to iterate over the '
-            'object, and we want to avoid that, since this would result in an obscure '
+            f"Iteration is NOT ACTUALLY implemented for {type(self).__name__}. "
+            "The reason we still stuck it in the class is because python will "
+            "automatically try to use __getitem__ on 0, 1, ... to iterate over the "
+            "object, and we want to avoid that, since this would result in an obscure "
             "error message saying that the getter function can't be called on 0"
         )
 
@@ -342,7 +342,7 @@ def gettable_containers(
             )
         else:
             raise AssertionError(
-                f'Source must be a Gettable or a Callable, not {type(src)}'
+                f"Source must be a Gettable or a Callable, not {type(src)}"
             )
 
 
@@ -362,7 +362,7 @@ SaveTo = Optional[Union[MutableMapping, KTSaver]]
 
 def is_not_empty(val) -> bool:
     if isinstance(val, str):
-        return val != ''
+        return val != ""
     else:
         return val is not None
 
@@ -370,7 +370,7 @@ def is_not_empty(val) -> bool:
 def ask_user_for_key(
     key=None,
     *,
-    prompt_template='Enter a value for {}: ',
+    prompt_template="Enter a value for {}: ",
     save_to: SaveTo = None,
     save_condition=is_not_empty,
     user_asker=ask_user_for_input,
@@ -389,7 +389,7 @@ def ask_user_for_key(
     if isinstance(egress, Callable):
         val = egress(key, val)
     if save_to is not None and save_condition(val):
-        if hasattr(save_to, '__setitem__'):
+        if hasattr(save_to, "__setitem__"):
             save_to_func = save_to.__setitem__
         save_to_func(key, val)
     return val
@@ -398,7 +398,7 @@ def ask_user_for_key(
 def user_gettable(
     save_to: SaveTo = None,
     *,
-    prompt_template='Enter a value for {}: ',
+    prompt_template="Enter a value for {}: ",
     egress: Optional[Callable] = None,
     user_asker=ask_user_for_input,
     val_is_valid: Callable[[VT], bool] = is_not_empty,

config2py/s_configparser.py

@@ -1,6 +1,7 @@
 """
 Data Object Layer for configparser standard lib.
 """
+
 from configparser import ConfigParser
 from configparser import BasicInterpolation, ExtendedInterpolation
 from functools import wraps
@@ -10,7 +11,7 @@ from dol import Store
 
 # from py2store.signatures import Sig
 
-_test_config_str = '''[Simple Values]
+_test_config_str = """[Simple Values]
 key=value
 spaces in keys=allowed
 spaces in values=allowed as well
@@ -51,7 +52,7 @@ empty string value here =
             deeper than the first line
             of a value
         # Did I mention we can indent comments, too?
-'''
+"""
 
 
 def persist_after_operation(method_func):
@@ -87,7 +88,7 @@ def super_and_persist(super_cls, method_name):
 
 
 ConfigParserStore = Store.wrap(ConfigParser)
-ConfigParserStore.__name__ = 'ConfigParserStore'
+ConfigParserStore.__name__ = "ConfigParserStore"
 
 
 # TODO: ConfigParser is already a mapping, but pros/cons of subclassing?
@@ -199,7 +200,8 @@ class ConfigStore(ConfigParserStore):
     >>> ConfigReader(ini_filepath).to_dict()
     {'DEFAULT': {}, 'nothing': {'like': 'that', 'ever': 'happened'}}
 
-        """
+    """
+
     space_around_delimiters = True
     BasicInterpolation = BasicInterpolation
     ExtendedInterpolation = ExtendedInterpolation
@@ -224,24 +226,24 @@ class ConfigStore(ConfigParserStore):
         self._within_context_manager = False
 
         if isinstance(source, str):
-            if '\n' in source:
+            if "\n" in source:
                 self.read_string(source)
-                source_kind = 'string'
+                source_kind = "string"
             else:
                 self.read(source)
-                source_kind = 'filepath'
+                source_kind = "filepath"
         elif isinstance(source, bytes):
             self.read_string(source.decode())
-            source_kind = 'bytes'
+            source_kind = "bytes"
         elif isinstance(source, dict):
             self.read_dict(source)
-            source_kind = 'dict'
-        elif hasattr(source, 'read'):
+            source_kind = "dict"
+        elif hasattr(source, "read"):
             self.read_file(source)
-            source_kind = 'stream'
+            source_kind = "stream"
         else:
             self.read(source)
-            source_kind = 'unknown'
+            source_kind = "unknown"
         self.source = source
         self.source_kind = source_kind
         self.target_kind = target_kind or source_kind
@@ -264,28 +266,28 @@ class ConfigStore(ConfigParserStore):
         Persists means to call
         """
         if not self._within_context_manager:
-            if self.target_kind == 'filepath':
-                with open(self.source, 'w') as fp:
+            if self.target_kind == "filepath":
+                with open(self.source, "w") as fp:
                     return self.write(fp, self.space_around_delimiters)
             else:
-                if self.target_kind == 'stream':
+                if self.target_kind == "stream":
                     target = self.source
                     return self.write(target, self.space_around_delimiters)
-                elif self.target_kind in {'string', 'bytes'}:
+                elif self.target_kind in {"string", "bytes"}:
                     string_target = StringIO()
                     self.write(string_target, self.space_around_delimiters)
                     string_target.seek(0)
                     string_data = string_target.read()
-                    if self.target_kind == 'string':
+                    if self.target_kind == "string":
                         return string_data
-                    elif self.target_kind == 'bytes':
+                    elif self.target_kind == "bytes":
                         return string_data.encode()
                     else:
-                        raise ValueError(f'Unknown target_kind: {self.target_kind}')
-                elif self.target_kind == 'dict':
+                        raise ValueError(f"Unknown target_kind: {self.target_kind}")
+                elif self.target_kind == "dict":
                     return self.to_dict()
                 else:
-                    raise ValueError(f'Unknown target_kind: {self.target_kind}')
+                    raise ValueError(f"Unknown target_kind: {self.target_kind}")
 
     def __enter__(self):
         self._within_context_manager = True
@@ -360,13 +362,13 @@ class ConfigReader(ConfigStore):
     """
 
     def persist(self):
-        raise NotImplementedError('persist disabled for ConfigReader')
+        raise NotImplementedError("persist disabled for ConfigReader")
 
     def __setitem__(self, k, v):
-        raise NotImplementedError('__setitem__ disabled for ConfigReader')
+        raise NotImplementedError("__setitem__ disabled for ConfigReader")
 
     def __delitem__(self, k):
-        raise NotImplementedError('__delitem__ disabled for ConfigReader')
+        raise NotImplementedError("__delitem__ disabled for ConfigReader")
 
 
 # TODO: Need to wrap SectionProxy to make this work, since the obj and data here are
@@ -404,11 +406,11 @@ def postprocess_ini_section_items(items: Union[Mapping, Iterable]) -> Generator:
     {'name': 'aspyre', 'keywords': ['documentation', 'packaging', 'publishing']}
 
     """
-    splitter_re = re.compile('[\n\r\t]+')
+    splitter_re = re.compile("[\n\r\t]+")
     if isinstance(items, Mapping):
         items = items.items()
     for k, v in items:
-        if v.startswith('\n'):
+        if v.startswith("\n"):
             v = splitter_re.split(v[1:])
             v = [vv.strip() for vv in v if vv.strip()]
         yield k, v
@@ -433,5 +435,5 @@ def preprocess_ini_section_items(items: Union[Mapping, Iterable]) -> Generator:
         items = items.items()
     for k, v in items:
         if isinstance(v, list):
-            v = '\n\t' + '\n\t'.join(v)
+            v = "\n\t" + "\n\t".join(v)
         yield k, v

config2py/tests/test_tools.py

@@ -12,21 +12,21 @@ from config2py.tests.utils_for_testing import user_input_patch
 
 @pytest.fixture
 def mock_config_store_factory():
-    with patch('config2py.tools.get_configs_local_store') as mock_factory:
+    with patch("config2py.tools.get_configs_local_store") as mock_factory:
         yield mock_factory
 
 
 def test_simple_config_getter(mock_config_store_factory):
-    key = '_CONFIG2PY_SAFE_TO_DELETE_VAR_'
+    key = "_CONFIG2PY_SAFE_TO_DELETE_VAR_"
 
     # Set up mock config store
-    mock_config_store = {key: 'from store'}
+    mock_config_store = {key: "from store"}
     mock_config_store_factory.return_value = mock_config_store
 
     # Test getting config from environment variable
-    os.environ[key] = 'from env var'
+    os.environ[key] = "from env var"
     config_getter = simple_config_getter(first_look_in_env_vars=True)
-    assert config_getter(key) == 'from env var'
+    assert config_getter(key) == "from env var"
 
     # Test getting config from central config store
     del os.environ[key]  # delete env var to test central config store
@@ -34,9 +34,9 @@ def test_simple_config_getter(mock_config_store_factory):
     # assert config_getter(key) == "from store"
 
     # Test getting config with ask_user_if_key_not_found=True
-    with patch('builtins.input', return_value='from user'):
+    with patch("builtins.input", return_value="from user"):
         config_getter = simple_config_getter(ask_user_if_key_not_found=True)
-        assert config_getter('new_key') == 'from user'
+        assert config_getter("new_key") == "from user"
 
     # TODO: Make this test work
     # Test that config_getter.configs is set correctly
@@ -57,7 +57,7 @@ def test_simple_config_getter_with_user_input(monkeypatch):
     my_get_config = simple_config_getter(
         local_config_dir, ask_user_if_key_not_found=True
     )
-    config_name = 'SOME_CONFIG_NAME'
+    config_name = "SOME_CONFIG_NAME"
 
     # make sure config_name not in environment or local_config_dir
     assert config_name not in os.environ
@@ -67,41 +67,41 @@ def test_simple_config_getter_with_user_input(monkeypatch):
     # should try to get it from the user
 
     # Use monkeypatch to replace the input function with the mock_input function
-    user_inputs('')  # user enters nothing
-    val = my_get_config(config_name, default='default_value')
+    user_inputs("")  # user enters nothing
+    val = my_get_config(config_name, default="default_value")
 
     # This the user didn't enter anything, the default value should be returned:
-    assert val == 'default_value'
+    assert val == "default_value"
 
     # Still no config_name in the local_config_dir
     assert config_name not in os.listdir(local_config_dir)
 
-    user_inputs('user_value')  # user enters user_value
-    val = my_get_config(config_name, default='default_value')
+    user_inputs("user_value")  # user enters user_value
+    val = my_get_config(config_name, default="default_value")
     # Now the user entered a value, so that value should be returned:
-    assert val == 'user_value'
+    assert val == "user_value"
 
     # And now there's a config_name in the local_config_dir
     assert config_name in os.listdir(local_config_dir)
 
 
 def test_source_config_params():
-    @source_config_params('a', 'b')
+    @source_config_params("a", "b")
     def foo(a, b, c):
         return a, b, c
 
-    config = {'a': 1, 'b': 2, 'c': 3}
-    _v = foo(a='a', b='b', c=3, _config_getter=config.get)
+    config = {"a": 1, "b": 2, "c": 3}
+    _v = foo(a="a", b="b", c=3, _config_getter=config.get)
     assert _v == (1, 2, 3)
 
-    @source_config_params('a', 'b')
+    @source_config_params("a", "b")
     def bar(a, b, c, **kw):
-        assert 'kw' not in kw, f'kw should be unpacked into **kw. Got: {kw=}'
+        assert "kw" not in kw, f"kw should be unpacked into **kw. Got: {kw=}"
         return a + b + c + sum(kw.values())
 
-    _v = bar(a='a', b='b', c=3, d=4, e=5, _config_getter=config.get)
+    _v = bar(a="a", b="b", c=3, d=4, e=5, _config_getter=config.get)
     assert _v == 15
 
 
-if __name__ == '__main__':
-    pytest.main(['-v', __file__])
+if __name__ == "__main__":
+    pytest.main(["-v", __file__])

config2py/tests/utils_for_testing.py

@@ -2,4 +2,4 @@ from functools import partial
 
 
 def user_input_patch(monkeypatch, user_input_string: str):
-    monkeypatch.setattr('builtins.input', lambda _: user_input_string)
+    monkeypatch.setattr("builtins.input", lambda _: user_input_string)

config2py/tools.py

@@ -8,6 +8,7 @@ import os
 from i2 import Sig
 
 from config2py.util import (
+    envvar,
     get_configs_folder_for_app,
     DFLT_CONFIG_FOLDER,
     is_repl,
@@ -44,7 +45,7 @@ def get_configs_local_store(
         # TODO: Not tested
         # TODO: Make this open-closed plug-in via routing argument
         _, extension = os.path.splitext(config_src)
-        if extension in {'.ini', '.cfg'}:
+        if extension in {".ini", ".cfg"}:
             from config2py.s_configparser import ConfigStore
 
             return ConfigStore(config_src)
@@ -54,8 +55,8 @@ def get_configs_local_store(
         return TextFiles(path)
     else:
         raise ValueError(
-            f'config_src must be a directory, ini or cfg file, or app name. '
-            f'Was: {config_src}'
+            f"config_src must be a directory, ini or cfg file, or app name. "
+            f"Was: {config_src}"
         )
 
 
@@ -89,7 +90,7 @@ def simple_config_getter(
     central_configs = config_store_factory(configs_src)
     sources = []
     if first_look_in_env_vars:
-        sources.append(os.environ)
+        sources.append(envvar)
     sources.append(central_configs)
     if ask_user_if_key_not_found is None:
         # if the user didn't ask for anythin explicit (True or False), then
@@ -126,13 +127,13 @@ configs = local_configs  # TODO: backwards compatibility alias
 
 # --------------------------------------------------------------------
 
-export_line_p = re.compile('export .+')
+export_line_p = re.compile("export .+")
 export_p = re.compile(r'(\w+)\s?\=\s?"(.+)"')
 
 _extract_name_and_value_from_export_line = Pipe(
-    lambda x: x[len('export ') :],
+    lambda x: x[len("export ") :],
     lambda x: export_p.match(x),
-    lambda x: x.groups() if x else '',
+    lambda x: x.groups() if x else "",
 )
 
 
@@ -155,7 +156,7 @@ def extract_exports(exports: str) -> dict:
     then this simple parser can be useful.
 
     """
-    if '\n' not in exports and Path(resolve_path(exports)).is_file():
+    if "\n" not in exports and Path(resolve_path(exports)).is_file():
         exports = Path(resolve_path(exports)).read_text()
     return dict(
         filter(
@@ -211,7 +212,7 @@ def source_config_params(*config_params):
 
         sig = Sig(func)
 
-        @sig.add_params(['_config_getter'])
+        @sig.add_params(["_config_getter"])
         def wrapped_func(*args, _config_getter, **kwargs):
             def source(k, v):
                 if k == sig.var_keyword_name:

config2py/util.py

@@ -3,20 +3,23 @@
 import re
 import os
 import ast
+from collections import ChainMap
 from pathlib import Path
 from typing import Optional, Union, Any, Callable, Set, Iterable
 import getpass
 
+from dol import process_path
+
 from i2 import mk_sentinel  # TODO: Only i2 dependency. Consider replacing.
 
 # def mk_sentinel(name):  # TODO: Only i2 dependency. Here's replacement, but not picklable
 #     return type(name, (), {'__repr__': lambda self: name})()
 
-DFLT_APP_NAME = 'config2py'
+DFLT_APP_NAME = "config2py"
 DFLT_MASKING_INPUT = False
 
-not_found = mk_sentinel('not_found')
-no_default = mk_sentinel('no_default')
+not_found = mk_sentinel("not_found")
+no_default = mk_sentinel("no_default")
 
 
 def always_true(x: Any) -> bool:
@@ -34,10 +37,34 @@ def is_not_empty(x: Any) -> bool:
     return bool(x)
 
 
+# Note: Why subclassing ChainMap works, but subclassing dict doesn't.
+# The `EnvironmentVariables` class inherits from `collections.ChainMap` and wraps
+# `os.environ`, providing a dynamic view of the environment variables without exposing
+# sensitive data. Unlike a regular `dict` copy, which creates a static snapshot,
+# `ChainMap` maintains a live reference to `os.environ`, so any changes to the
+# environment—whether through `os.environ['KEY'] = 'value'` or external updates—are
+# immediately reflected in `EnvironmentVariables`. Overriding `__repr__` ensures that
+# printing the object (e.g., in a REPL or log) hides the actual contents,
+# preserving confidentiality while retaining full read/write functionality.
+class EnvironmentVariables(ChainMap):
+    """
+    Class to wrap environment variables without revealing sensitive information.
+    """
+
+    def __init__(self):
+        super().__init__(os.environ)
+
+    def __repr__(self):
+        return "EnvironmentVariables"
+
+
+envvar = EnvironmentVariables()
+
+
 # TODO: Make this into an open-closed mini-framework
 def ask_user_for_input(
     prompt: str,
-    default: str = '',
+    default: str = "",
     *,
     mask_input=DFLT_MASKING_INPUT,
     masking_toggle_str: str = None,
@@ -57,16 +84,16 @@ def ask_user_for_input(
     :return: The user's response (or the default value if the user entered nothing)
     """
     _original_prompt = prompt
-    if prompt[-1] != ' ':  # pragma: no cover
-        prompt = prompt + ' '
+    if prompt[-1] != " ":  # pragma: no cover
+        prompt = prompt + " "
     if masking_toggle_str is not None:
         prompt = (
-            f'{prompt}\n'
+            f"{prompt}\n"
             f"    (Input masking is {'ENABLED' if mask_input else 'DISABLED'}. "
             f"Enter '{masking_toggle_str}' (without quotes) to toggle input masking)\n"
         )
-    if default not in {''}:
-        prompt = prompt + f' [{default}]: '
+    if default not in {""}:
+        prompt = prompt + f" [{default}]: "
     if mask_input:
         _prompt_func = getpass.getpass
     else:
@@ -149,8 +176,8 @@ def extract_variable_declarations(
         expand = None
 
     env_vars = {}
-    pattern = re.compile(r'^export\s+([A-Za-z0-9_]+)=(.*)$')
-    lines = string.split('\n')
+    pattern = re.compile(r"^export\s+([A-Za-z0-9_]+)=(.*)$")
+    lines = string.split("\n")
     for line in lines:
         line = line.strip()
         match = pattern.match(line)
@@ -159,7 +186,7 @@ def extract_variable_declarations(
             value = match.group(2).strip('"')
             if expand is not None:
                 for key, val in expand.items():
-                    value = value.replace(f'${key}', val)
+                    value = value.replace(f"${key}", val)
                 env_vars[name] = value
                 expand = dict(expand, **env_vars)
             else:
@@ -169,79 +196,80 @@ def extract_variable_declarations(
 
 def _system_default_for_app_data_folder():
     """Get the system default for the app data folder."""
-    if os.name == 'nt':
+    if os.name == "nt":
         # Windows
-        app_data_folder = os.getenv('APPDATA')
+        app_data_folder = os.getenv("APPDATA")
     else:
         # macOS and Linux/Unix
-        app_data_folder = os.path.expanduser('~/.config')
+        app_data_folder = os.path.expanduser("~/.config")
     return app_data_folder
 
 
 DFLT_APP_DATA_FOLDER = os.getenv(
-    'CONFIG2PY_APP_DATA_FOLDER', _system_default_for_app_data_folder()
+    "CONFIG2PY_APP_DATA_FOLDER", _system_default_for_app_data_folder()
 )
 
 
-def process_path(
-    *path: Iterable[str],
-    ensure_dir_exists=False,
-    assert_exists=False,
-    ensure_endswith_slash=False,
-    ensure_does_not_end_with_slash=False,
-    expanduser=True,
-    expandvars=True,
-    abspath=True,
-    rootdir: str = '',
-) -> str:
+def create_directories(dirpath, max_dirs_to_make=None):
     """
-    Process a path string, ensuring it exists, and optionally expanding user.
+    Create directories up to a specified limit.
 
-    Args:
-        path (Iterable[str]): The path to process. Can be multiple components of a path.
-        ensure_dir_exists (bool): Whether to ensure the path exists.
-        assert_exists (bool): Whether to assert that the path exists.
-        ensure_endswith_slash (bool): Whether to ensure the path ends with a slash.
-        ensure_does_not_end_with_slash (bool): Whether to ensure the path does not end with a slash.
-        expanduser (bool): Whether to expand the user in the path.
-        expandvars (bool): Whether to expand environment variables in the path.
-        abspath (bool): Whether to convert the path to an absolute path.
-        rootdir (str): The root directory to prepend to the path.
+    Parameters:
+    dirpath (str): The directory path to create.
+    max_dirs_to_make (int, optional): The maximum number of directories to create. If None, there's no limit.
 
     Returns:
-        str: The processed path.
+    bool: True if the directory was created successfully, False otherwise.
+
+    Raises:
+    ValueError: If max_dirs_to_make is negative.
+
+    Examples:
+    >>> import tempfile, shutil
+    >>> temp_dir = tempfile.mkdtemp()
+    >>> target_dir = os.path.join(temp_dir, 'a', 'b', 'c')
+    >>> create_directories(target_dir, max_dirs_to_make=2)
+    False
+    >>> create_directories(target_dir, max_dirs_to_make=3)
+    True
+    >>> os.path.isdir(target_dir)
+    True
+    >>> shutil.rmtree(temp_dir)  # Cleanup
+
+    >>> temp_dir = tempfile.mkdtemp()
+    >>> target_dir = os.path.join(temp_dir, 'a', 'b', 'c', 'd')
+    >>> create_directories(target_dir)
+    True
+    >>> os.path.isdir(target_dir)
+    True
+    >>> shutil.rmtree(temp_dir)  # Cleanup
+    """
+    if max_dirs_to_make is not None and max_dirs_to_make < 0:
+        raise ValueError("max_dirs_to_make must be non-negative or None")
 
-    >>> process_path('a', 'b', 'c')  # doctest: +ELLIPSIS
-    '...a/b/c'
-    >>> from functools import partial
-    >>> process_path('a', 'b', 'c', rootdir='/root/dir/', ensure_endswith_slash=True)
-    '/root/dir/a/b/c/'
+    if os.path.exists(dirpath):
+        return True
 
-    """
-    path = os.path.join(*path)
-    if ensure_endswith_slash and ensure_does_not_end_with_slash:
-        raise ValueError(
-            'Cannot ensure both ends with slash and does not end with slash.'
-        )
-    if rootdir:
-        path = os.path.join(rootdir, path)
-    if expanduser:
-        path = os.path.expanduser(path)
-    if expandvars:
-        path = os.path.expandvars(path)
-    if abspath:
-        path = os.path.abspath(path)
-    if ensure_endswith_slash:
-        if not path.endswith('/'):
-            path = path + '/'
-    if ensure_does_not_end_with_slash:
-        if path.endswith('/'):
-            path = path[:-1]
-    if ensure_dir_exists:
-        os.makedirs(path, exist_ok=True)
-    if assert_exists:
-        assert os.path.exists(path), f'Path does not exist: {path}'
-    return path
+    if max_dirs_to_make is None:
+        os.makedirs(dirpath, exist_ok=True)
+        return True
+
+    # Calculate the number of directories to create
+    dirs_to_make = []
+    current_path = dirpath
+
+    while not os.path.exists(current_path):
+        dirs_to_make.append(current_path)
+        current_path, _ = os.path.split(current_path)
+
+    if len(dirs_to_make) > max_dirs_to_make:
+        return False
+
+    # Create directories from the top level down
+    for dir_to_make in reversed(dirs_to_make):
+        os.mkdir(dir_to_make)
+
+    return True
 
 
 # Note: First possible i2 dependency -- vendoring for now
@@ -291,7 +319,7 @@ def _default_folder_setup(directory_path: str) -> None:
         # Add a hidden file to annotate the directory as one managed by config2py.
         # This helps distinguish it from directories created by other programs
         # (this can be useful to avoid conflicts).
-        (Path(directory_path) / '.config2py').write_text('Created by config2py.')
+        (Path(directory_path) / ".config2py").write_text("Created by config2py.")
 
 
 def get_app_data_folder(
@@ -344,7 +372,7 @@ def get_app_data_folder(
     return app_data_path
 
 
-DFLT_CONFIGS_NAME = 'configs'
+DFLT_CONFIGS_NAME = "configs"
 
 
 # TODO: is "get" the right word, since it makes the folder too?
@@ -384,11 +412,11 @@ import sys
 
 
 def _get_ipython_in_globals():
-    return 'get_ipython' in globals()
+    return "get_ipython" in globals()
 
 
 def _main_does_not_have_file_attribute():
-    return not hasattr(sys.modules['__main__'], '__file__')
+    return not hasattr(sys.modules["__main__"], "__file__")
 
 
 _repl_conditions = {_get_ipython_in_globals, _main_does_not_have_file_attribute}

{config2py-0.1.35.dist-info → config2py-0.1.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: config2py
-Version: 0.1.35
+Version: 0.1.37
 Summary: Simplified reading and writing configurations from various sources and formats
 Home-page: https://github.com/i2mint/config2py
 Author: OtoSense
@@ -10,7 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dol
 Requires-Dist: i2
-Requires-Dist: importlib-resources ; python_version < "3.9"
+Requires-Dist: importlib-resources; python_version < "3.9"
 
 # config2py
 

config2py-0.1.37.dist-info/RECORD

@@ -0,0 +1,15 @@
+config2py/__init__.py,sha256=GZ8lkm8TOKrV-zVd_Tc_8XVXDzFePECacjhOSGe2xcs,844
+config2py/base.py,sha256=eQpRQjZYT-z6GhBemepaPUEyVVP8e_l04dghYeBBJdI,15880
+config2py/errors.py,sha256=QdwGsoJhv6LHDHp-_yyz4oUg1Fgu4S-S7O2nuA0a5cw,203
+config2py/s_configparser.py,sha256=-Sl2-J-QOLUiahwhCTiPsmjs4cKc79JuTbQ9gQcOiGY,15871
+config2py/tools.py,sha256=goDuHHXKJzdFgmHzDnLBGMZEhp0kKU-aK47c1-MpJT8,9199
+config2py/util.py,sha256=bchsJjaMnsfnplCJsg7i0Osyzuha3N-hExuc6gmS-7I,17188
+config2py/scrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+config2py/tests/__init__.py,sha256=sk-yGJQOZES2z70M4xmZB57tsxSktX_84ybDuV8Cz5Q,297
+config2py/tests/test_tools.py,sha256=sdiBNTavuzxW2AsqBRTO9U21iWig5DEyV38r6lmaZak,3728
+config2py/tests/utils_for_testing.py,sha256=RcMiVtKK39rc8BsgIXQH3RCkd8qKo2o2MT7Rt0dJF2E,162
+config2py-0.1.37.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+config2py-0.1.37.dist-info/METADATA,sha256=oVY9jkk7t4epX9WoV1luTW6z2E-enwqfm92p2M9xyQU,14558
+config2py-0.1.37.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+config2py-0.1.37.dist-info/top_level.txt,sha256=DFnlOIKMIGWQRROr3voJFhWFViHaWgTTeWZjC5YC9QQ,10
+config2py-0.1.37.dist-info/RECORD,,

{config2py-0.1.35.dist-info → config2py-0.1.37.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

config2py/tests/test_util.py

@@ -1,39 +0,0 @@
-import tempfile
-import os
-import pytest
-from config2py.util import process_path
-
-
-def test_process_path():
-    # Create a temporary directory
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = os.path.join(temp_dir, 'foo/bar')
-
-        output_path = process_path(temp_path)
-        assert output_path == temp_path
-        assert not os.path.exists(output_path)
-
-        output_path = process_path(temp_path, expanduser=False)
-        assert output_path == temp_path
-        assert not os.path.exists(output_path)
-
-        with pytest.raises(AssertionError):
-            output_path = process_path(temp_path, assert_exists=True)
-
-        output_path = process_path(temp_path, ensure_dir_exists=True)
-        assert output_path == temp_path
-        assert os.path.exists(output_path)
-
-        output_path = process_path(temp_path, assert_exists=True)
-        assert output_path == temp_path
-        assert os.path.exists(output_path)
-
-        # If path doesn't end with a (system file separator) slash, add one:
-        output_path = process_path(temp_path, ensure_endswith_slash=True)
-        assert output_path == temp_path + os.path.sep
-
-        # If path ends with a (system file separator) slash, remove it.
-        output_path = process_path(
-            temp_path + os.path.sep, ensure_does_not_end_with_slash=True
-        )
-        assert output_path == temp_path

config2py-0.1.35.dist-info/RECORD

@@ -1,16 +0,0 @@
-config2py/__init__.py,sha256=ru-bUQk5EuOLzHmNAcElSN8P2saSUEb5KFRkfTkzsUo,770
-config2py/base.py,sha256=fDKClGpgNecWFL9a7Y_FpqwuRxAAD_XCuByW68Yq5KE,15880
-config2py/errors.py,sha256=QdwGsoJhv6LHDHp-_yyz4oUg1Fgu4S-S7O2nuA0a5cw,203
-config2py/s_configparser.py,sha256=XhxFz6-PG4-QsecJfbjLFdBWHcPU6dwgqwkTZyY_y3E,15873
-config2py/tools.py,sha256=W2YQm-PerKRN8prsxVfcBCChx75pZ9H8UqWH8pGxECE,9191
-config2py/util.py,sha256=C9JiGlMcSQozq6H-nuaS02sh49i4irRzSVqofW9Bq74,16460
-config2py/scrap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-config2py/tests/__init__.py,sha256=sk-yGJQOZES2z70M4xmZB57tsxSktX_84ybDuV8Cz5Q,297
-config2py/tests/test_tools.py,sha256=km9RNh-gDtSJNjYiLQdkWcRi9IB5MwpijD3U2XCyi1Y,3728
-config2py/tests/test_util.py,sha256=DNJn60dvyr7xb86Spoz_VDS4cwU2mtcRo1_MgoCrKCY,1391
-config2py/tests/utils_for_testing.py,sha256=Vz6EDY27uy_RZCSceZ7jqXkp_CXe52KAZSXcYKivazM,162
-config2py-0.1.35.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-config2py-0.1.35.dist-info/METADATA,sha256=LN--FD2SE3BMV8vAfAq5CUSaksGY5DbXKw8qyZagzbs,14559
-config2py-0.1.35.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-config2py-0.1.35.dist-info/top_level.txt,sha256=DFnlOIKMIGWQRROr3voJFhWFViHaWgTTeWZjC5YC9QQ,10
-config2py-0.1.35.dist-info/RECORD,,