python-simpleconf 0.7.2__tar.gz → 0.8.0__tar.gz

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-simpleconf
-Version: 0.7.2
+Version: 0.8.0
 Summary: Simple configuration management with python.
 License: MIT
+License-File: LICENSE
 Author: pwwang
 Author-email: pwwang@pwwang.com
 Requires-Python: >=3.9,<4.0
@@ -13,19 +14,21 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: all
-Provides-Extra: cloud
+Provides-Extra: async
 Provides-Extra: env
 Provides-Extra: ini
 Provides-Extra: toml
 Provides-Extra: yaml
+Requires-Dist: aiofiles (>=23.0.0) ; extra == "async"
 Requires-Dist: diot (>=0.3.2,<0.4.0)
 Requires-Dist: iniconfig (>=2.0,<3.0) ; extra == "ini" or extra == "all"
+Requires-Dist: panpath (>=0.4.8,<0.5.0)
 Requires-Dist: python-dotenv (>=1.1,<2.0) ; extra == "env" or extra == "all"
 Requires-Dist: pyyaml (>=6,<7) ; extra == "yaml" or extra == "all"
 Requires-Dist: rtoml (>=0.12,<0.13) ; (sys_platform == "linux") and (extra == "toml" or extra == "all")
 Requires-Dist: tomli (>=2.0,<3.0) ; (sys_platform != "linux") and (extra == "toml" or extra == "all")
-Requires-Dist: yunpath (>=0.0.4,<0.0.5) ; extra == "cloud"
 Project-URL: Homepage, https://github.com/pwwang/simpleconf
 Project-URL: Repository, https://github.com/pwwang/simpleconf
 Description-Content-Type: text/markdown
@@ -60,24 +63,34 @@ pip install python-simpleconf[all]
 - Type casting
 - Profile support
 - Simple APIs
+- Async loading support
 
 ## Usage
 
 ### Loading configurations
 
 ```python
+import asyncio
 from simpleconf import Config
 
-# Load a single file
-conf = Config.load('~/xxx.ini')
-# load multiple files, later files override previous ones
-conf = Config.load(
-   '~/xxx.ini', '~/xxx.env', '~/xxx.yaml', '~/xxx.toml',
-   '~/xxx.json', 'simpleconf.osenv', {'a': 3}
-)
 
-# Load a single file with a different loader
-conf = Config.load('~/xxx.ini', loader="toml")
+async def main():
+  # Load a single file
+  conf = Config.load('~/xxx.ini')
+  # load multiple files, later files override previous ones
+  conf = Config.load(
+    '~/xxx.ini', '~/xxx.env', '~/xxx.yaml', '~/xxx.toml',
+    '~/xxx.json', 'simpleconf.osenv', {'a': 3}
+  )
+
+  # Load a single file with a different loader
+  conf = Config.load('~/xxx.ini', loader="toml")
+
+  # Async loading
+  conf = await Config.a_load('~/xxx.ini')
+
+if __name__ == "__main__":
+  asyncio.run(main())
 ```
 
 ### Accessing configuration values
