Config model options handling. Closes #185

src/cpl-core/cpl/core/configuration/configuration.py

@@ -8,7 +8,6 @@ from cpl.core.configuration.configuration_model_abc import ConfigurationModelABC
 from cpl.core.console.console import Console
 from cpl.core.console.foreground_color_enum import ForegroundColorEnum
 from cpl.core.typing import D, T
-from cpl.core.utils.json_processor import JSONProcessor
 
 
 class Configuration:
@@ -116,9 +115,7 @@ class Configuration:
                 if sub.__name__ != key and sub.__name__.replace("Settings", "") != key:
                     continue
 
-                configuration = JSONProcessor.process(sub, value)
-
-                cls.set(sub, configuration)
+                cls.set(sub, sub(value))
 
     @classmethod
     def set(cls, key: Any, value: T):

src/cpl-core/cpl/core/configuration/configuration_model_abc.py

@@ -1,7 +1,81 @@
-from abc import ABC
+from abc import ABC, abstractmethod
+from typing import Optional, Type, Any
+
+from cpl.core.typing import T
+from cpl.core.utils.cast import cast
+from cpl.core.utils.get_value import get_value
+from cpl.core.utils.string import String
 
 
 class ConfigurationModelABC(ABC):
     r"""
     ABC for configuration model classes
     """
+
+    @abstractmethod
+    def __init__(
+        self,
+        src: Optional[dict] = None,
+        env_prefix: Optional[str] = None,
+        readonly: bool = True,
+    ):
+        ABC.__init__(self)
+
+        self._src = src or {}
+        self._options: dict[str, Any] = {}
+
+        self._env_prefix = env_prefix
+        self._readonly = readonly
+
+    def __setattr__(self, attr: str, value: Any):
+        if hasattr(self, "_readonly") and self._readonly:
+            raise AttributeError(f"Cannot set attribute: {attr}. {type(self).__name__} is read-only")
+
+        super().__setattr__(attr, value)
+
+    def __getattr__(self, attr: str) -> Any:
+        options = super().__getattribute__("_options")
+        if attr in options:
+            return options[attr]
+
+        return super().__getattribute__(attr)
+
+    def option(self, field: str, cast_type: Type[T], default=None, required=False, from_env=True):
+        value = None
+
+        field_variants = [
+            field,
+            String.first_to_upper(field),
+            String.first_to_lower(field),
+            String.to_camel_case(field),
+            String.to_snake_case(field),
+            String.first_to_upper(String.to_camel_case(field)),
+        ]
+
+        value = None
+        for variant in field_variants:
+            if variant in self._src:
+                value = self._src[variant]
+                break
+
+        if value is None and from_env:
+            from cpl.core.environment import Environment
+
+            env_field = field.upper()
+            if self._env_prefix:
+                env_field = f"{self._env_prefix}_{env_field}"
+            value = Environment.get(env_field, cast_type)
+
+        if value is None and required:
+            raise ValueError(f"{field} is required")
+        elif value is None:
+            self._options[field] = default
+            return
+
+        self._options[field] = cast(value, cast_type)
+
+    def get(self, field: str, default=None) -> Optional[T]:
+        return get_value(self._src, field, self._options[field].type, default)
+
+    def to_dict(self) -> dict:
+        return {field: self.get(field) for field in self._options.keys()}

src/cpl-core/cpl/core/log/logging_settings.py

@@ -5,49 +5,14 @@ from cpl.core.log.log_level_enum import LogLevel
 
 
 class LogSettings(ConfigurationModelABC):
-    r"""Representation of logging settings"""
 
     def __init__(
         self,
-        path: str = None,
-        filename: str = None,
-        console_log_level: LogLevel = None,
-        file_log_level: LogLevel = None,
+        src: Optional[dict] = None,
     ):
-        ConfigurationModelABC.__init__(self)
-        self._path: Optional[str] = path
-        self._filename: Optional[str] = filename
-        self._console: Optional[LogLevel] = console_log_level
-        self._level: Optional[LogLevel] = file_log_level
+        ConfigurationModelABC.__init__(self, src)
 
-    @property
-    def path(self) -> str:
-        return self._path
-
-    @path.setter
-    def path(self, path: str) -> None:
-        self._path = path
-
-    @property
-    def filename(self) -> str:
-        return self._filename
-
-    @filename.setter
-    def filename(self, filename: str) -> None:
-        self._filename = filename
-
-    @property
-    def console(self) -> LogLevel:
-        return self._console
-
-    @console.setter
-    def console(self, console: LogLevel) -> None:
-        self._console = console
-
-    @property
-    def level(self) -> LogLevel:
-        return self._level
-
-    @level.setter
-    def level(self, level: LogLevel) -> None:
-        self._level = level
+        self.option("path", str, default="logs")
+        self.option("filename", str, default="app.log")
+        self.option("console_level", LogLevel, default=LogLevel.info)
+        self.option("level", LogLevel, default=LogLevel.info)

