appsettings2 2.0.7__tar.gz → 2.0.9__tar.gz

{appsettings2-2.0.7/src/appsettings2.egg-info → appsettings2-2.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appsettings2
-Version: 2.0.7
+Version: 2.0.9
 Summary: Unifies configuration sources into a Configuration object that can be bound to complex types, or accessed directly for configuration data.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License

{appsettings2-2.0.7 → appsettings2-2.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "appsettings2"
-version = "2.0.7"
+version = "2.0.9"
 description = "Unifies configuration sources into a Configuration object that can be bound to complex types, or accessed directly for configuration data."
 keywords = ["appsettings", "configuration"]
 authors = [

{appsettings2-2.0.7 → appsettings2-2.0.9}/src/appsettings2/Configuration.py

@@ -86,6 +86,8 @@ class Configuration:
     def __deunionize(self, t: type) -> type:
         if get_origin(t) is Union:
             t = [e for e in get_args(t) if e is not NoneType][0]
+        elif get_origin(t) is types.UnionType:
+            t = [e for e in get_args(t) if e is not NoneType][0]
         return t
 
     def __recursive_bind(self, target: object, source: Configuration | dict[str, Any]) -> Any:
@@ -97,6 +99,14 @@ class Configuration:
             )
         else:
             target_type_hints = get_type_hints(target)
+
+        # build scrubbed/normalized key lookup (for matching)
+        norm_source: bool | None = None
+        key_scrub_re_cfg: re.Pattern[str] | None = None
+        if isinstance(source, Configuration):
+            norm_source = source._Configuration__normalize
+            key_scrub_re_cfg = source._Configuration__key_scrub_re
+
         names = set(dir(target) | target_type_hints.keys())
         for aname in names:
             if aname.startswith('_'):
@@ -107,6 +117,20 @@ class Configuration:
                 continue
             ahint = target_type_hints.get(aname)
             rval = source.get(aname)
+            # scrub/normalize-aware; look up using transformed keys
+            if rval is None and norm_source is not None:
+                raw_src_key = aname.replace(':', '__')
+                for cfg_key in source.keys():  # type: ignore[union-attr]
+                    raw = cfg_key.replace('.', '_')
+                    candidate = raw.upper() if norm_source else raw
+                    scrubbed = candidate if key_scrub_re_cfg is None \
+                        else key_scrub_re_cfg.sub(
+                            lambda m: '_' if unicodedata.category(m[0]) not in ('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl', 'Mn', 'Mc', 'Nd', 'Pc') else m[0],
+                            candidate)
+                    compare = scrubbed.replace('-', '_')
+                    if compare == raw_src_key or compare.upper() == raw_src_key.upper():
+                        rval = source.get(cfg_key)  # type: ignore[union-attr]
+                        break
             if ahint is None:
                 # attr has no type hints, attempt to treat as a property
                 prop = getattr(type(target), aname)
@@ -156,7 +180,37 @@ class Configuration:
                                 lval[dk] = self.__recursive_bind_type(value_type, dv)
                             setattr(target, aname, lval)
                         continue
+                # Union/Optional types when rval missing but there's source data?
+                if get_origin(ahint) is Union or get_origin(ahint) is types.UnionType \
+                        or (isinstance(ahint, type) and hasattr(ahint, '__origin__')):
+                    unwrapped = self.__deunionize(ahint)
+                    if unwrapped not in (str, int, float, bool, NoneType):
+                        # source key overlaps with attr names?
+                        src_key_overlap = False
+                        for cfg_key in source.keys():  # type: ignore[union-attr]
+                            raw_src_key = cfg_key.replace('.', '_')
+                            candidate = raw_src_key.upper() if norm_source else raw_src_key
+                            scrubbed = candidate if key_scrub_re_cfg is None \
+                                else key_scrub_re_cfg.sub(
+                                    lambda m: '_' if unicodedata.category(m[0]) not in ('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl', 'Mn', 'Mc', 'Nd', 'Pc') else m[0],
+                                    candidate)
+                            compare = scrubbed.replace('-', '_').replace('_', '')
+                            for other_attr in names:
+                                if not other_attr.startswith('_'):
+                                    okey = other_attr.replace(':', '__')
+                                    if compare == okey or compare.upper() == okey.upper():
+                                        src_key_overlap = True
+                                        break
+                            if src_key_overlap:
+                                break
+                        if isinstance(source, Configuration) and source.keys() and not src_key_overlap:  # type: ignore[union-attr]
+                            lval = unwrapped()
+                            setattr(target, aname, lval)
+                            self.__recursive_bind(lval, source)
+                            continue
                 setattr(target, aname, None)
+            elif ahint is bool:
+                setattr(target, aname, bool(rval))
             elif ahint is float:
                 setattr(target, aname, float(rval))
             elif ahint is int:
@@ -174,6 +228,28 @@ class Configuration:
                         for dk, dv in rval.items():
                             lval[dk] = self.__recursive_bind_type(value_type, dv)
                         setattr(target, aname, lval)
+                elif (
+                    get_origin(ahint) is Union
+                    or get_origin(ahint) is types.UnionType
+                    or (isinstance(ahint, type) and hasattr(ahint, '__origin__'))
+                ):
+                    # Handle Optional/Union types — unwrap before instantiating
+                    unwrapped = self.__deunionize(ahint)
+                    if get_origin(unwrapped) is dict:
+                        value_type = get_args(unwrapped)[1]
+                        if value_type in (str, int, float, bool, type(None)):
+                            lval = rval.to_dict()
+                            setattr(target, aname, lval)
+                        else:
+                            lval = dict[str, Any]()
+                            for dk, dv in rval.items():
+                                lval[dk] = self.__recursive_bind_type(value_type, dv)
+                            setattr(target, aname, lval)
+                    else:
+                        if lval is None:
+                            lval = unwrapped()
+                            setattr(target, aname, lval)
+                        self.__recursive_bind(lval, rval)
                 else:
                     if lval is None:
                         ahint = self.__deunionize(ahint)
@@ -262,12 +338,66 @@ class Configuration:
             source = self.get(key)
             if source is not None:
                 source_type = type(source)
-                if source_type is Configuration or source_type is dict:
+                if source_type in (Configuration, dict):
                     return self.__recursive_bind(target, source)
+                elif source_type is list:
+                    return self.__bind_list_source(target, key, source)
                 else:
-                    raise ConfigurationException(
-                        f'Bind of source type `{type(source)}` is not supported.')
+                    # Scalar source: convert to matching typed attribute(s) on target
+                    return self.__bind_scalar_to_target(target, key, source)
+            else:
+                return target
+
+    def __bind_list_source(self, target: object, key: str, source: list[Any]) -> Any:
+        """Bind a Configuration- or dict-wrapped list source to *target*."""
+        if not hasattr(target, '__class__'):
             return target
+        hints = get_type_hints(type(target))
+        raw_key = self.__scrub_key(key.replace(':', '__'))
+        for attr_name, ahint in hints.items():
+            if raw_key == self.__scrub_key(attr_name) or key.upper() == attr_name.upper():
+                element_type = ahint.__args__[0] if get_origin(ahint) is list else None
+                if element_type is not None and source:
+                    lval = []
+                    for e in source:
+                        lval.append(self.__recursive_bind_type(element_type, e))
+                    setattr(target, attr_name, lval)
+                    return target
+        # taking object/untyped attr from normalized
+        for attr_name, ahint in hints.items():
+            if raw_key == self.__scrub_key(attr_name) or key.upper() == attr_name.upper():
+                if ahint is object:
+                    setattr(target, attr_name, source)
+                    return target
+        return target
+
+    def __bind_scalar_to_target(self, target: object, key: str, value: Any) -> Any:
+        """Bind a scalar config value to the typed attribute on *target* matching the key."""
+        if not hasattr(target, '__class__'):
+            return target
+        hints = get_type_hints(type(target))
+        # Normalize / scrub exactly as :py:meth:`set` does so we can match back.
+        raw_key = self.__scrub_key(key.replace(':', '__'))
+        for attr_name, ahint in hints.items():
+            if raw_key == self.__scrub_key(attr_name):
+                converted = self.__convert_to_type(value, ahint)
+                setattr(target, attr_name, converted)
+        return target
+
+    @staticmethod
+    def __convert_to_type(value: Any, target_type: type) -> Any:
+        """Convert *value* to *target_type* using primitive coercion rules."""
+        if target_type is float:
+            return float(value)
+        elif target_type is int:
+            return int(value)
+        elif target_type is str:
+            return str(value)
+        elif target_type is bool:
+            return bool(value)
+        else:
+            # Complex type or Any — nothing we can do for a scalar source
+            return value
 
     def clear(self) -> None:
         """Clear all configuration data."""

{appsettings2-2.0.7 → appsettings2-2.0.9}/src/appsettings2/__init__.py

@@ -10,8 +10,8 @@ from . import helpers
 from . import providers
 
 
-__version__ = '2.0.7'
-__commit__ = '62b357b'
+__version__ = '2.0.9'
+__commit__ = 'b510516'
 __all__ = [
     '__version__', '__commit__',
     'Configuration',

{appsettings2-2.0.7 → appsettings2-2.0.9/src/appsettings2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appsettings2
-Version: 2.0.7
+Version: 2.0.9
 Summary: Unifies configuration sources into a Configuration object that can be bound to complex types, or accessed directly for configuration data.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License