@@ -115,6 +128,10 @@ from simpleconf import ProfileConfig
 
 conf = ProfileConfig.load({'default': {'a': 1})
 # conf.a == 1
+
+# Asynchronous loading
+# conf = await ProfileConfig.a_load({'default': {'a': 1})
+# conf.a == 1
 ```
 
 ##### Loading a `.env` file

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/README.md

@@ -28,24 +28,34 @@ pip install python-simpleconf[all]
 - Type casting
 - Profile support
 - Simple APIs
+- Async loading support
 
 ## Usage
 
 ### Loading configurations
 
 ```python
+import asyncio
 from simpleconf import Config
 
-# Load a single file
-conf = Config.load('~/xxx.ini')
-# load multiple files, later files override previous ones
-conf = Config.load(
-   '~/xxx.ini', '~/xxx.env', '~/xxx.yaml', '~/xxx.toml',
-   '~/xxx.json', 'simpleconf.osenv', {'a': 3}
-)
 
-# Load a single file with a different loader
-conf = Config.load('~/xxx.ini', loader="toml")
+async def main():
+  # Load a single file
+  conf = Config.load('~/xxx.ini')
+  # load multiple files, later files override previous ones
+  conf = Config.load(
+    '~/xxx.ini', '~/xxx.env', '~/xxx.yaml', '~/xxx.toml',
+    '~/xxx.json', 'simpleconf.osenv', {'a': 3}
+  )
+
+  # Load a single file with a different loader
+  conf = Config.load('~/xxx.ini', loader="toml")
+
+  # Async loading
+  conf = await Config.a_load('~/xxx.ini')
+
+if __name__ == "__main__":
+  asyncio.run(main())
 ```
 
 ### Accessing configuration values
@@ -83,6 +93,10 @@ from simpleconf import ProfileConfig
 
 conf = ProfileConfig.load({'default': {'a': 1})
 # conf.a == 1
+
+# Asynchronous loading
+# conf = await ProfileConfig.a_load({'default': {'a': 1})
+# conf.a == 1
 ```
 
 ##### Loading a `.env` file

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "python-simpleconf"
-version = "0.7.2"
+version = "0.8.0"
 description = "Simple configuration management with python."
 authors = [ "pwwang <pwwang@pwwang.com>",]
 license = "MIT"
@@ -20,33 +20,37 @@ python = "^3.9"
 diot = "^0.3.2"
 python-dotenv = { version="^1.1", optional = true}
 pyyaml = { version="^6", optional = true}
+panpath = "^0.4.8"
 # Use rtoml only when the wheel is available (linux)
 rtoml = {version = "^0.12", optional = true, platform = "linux"}
 tomli = {version = "^2.0", optional = true, markers = 'sys_platform != "linux"'}
 iniconfig = {version = "^2.0", optional = true}
-yunpath = {version = "^0.0.4", optional = true}
+aiofiles = {version = ">=23.0.0", optional = true}
 
 [tool.poetry.extras]
 ini = [ "iniconfig" ]
 env = [ "python-dotenv"]
 yaml = [ "pyyaml"]
 toml = [ "rtoml", "tomli"]
+async = [ "aiofiles"]
 all = [ "iniconfig", "python-dotenv", "pyyaml", "rtoml", "tomli"]
-cloud = [ "yunpath"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8"
 pytest-cov = "^6"
+pytest-asyncio = "^1"
+backports-asyncio-runner = {version = "^1.1.0", python = "<3.11"}
 
 [tool.pytest.ini_options]
-addopts = "-vv -p no:asyncio --cov=simpleconf --cov-report xml:cov.xml --cov-report term-missing"
+addopts = "-vv --cov=simpleconf --cov-report xml:cov.xml --cov-report term-missing"
 filterwarnings = [
     "error"
 ]
 console_output_style = "progress"
 junit_family = "xunit1"
+asyncio_mode = "auto"
 
 [tool.black]
 line-length = 88
-target-version = ['py37', 'py38', 'py39', 'py310']
+target-version = ['py39', 'py310', 'py311', 'py312']
 include = '\.pyi?$'

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/__init__.py

@@ -1,3 +1,3 @@
 from .config import Config, ProfileConfig
 
-__version__ = "0.7.2"
+__version__ = "0.8.0"

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/config.py

@@ -14,8 +14,9 @@ LoaderType = Union[str, Loader, None]
 class Config:
     """The configuration class"""
 
-    @staticmethod
+    @classmethod
     def load(
+        cls,
         *configs: Any,
         loader: LoaderType | Sequence[LoaderType] = None,
         ignore_nonexist: bool = False,
@@ -50,8 +51,51 @@ class Config:
 
         return out
 
-    @staticmethod
+    @classmethod
+    async def a_load(
+        cls,
+        *configs: Any,
+        loader: LoaderType | Sequence[LoaderType] = None,
+        ignore_nonexist: bool = False,
+    ) -> Diot:
+        """Asynchronously load the configuration from the files, or other
+        configurations
+
+        Args:
+            *configs: The configuration files or other configurations to load
+                Latter ones will override the former ones for items with the
+                same keys recursively.
+            loader: The loader to use. If a list is given, it must have the
+                same length as configs.
+            ignore_nonexist: Whether to ignore non-existent files
+                Otherwise, will raise errors
+
+        Returns:
+            A Diot object with the loaded configurations
+        """
+        if not isinstance(loader, Sequence) or isinstance(loader, str):
+            loader = [loader] * len(configs)
+
+        if len(loader) != len(configs):
+            raise ValueError(
+                f"Length of loader ({len(loader)}) does not match "
+                f"length of configs ({len(configs)})"
+            )
+
+        out = Diot()
+        for i, conf in enumerate(configs):
+            loaded = await cls.a_load_one(
+                conf,
+                loader[i],
+                ignore_nonexist,
+            )
+            out.update_recursively(loaded)
+
+        return out
+
+    @classmethod
     def load_one(
+        cls,
         config,
         loader: str | Loader | None = None,
         ignore_nonexist: bool = False,
@@ -78,12 +122,42 @@ class Config:
 
         return loader.load(config, ignore_nonexist)
 
+    @classmethod
+    async def a_load_one(
+        cls,
+        config,
+        loader: str | Loader | None = None,
+        ignore_nonexist: bool = False,
+    ) -> Diot:
+        """Asynchronously load the configuration from the file
+
+        Args:
+            config: The configuration file to load
+            loader: The loader to use
+            ignore_nonexist: Whether to ignore non-existent files
+                Otherwise, will raise errors
+
+        Returns:
+            A Diot object with the loaded configuration
+        """
+        if loader is None:
+            if hasattr(config, "read"):
+                raise ValueError("'loader' must be specified for stream")
+
+            ext = config_to_ext(config)
+            loader = get_loader(ext)
+        else:
+            loader = get_loader(loader)
+
+        return await loader.a_load(config, ignore_nonexist)
+
 
 class ProfileConfig:
     """The configuration class with profile support"""
 
-    @staticmethod
+    @classmethod
     def load(
+        cls,
         *configs: Any,
         loader: LoaderType | Sequence[LoaderType] = None,
         ignore_nonexist: bool = False,
@@ -146,8 +220,78 @@ class ProfileConfig:
 
         return out
 
-    @staticmethod
+    @classmethod
+    async def a_load(
+        cls,
+        *configs: Any,
+        loader: LoaderType | Sequence[LoaderType] = None,
+        ignore_nonexist: bool = False,
+        base: str = "default",
+        allow_missing_base: bool = False,
+    ) -> Diot:
+        """Asynchronously load the configuration from the files, or other
+        configurations
+
+        Args:
+            *configs: The configuration files or other configurations to load
+                Latter ones will override the former ones for items with the
+                same profile and keys recursively.
+            loader: The loader to use. If a list is given, it must have the
+                same length as configs.
+            ignore_nonexist: Whether to ignore non-existent files
+                Otherwise, will raise errors
+            base: The default profile to use after loading
+            allow_missing_base: Whether to allow missing base profile
+                If False, will raise errors when the base profile is not found
+                in the loaded profiles.
+
+        Returns:
+            A Diot object with the loaded configurations
+        """
+        if not isinstance(loader, Sequence) or isinstance(loader, str):
+            loader = [loader] * len(configs)
+
+        if len(loader) != len(configs):
+            raise ValueError(
+                f"Length of loader ({len(loader)}) does not match "
+                f"length of configs ({len(configs)})"
+            )
+
+        out = Diot({POOL_KEY: Diot()})
+        pool = out[POOL_KEY]
+        out[META_KEY] = {
+            "current_profile": None,
+            "base_profile": None,
+        }
+        for i, conf in enumerate(configs):
+            lder = loader[i]
+
+            if lder is None and hasattr(conf, "read"):
+                raise ValueError("'loader' must be specified for stream")
+
+            if lder is None:
+                ext = config_to_ext(conf)
+                lder = get_loader(ext)
+            else:
+                lder = get_loader(lder)
+
+            loaded = await lder.a_load_with_profiles(conf, ignore_nonexist)
+            for profile, value in loaded.items():
+                profile = profile.lower()
+                pool.setdefault(profile, Diot())
+                pool[profile].update_recursively(value)
+
+        if base and base not in pool and not allow_missing_base:
+            raise ValueError(f"Base profile '{base}' not found")
+
+        if base and base in pool:
+            out = ProfileConfig.use_profile(out, base, base=base)
+
+        return out
+
+    @classmethod
     def load_one(
+        cls,
         conf: Any,
         loader: str | Loader | None = None,
         ignore_nonexist: bool = False,
@@ -197,6 +341,61 @@ class ProfileConfig:
 
         return out
 
+    @classmethod
+    async def a_load_one(
+        cls,
+        conf: Any,
+        loader: str | Loader | None = None,
+        ignore_nonexist: bool = False,
+        base: str = "default",
+        allow_missing_base: bool = False,
+    ) -> Diot:
+        """Asynchronously load the configuration from the file
+
+        Args:
+            conf: The configuration file to load
+            loader: The loader to use. Will detect from conf by default
+            ignore_nonexist: Whether to ignore non-existent files
+                Otherwise, will raise errors
+            base: The default profile to use after loading
+            allow_missing_base: Whether to allow missing base profile
+                If False, will raise errors when the base profile is not found
+                in the loaded profiles.
+
+        Returns:
+            A Diot object with the loaded configuration
+        """
+
+        out = Diot({POOL_KEY: Diot()})
+        pool = out[POOL_KEY]
+        out[META_KEY] = {
+            "current_profile": None,
+            "base_profile": None,
+        }
+
+        if loader is None:
+            if hasattr(conf, "read"):
+                raise ValueError("'loader' must be specified for stream")
+
+            ext = config_to_ext(conf)
+            loader = get_loader(ext)
+        else:
+            loader = get_loader(loader)
+
+        loaded = await loader.a_load_with_profiles(conf, ignore_nonexist)
+        for profile, value in loaded.items():
+            profile = profile.lower()
+            pool.setdefault(profile, Diot())
+            pool[profile].update_recursively(value)
+
+        if base and base not in pool and not allow_missing_base:
+            raise ValueError(f"Base profile '{base}' not found")
+
+        if base and base in pool:
+            out = ProfileConfig.use_profile(out, base, base=base)
+
+        return out
+
     @staticmethod
     def use_profile(
         conf: Diot,

python_simpleconf-0.8.0/simpleconf/loaders/__init__.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Callable, List, Dict
+from pathlib import Path
+
+from diot import Diot
+from panpath import PanPath
+from ..caster import cast
+
+
+class Loader(ABC):
+
+    CASTERS: List[Callable[[str, bool], Any]] | None = None
+
+    @staticmethod
+    def _convert_path(conf: str | Path) -> Path:
+        """Convert the conf to Path if it is a string"""
+        if isinstance(conf, (str, Path)):
+            return PanPath(conf)
+        return conf
+
+    @abstractmethod
+    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Load the configuration from the path or configurations"""
+
+    @abstractmethod
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from the path or configurations"""
+
+    @classmethod
+    def _convert(cls, conf: Any, loaded: Any) -> Diot:
+        """Convert the loaded configuration to Diot"""
+        if cls.CASTERS:
+            loaded = cast(loaded, cls.CASTERS)
+
+        return Diot(loaded)
+
+    @classmethod
+    def _convert_with_profiles(cls, conf: Any, loaded: Any) -> Diot:
+        """Convert the loaded configuration with profiles to Diot"""
+        return Diot(loaded)
+
+    def _exists(self, conf: str | Path, ignore_exist: bool) -> bool:
+        """Check if the configuration file exists"""
+        path = self.__class__._convert_path(conf)
+        exists = path.exists()
+        if not ignore_exist and not exists:
+            raise FileNotFoundError(f"{conf} does not exist")
+        return exists
+
+    async def _a_exists(self, conf: str | Path, ignore_exist: bool) -> bool:
+        """Asynchronously check if the configuration file exists"""
+        path = self.__class__._convert_path(conf)
+        exists = await path.a_exists()
+        if not ignore_exist and not exists:
+            raise FileNotFoundError(f"{conf} does not exist")
+        return exists
+
+    def load(self, conf: Any, ignore_nonexist: bool = False) -> Diot:
+        """Load the configuration from the path or configurations and cast
+        values
+
+        Args:
+            conf: The configuration file to load
+
+        Returns:
+            The Diot object
+        """
+        path = self.__class__._convert_path(conf)
+        loaded = self.loading(path, ignore_nonexist)
+        return self.__class__._convert(conf, loaded)
+
+    async def a_load(self, conf: Any, ignore_nonexist: bool = False) -> Diot:
+        """Asynchronously load the configuration from the path or configurations
+        and cast values
+
+        Args:
+            conf: The configuration file to load
+
+        Returns:
+            The Diot object
+        """
+        path = self.__class__._convert_path(conf)
+        loaded = await self.a_loading(path, ignore_nonexist)
+        return self.__class__._convert(conf, loaded)
+
+    def load_with_profiles(  # type: ignore[override]
+        self,
+        conf: Any,
+        ignore_nonexist: bool = False,
+    ) -> Diot:
+        """Load the configuration from the path or configurations with profiles
+        and cast values
+
+        Args:
+            conf: The configuration file to load
+
+        Returns:
+            The Diot object
+        """
+        path = self.__class__._convert_path(conf)
+        loaded = self.loading(path, ignore_nonexist)
+        return self.__class__._convert_with_profiles(conf, loaded)
+
+    async def a_load_with_profiles(  # type: ignore[override]
+        self,
+        conf: Any,
+        ignore_nonexist: bool = False,
+    ) -> Diot:
+        """Asynchronously load the configuration from the path or configurations
+        with profiles and cast values
+
+        Args:
+            conf: The configuration file to load
+
+        Returns:
+            The Diot object
+        """
+        path = self.__class__._convert_path(conf)
+        loaded = await self.a_loading(path, ignore_nonexist)
+        return self.__class__._convert_with_profiles(conf, loaded)
+
+
+class NoConvertingPathMixin(ABC):
+    """String loader base class"""
+
+    @staticmethod
+    def _convert_path(conf: str) -> str:
+        return conf
+
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from a toml file"""
+        return self.loading(conf, ignore_nonexist)

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/dict.py

@@ -14,6 +14,10 @@ class DictLoader(Loader):
         """Load the configuration from a dict"""
         return conf
 
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from a dict"""
+        return conf
+
 
 class DictsLoader(NoConvertingPathMixin, DictLoader):
     """Dict string loader"""

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/env.py

@@ -1,7 +1,7 @@
 import warnings
 import io
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Awaitable, Dict
 from diot import Diot
 
 from ..utils import require_package
@@ -46,25 +46,37 @@ class EnvLoader(Loader):
 
         return dotenv.main.DotEnv(conf).dict()
 
-    def load_with_profiles(  # type: ignore[override]
-        self,
+    async def a_loading(self, conf, ignore_nonexist):
+        """Asynchronously load the configuration from a .env file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            if isinstance(content, Awaitable):
+                content = await content
+            if isinstance(content, bytes):
+                content = content.decode()
+            return dotenv.dotenv_values(stream=io.StringIO(content))
+
+        if not await self._a_exists(conf, ignore_nonexist):
+            return {}
+
+        return dotenv.main.DotEnv(conf).dict()
+
+    @classmethod
+    def _convert_with_profiles(  # type: ignore[override]
+        cls,
         conf: Any,
-        ignore_nonexist: bool = False,
+        loaded: Dict[str, Any],
     ) -> Diot:
-        """Load and cast the configuration from a .env file with profiles"""
-        envs = self.loading(conf, ignore_nonexist)
         out = Diot()
-        for k, v in envs.items():
+        for k, v in loaded.items():
             if "_" not in k:
-                warnings.warn(
-                    f"{Path(conf).name}: No profile name found in key: {k}"
-                )
+                warnings.warn(f"{Path(conf).name}: No profile name found in key: {k}")
                 continue
             profile, key = k.split("_", 1)
             profile = profile.lower()
             out.setdefault(profile, Diot())[key] = v
 
-        return cast(out, self.__class__.CASTERS)
+        return cast(out, cls.CASTERS)
 
 
 class EnvsLoader(NoConvertingPathMixin, EnvLoader):

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/ini.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Dict
+from typing import Any, Awaitable, Dict
 from pathlib import Path
 from diot import Diot
 
@@ -47,10 +47,28 @@ class IniLoader(Loader):
 
         return iniconfig.IniConfig(conf).sections
 
-    def load(self, conf: Any, ignore_nonexist: bool = False) -> Diot:
-        """Load and cast the configuration from an ini-like file"""
-        sections = self.loading(conf, ignore_nonexist)
-        keys = list(sections)
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from an ini-like file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            if isinstance(content, Awaitable):
+                content = await content
+            if isinstance(content, bytes):
+                content = content.decode()
+            return iniconfig.IniConfig("<config>", content).sections
+
+        if not await self._a_exists(conf, ignore_nonexist):
+            return {"default": {}}
+
+        return iniconfig.IniConfig(conf).sections
+
+    @classmethod
+    def _convert(  # type: ignore[override]
+        cls,
+        conf: Any,
+        loaded: Dict[str, Any],
+    ) -> Diot:
+        keys = list(loaded)
 
         if hasattr(conf, "read"):
             pathname = "<config>"
@@ -66,22 +84,19 @@ class IniLoader(Loader):
             )
 
         if len(keys) == 0 or keys[0].lower() != "default":
-            raise ValueError(
-                f"{pathname}: Only the default section can be loaded."
-            )
+            raise ValueError(f"{pathname}: Only the default section can be loaded.")
 
-        return cast(Diot(sections[keys[0]]), self.__class__.CASTERS)
+        return cast(Diot(loaded[keys[0]]), cls.CASTERS)
 
-    def load_with_profiles(  # type: ignore[override]
-        self,
+    @classmethod
+    def _convert_with_profiles(  # type: ignore[override]
+        cls,
         conf: Any,
-        ignore_nonexist: bool = False,
+        loaded: Dict[str, Any],
     ) -> Diot:
-        """Load and cast the configuration from an ini-like file with profiles"""
-        sections = self.loading(conf, ignore_nonexist)
         out = Diot()
-        for k, v in sections.items():
-            out[k.lower()] = cast(v, self.__class__.CASTERS)
+        for k, v in loaded.items():
+            out[k.lower()] = cast(v, cls.CASTERS)
         return out
 
 

python_simpleconf-0.8.0/simpleconf/loaders/json.py

@@ -0,0 +1,47 @@
+import json
+from typing import Any, Awaitable, Dict
+
+from . import Loader, NoConvertingPathMixin
+
+
+class JsonLoader(Loader):
+    """Json file loader"""
+
+    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Load the configuration from a json file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            return json.loads(content)
+
+        if not self._exists(conf, ignore_nonexist):
+            return {}
+
+        with open(conf) as f:
+            return json.load(f)
+
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from a json file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            if isinstance(content, Awaitable):
+                content = await content
+            if isinstance(content, bytes):
+                content = content.decode()
+            return json.loads(content)
+
+        if not await self._a_exists(conf, ignore_nonexist):
+            return {}
+
+        async with self.__class__._convert_path(conf).a_open() as f:
+            content = await f.read()
+            if isinstance(content, bytes):  # pragma: no cover
+                content = content.decode()
+            return json.loads(content)
+
+
+class JsonsLoader(NoConvertingPathMixin, JsonLoader):
+    """Json string loader"""
+
+    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Load the configuration from a json file"""
+        return json.loads(conf)

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/osenv.py

@@ -1,6 +1,6 @@
+import warnings
 from os import environ
 from typing import Any, Dict
-import warnings
 
 from diot import Diot
 
@@ -42,23 +42,27 @@ class OsenvLoader(NoConvertingPathMixin, Loader):
                 out[k[len_prefix:]] = v
         return out
 
-    def load_with_profiles(  # type: ignore[override]
+    async def a_loading(
         self,
         conf: Any,
         ignore_nonexist: bool = False,
+    ) -> Dict[str, Any]:
+        """Asynchronously load the configuration from environment variables"""
+        return self.loading(conf, ignore_nonexist)
+
+    @classmethod
+    def _convert_with_profiles(  # type: ignore[override]
+        cls,
+        conf: Any,
+        loaded: Dict[str, Any],
     ) -> Diot:
-        prefix = f"{conf[:-6]}_" if len(conf) > 6 else ""
-        len_prefix = len(prefix)
         out = Diot()
-        for k, v in environ.items():
-            if not k.startswith(prefix):
-                continue
-            key = k[len_prefix:]
+        for key, val in loaded.items():
             if "_" not in key:
-                warnings.warn(f"{conf}: No profile name found in key: {k}")
+                warnings.warn(f"{conf}: No profile name found in key: {key}")
                 continue
             profile, key = key.split("_", 1)
             profile = profile.lower()
-            out.setdefault(profile, Diot())[key] = v
+            out.setdefault(profile, Diot())[key] = val
 
-        return cast(out, self.__class__.CASTERS)
+        return cast(out, cls.CASTERS)

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/toml.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, Awaitable
 
 from ..utils import require_package
 from ..caster import (
@@ -34,6 +34,27 @@ class TomlLoader(Loader):
         with open(conf, "r") as f:  # rtoml
             return toml.load(f)
 
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from a toml file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            if isinstance(content, Awaitable):
+                content = await content
+            if isinstance(content, bytes):
+                content = content.decode()
+            return toml.loads(content)
+
+        if not await self._a_exists(conf, ignore_nonexist):
+            return {}
+
+        async with self.__class__._convert_path(conf).a_open("rb") as f:
+            content = await f.read()
+            try:
+                return toml.loads(content)
+            except TypeError:
+                content = content.decode()
+                return toml.loads(content)
+
 
 class TomlsLoader(NoConvertingPathMixin, TomlLoader):
     """Toml string loader"""

{python_simpleconf-0.7.2 → python_simpleconf-0.8.0}/simpleconf/loaders/yaml.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, Awaitable
 
 from . import Loader, NoConvertingPathMixin
 from ..utils import require_package
@@ -21,6 +21,25 @@ class YamlLoader(Loader):
         with open(conf) as f:
             return yaml.load(f, Loader=yaml.FullLoader)
 
+    async def a_loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
+        """Asynchronously load the configuration from a yaml file"""
+        if hasattr(conf, "read"):
+            content = conf.read()
+            if isinstance(content, Awaitable):
+                content = await content
+            if isinstance(content, bytes):
+                content = content.decode()
+            return yaml.load(content, Loader=yaml.FullLoader)
+
+        if not await self._a_exists(conf, ignore_nonexist):
+            return {}
+
+        async with self.__class__._convert_path(conf).a_open() as f:
+            content = await f.read()
+            if isinstance(content, bytes):  # pragma: no cover
+                content = content.decode()
+            return yaml.load(content, Loader=yaml.FullLoader)
+
 
 class YamlsLoader(NoConvertingPathMixin, YamlLoader):
     """Yaml string loader"""

python_simpleconf-0.7.2/simpleconf/loaders/__init__.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Callable, List, Dict
-from pathlib import Path
-
-from diot import Diot
-from ..caster import cast
-
-
-class Loader(ABC):
-
-    CASTERS: List[Callable[[str, bool], Any]] | None = None
-
-    @staticmethod
-    def _convert_path(conf: str | Path) -> Path:
-        """Convert the conf to Path if it is a string"""
-        try:
-            from yunpath import AnyPath
-        except ImportError:
-            AnyPath = Path
-
-        if isinstance(conf, str):
-            return AnyPath(conf)
-        return conf
-
-    @abstractmethod
-    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
-        """Load the configuration from the path or configurations"""
-
-    def _exists(self, conf: str | Path, ignore_exist: bool) -> bool:
-        """Check if the configuration file exists"""
-        path = self.__class__._convert_path(conf)
-        if not ignore_exist and not path.exists():
-            raise FileNotFoundError(f"{conf} does not exist")
-        return path.exists()
-
-    def load(self, conf: Any, ignore_nonexist: bool = False) -> Diot:
-        """Load the configuration from the path or configurations and cast
-        values
-
-        Args:
-            conf: The configuration file to load
-
-        Returns:
-            The Diot object
-        """
-        path = self.__class__._convert_path(conf)
-        loaded = self.loading(path, ignore_nonexist)
-        if self.__class__.CASTERS:
-            loaded = cast(loaded, self.__class__.CASTERS)
-
-        return Diot(loaded)
-
-    load_with_profiles = load
-
-
-class NoConvertingPathMixin(ABC):
-    """String loader base class"""
-
-    @staticmethod
-    def _convert_path(conf: str) -> str:
-        return conf

python_simpleconf-0.7.2/simpleconf/loaders/json.py

@@ -1,28 +0,0 @@
-import json
-from typing import Any, Dict
-
-from . import Loader, NoConvertingPathMixin
-
-
-class JsonLoader(Loader):
-    """Json file loader"""
-
-    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
-        """Load the configuration from a json file"""
-        if hasattr(conf, "read"):
-            content = conf.read()
-            return json.loads(content)
-
-        if not self._exists(conf, ignore_nonexist):
-            return {}
-
-        with open(conf) as f:
-            return json.load(f)
-
-
-class JsonsLoader(NoConvertingPathMixin, JsonLoader):
-    """Json string loader"""
-
-    def loading(self, conf: Any, ignore_nonexist: bool) -> Dict[str, Any]:
-        """Load the configuration from a json file"""
-        return json.loads(conf)