dataconf 3.5.0__tar.gz → 3.7.0__tar.gz

{dataconf-3.5.0 → dataconf-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataconf
-Version: 3.5.0
+Version: 3.7.0
 Summary: Simple dataclasses configuration management for Python with hocon/json/yaml/properties/env-vars/dict support.
 Home-page: https://github.com/zifeo/dataconf
 License: MPL-2.0
@@ -15,9 +15,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: PyYAML (>=6.0.2,<7.0.0)
-Requires-Dist: isodate (>=0.6.1,<0.8.0)
+Requires-Dist: isodate (>=0.7.2,<0.8.0)
 Requires-Dist: pyhocon (>=0.3.61,<0.4.0)
-Requires-Dist: pyparsing (>=3.2.1,<4.0.0)
+Requires-Dist: pyparsing (>=3.2.3,<4.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Project-URL: Repository, https://github.com/zifeo/dataconf
 Description-Content-Type: text/markdown

{dataconf-3.5.0 → dataconf-3.7.0}/dataconf/main.py

@@ -45,13 +45,14 @@ class Multi:
         self.kwargs = kwargs
 
     def env(self, prefix: str, **kwargs) -> "Multi":
-        self.strict = False
         data = env_vars_parse(prefix, os.environ)
-        return self.dict(data, **kwargs)
+        strict = kwargs.pop("strict", False)
+        return self.dict(data, strict=strict, **kwargs)
 
     def dict(self, obj: Dict[str, Any], **kwargs) -> "Multi":
         conf = ConfigFactory.from_dict(obj)
-        return Multi(self.confs + [conf], self.strict, **kwargs)
+        strict = kwargs.pop("strict", self.strict)
+        return Multi(self.confs + [conf], strict, **kwargs)
 
     def string(self, s: str, loader: str = HOCON, **kwargs) -> "Multi":
         if loader == YAML:

{dataconf-3.5.0 → dataconf-3.7.0}/dataconf/utils.py

@@ -42,6 +42,21 @@ if PY310up:
 
 NoneType = type(None)
 
+_BOOL_TRUE = {"true", "1", "yes", "on", "t", "y"}
+_BOOL_FALSE = {"false", "0", "no", "off", "f", "n"}
+
+
+def __parse_bool(value: Any):
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        normalised = value.strip().lower()
+        if normalised in _BOOL_TRUE:
+            return True
+        if normalised in _BOOL_FALSE:
+            return False
+    return None
+
 
 def __parse_type(value: Any, clazz: Type, path: str, check: bool):
     try:
@@ -50,14 +65,16 @@ def __parse_type(value: Any, clazz: Type, path: str, check: bool):
     except TypeError:
         pass
 
-    raise TypeConfigException(f"expected type {clazz} at {path}, got {type(value)}")
+    raise TypeConfigException(
+        f"expected type {clazz} at {path_to_str(path)}, got {type(value)}"
+    )
 
 
 def is_union(origin):
     return origin is Union or (PY310up and origin is UnionType)
 
 
-def is_optional(type: Type):
+def is_optional(type: Type | Any | str):
     # Optional = Union[T, NoneType]
     return is_union(get_origin(type)) and NoneType in get_args(type)
 
@@ -66,7 +83,7 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
     if is_dataclass(clazz):
         if not isinstance(value, ConfigTree):
             raise TypeConfigException(
-                f"expected type {clazz} at {path}, got {type(value)}"
+                f"expected type {clazz} at {path_to_str(path)}, got {type(value)}"
             )
 
         fs = {}
@@ -96,15 +113,34 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
                 # Optional not found
                 fs[f.name] = None
 
+            elif is_dataclass(f.type):
+                if all(
+                    not isinstance(field.default, _MISSING_TYPE)
+                    or not isinstance(field.default_factory, _MISSING_TYPE)
+                    or is_optional(field.type)
+                    for field in fields(f.type)
+                ):
+                    fs[f.name] = f.type(
+                        **{
+                            field.name: None
+                            for field in fields(f.type)
+                            if is_optional(field.type)
+                        }
+                    )
+                else:
+                    raise MalformedConfigException(
+                        f'expected type {clazz} at {path_to_str(path)}, no field "{f.name}" found and {f.type} cannot be implicitly created'
+                    )
+
             else:
                 raise MalformedConfigException(
-                    f"expected type {clazz} at {path}, no {f.name} found in dataclass"
+                    f'expected type {clazz} at {path_to_str(path)}, no field "{f.name}" found'
                 )
 
         unexpected_keys = value.keys() - {renamings.get(k, k) for k in fs.keys()}
         if len(unexpected_keys) > 0 and not ignore_unexpected:
             raise UnexpectedKeysException(
-                f'unexpected key(s) "{", ".join(unexpected_keys)}" detected for type {clazz} at {path}'
+                f'unexpected key(s) "{", ".join(unexpected_keys)}" detected for type {clazz} at {path_to_str(path)}'
             )
 
         return clazz(**fs)
@@ -114,7 +150,9 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
 
     if origin is list:
         if value is None:
-            raise MalformedConfigException(f"expected list at {path} but received None")
+            raise MalformedConfigException(
+                f"expected list at {path_to_str(path)} but received None"
+            )
 
         if len(args) != 1:
             raise MissingTypeException("expected list with type information: List[?]")
@@ -128,7 +166,7 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
     if origin is tuple:
         if value is None:
             raise MalformedConfigException(
-                f"expected tuple at {path} but received None"
+                f"expected tuple at {path_to_str(path)} but received None"
             )
 
         if len(args) < 1:
@@ -181,18 +219,18 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
             return None
 
         raise TypeConfigException(
-            f"expected one of {', '.join(map(str, args))} at {path}, got {type(value)}"
+            f"expected one of {', '.join(map(str, args))} at {path_to_str(path)}, got {type(value)}"
         )
 
     if clazz is bool:
-        if not strict and value is not None:
-            try:
-                value = bool(value)
-            except ValueError:
-                pass
-        return __parse_type(value, clazz, path, isinstance(value, bool))
+        parsed = __parse_bool(value)
+        if parsed is not None:
+            return parsed
+        return __parse_type(value, clazz, path, False)
 
     if clazz is int:
+        if isinstance(value, bool):
+            return __parse_type(value, clazz, path, False)
         if not strict and value is not None:
             try:
                 value = int(value)
@@ -201,6 +239,8 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
         return __parse_type(value, clazz, path, isinstance(value, int))
 
     if clazz is float:
+        if isinstance(value, bool):
+            return __parse_type(value, clazz, path, False)
         if not strict and value is not None:
             try:
                 value = float(value)
@@ -220,13 +260,15 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
         return value
 
     if isclass(clazz) and (issubclass(clazz, Enum) or issubclass(clazz, IntEnum)):
-        if isinstance(value, int):
+        if isinstance(value, int) and not isinstance(value, bool):
             return clazz.__call__(value)
         elif issubclass(clazz, str):
             return clazz(value)
         elif isinstance(value, str):
             return clazz.__getitem__(value)
-        raise TypeConfigException(f"expected str or int at {path}, got {type(value)}")
+        raise TypeConfigException(
+            f"expected str or int at {path_to_str(path)}, got {type(value)}"
+        )
 
     if isclass(clazz) and issubclass(clazz, Path):
         return clazz.__call__(value)
@@ -235,7 +277,7 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
         if value in args:
             return value
         raise TypeConfigException(
-            f"expected one of {', '.join(map(str, args))} at {path}, got {value}"
+            f"expected one of {', '.join(map(str, args))} at {path_to_str(path)}, got {value}"
         )
 
     if clazz is datetime:
@@ -244,7 +286,7 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
             return isoparse(dt)
         except ValueError as e:
             raise ParseException(
-                f"expected type {clazz} at {path}, cannot parse due to {e}"
+                f"expected type {clazz} at {path_to_str(path)}, cannot parse due to {e}"
             )
 
     if clazz is timedelta:
@@ -258,7 +300,7 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
             return duration
         except ValueError as e:
             raise ParseException(
-                f"expected type {clazz} at {path}, cannot parse due to {e}"
+                f"expected type {clazz} at {path_to_str(path)}, cannot parse due to {e}"
             )
 
     if clazz is relativedelta:
@@ -292,17 +334,19 @@ def __parse(value: any, clazz: Type, path: str, strict: bool, ignore_unexpected:
     elif len(child_successes) > 1:
         matching_classes = "\n- ".join(map(lambda x: x[0].__name__, child_successes))
         raise AmbiguousSubclassException(
-            f"""multiple subtypes of {clazz} matched at {path}, use '_type' to disambiguate:\n- {matching_classes}"""
+            f"""multiple subtypes of {clazz} matched at {path_to_str(path)}, use '_type' to disambiguate:\n- {matching_classes}"""
         )
 
     # no need to check length; false if empty
     if child_failures:
         failures = "\n- ".join([str(c) for c in child_failures])
         raise TypeConfigException(
-            f"expected type {clazz} at {path}, failed subclasses:\n- {failures}"
+            f"expected type {clazz} at {path_to_str(path)}, failed subclasses:\n- {failures}"
         )
 
-    raise TypeConfigException(f"expected type {clazz} at {path}, got {type(value)}")
+    raise TypeConfigException(
+        f"expected type {clazz} at {path_to_str(path)}, got {type(value)}"
+    )
 
 
 def __generate(value: object, path: str):
@@ -399,6 +443,10 @@ def __env_vars_parse(prefix: str, obj: Dict[str, Any]):
     return ret
 
 
+def path_to_str(path: str) -> str:
+    return path if len(path) > 0 else "root"
+
+
 def __cli_parse(argv: List[str]):
     kvs = {}
     i = 0

{dataconf-3.5.0 → dataconf-3.7.0}/dataconf/version.py

@@ -1,6 +1,6 @@
 import sys
 
-__version__ = "3.5.0"
+__version__ = "3.7.0"
 
 PY310up = sys.version_info >= (3, 10)
 PY311up = sys.version_info >= (3, 11)

{dataconf-3.5.0 → dataconf-3.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataconf"
-version = "3.5.0"
+version = "3.7.0"
 description = "Simple dataclasses configuration management for Python with hocon/json/yaml/properties/env-vars/dict support."
 authors = []
 license = "MPL-2.0"
@@ -35,20 +35,20 @@ dataconf = 'dataconf.cli:run'
 python = "^3.9"
 python-dateutil = "^2.9.0.post0"
 PyYAML = "^6.0.2"
-isodate = ">=0.6.1,<0.8.0"
+isodate = "^0.7.2"
 pyhocon = "^0.3.61"
-pyparsing = "^3.2.1"
+pyparsing = "^3.2.3"
 
 [tool.poetry.group.dev.dependencies]
-pytest = ">=8.3.5"
+pytest = ">=8.4.1"
 pre-commit = ">=4.2.0"
-commitizen = ">=4.4.1"
-pytest-httpserver = "^1.1.2"
-ruff = ">=0.11.2"
+commitizen = ">=4.8.3"
+pytest-httpserver = "^1.1.3"
+ruff = ">=0.12.7"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "3.5.0"
+version = "3.7.0"
 tag_format = "v$major.$minor.$patch$prerelease"
 version_files = [
     "pyproject.toml:version",