src/cpl-core/cpl/core/utils/__init__.py

@@ -3,3 +3,4 @@ from .credential_manager import CredentialManager
 from .json_processor import JSONProcessor
 from .pip import Pip
 from .string import String
+from .get_value import get_value

src/cpl-core/cpl/core/utils/cast.py

@@ -0,0 +1,64 @@
+from enum import Enum
+from typing import Type, Any
+
+from cpl.core.typing import T
+
+def _cast_enum(value: str, enum_type: Type[Enum]) -> Enum:
+    try:
+        return enum_type(value)
+    except ValueError:
+        pass
+
+    try:
+        return enum_type(value.lower())
+    except ValueError:
+        pass
+
+    try:
+        return enum_type(value.upper())
+    except ValueError:
+        pass
+
+    try:
+        return enum_type[value]
+    except KeyError:
+        pass
+
+    try:
+        return enum_type[value.lower()]
+    except KeyError:
+        pass
+
+    try:
+        return enum_type[value.upper()]
+    except KeyError:
+        pass
+
+    raise ValueError(f"Cannot cast value '{value}' to enum '{enum_type.__name__}'")
+
+def cast(value: Any, cast_type: Type[T], list_delimiter: str = ",") -> T:
+    """
+    Cast a value to a specified type.
+    :param Any value: Value to be casted.
+    :param Type[T] cast_type: A callable to cast the variable's value.
+    :param str list_delimiter: The delimiter to split the value into a list. Defaults to ",".
+    :return:
+    """
+    if cast_type == bool:
+        return value.lower() in ["true", "1", "yes", "on"]
+
+    if issubclass(cast_type, Enum):
+        return _cast_enum(value, cast_type)
+
+    if (cast_type if not hasattr(cast_type, "__origin__") else cast_type.__origin__) == list:
+        if not (value.startswith("[") and value.endswith("]")) and list_delimiter not in value:
+            raise ValueError("List values must be enclosed in square brackets or use a delimiter.")
+
+        if value.startswith("[") and value.endswith("]"):
+            value = value[1:-1]
+
+        value = value.split(list_delimiter)
+        subtype = cast_type.__args__[0] if hasattr(cast_type, "__args__") else None
+        return [subtype(item) if subtype is not None else item for item in value]
+
+    return cast_type(value)

src/cpl-core/cpl/core/utils/credential_manager.py

@@ -6,8 +6,10 @@ from cpl.core.log.logger import Logger
 
 _logger = Logger(__name__)
 
+
 class CredentialManager:
     r"""Handles credential encryption and decryption"""
+
     _secret: str = None
 
     @classmethod

src/cpl-core/cpl/core/utils/get_value.py

@@ -1,7 +1,7 @@
-from enum import Enum
 from typing import Type, Optional
 
 from cpl.core.typing import T
+from cpl.core.utils.cast import cast
 
 
 def get_value(
@@ -38,33 +38,6 @@ def get_value(
         return value
 
     try:
-        if cast_type == bool:
-            return value.lower() in ["true", "1"]
-
-        if issubclass(cast_type, Enum):
-            try:
-                return cast_type(value)
-            except ValueError:
-                pass
-
-            try:
-                return cast_type[value]
-            except KeyError:
-                pass
-
-            return default
-
-        if (cast_type if not hasattr(cast_type, "__origin__") else cast_type.__origin__) == list:
-            if not (value.startswith("[") and value.endswith("]")) and list_delimiter not in value:
-                raise ValueError("List values must be enclosed in square brackets or use a delimiter.")
-
-            if value.startswith("[") and value.endswith("]"):
-                value = value[1:-1]
-
-            value = value.split(list_delimiter)
-            subtype = cast_type.__args__[0] if hasattr(cast_type, "__args__") else None
-            return [subtype(item) if subtype is not None else item for item in value]
-
-        return cast_type(value)
+        cast(cast_type, value, list_delimiter)
     except (ValueError, TypeError):
         return default

src/cpl-core/cpl/core/utils/string.py

@@ -17,7 +17,11 @@ class String:
         Returns:
             String converted to CamelCase
         """
-        return re.sub(r"(?<!^)(?=[A-Z])", "_", s).lower()
+
+        s = String.to_snake_case(s)
+        words = s.split('_')
+        return words[0] + ''.join(word.title() for word in words[1:])
+        # return re.sub(r"(?<!^)(?=[A-Z])", "_", s).lower()
 
     @staticmethod
     def to_snake_case(chars: str) -> str: