Simplified LazyPropertySetting, changed Settings initialization

Author: mikicz

arca/_arca.py

@@ -1,6 +1,5 @@
 import hashlib
 import json
-import os
 import re
 from collections import defaultdict
 from datetime import datetime
@@ -34,16 +33,16 @@ class Arca:
 
     RUNNER = Path(__file__).parent.resolve() / "_runner.py"
 
-    base_dir: str = LazySettingProperty(key="base_dir", default=".arca")
-    single_pull: bool = LazySettingProperty(key="single_pull", default=False, convert=bool)
-    ignore_cache_errors: bool = LazySettingProperty(key="ignore_cache_errors", default=False, convert=bool)
+    base_dir: str = LazySettingProperty(default=".arca")
+    single_pull: bool = LazySettingProperty(default=False, convert=bool)
+    ignore_cache_errors: bool = LazySettingProperty(default=False, convert=bool)
 
     def __init__(self, backend: BackendDefinitionType=NOT_SET,
                  settings=None,
                  single_pull=None,
                  base_dir=None,
                  ignore_cache_errors=None) -> None:
-        self.settings: Settings = self._get_settings(settings)
+        self.settings: Settings = Settings(settings)
 
         if ignore_cache_errors is not None:
             self.ignore_cache_errors = bool(ignore_cache_errors)
@@ -80,22 +79,6 @@ def get_backend_instance(self, backend: BackendDefinitionType) -> BaseBackend:
 
         return backend
 
-    def _get_settings(self, settings: Optional[Dict[str, Any]]) -> Settings:
-        """
-        Returns a initialized a :class:`arca.utils.Settings` instance,
-        from the provided dictionary and from environment variables
-        """
-        if settings is not None:
-            _settings = Settings(settings)
-        else:
-            _settings = Settings()
-
-        for key, val in os.environ.items():
-            if key.startswith(Settings.PREFIX):
-                _settings.set(key, val)
-
-        return _settings
-
     def make_region(self) -> CacheRegion:
         """
         Returns a :class:`CacheRegion <dogpile.cache.region.CacheRegion>` based on settings.

arca/backend/base.py

@@ -25,8 +25,8 @@ class BaseBackend:
     * **cwd**: Relative path to the required working directory. (default is ``""``, the root of the repo)
     """
 
-    requirements_location: str = LazySettingProperty(key="requirements_location", default="requirements.txt")
-    cwd: str = LazySettingProperty(key="cwd", default="")
+    requirements_location: str = LazySettingProperty(default="requirements.txt")
+    cwd: str = LazySettingProperty(default="")
 
     def __init__(self, **settings):
         self._arca = None
@@ -66,6 +66,8 @@ def get_setting(self, key, default=NOT_SET):
 
         :raise KeyError: If the key is not set and default isn't provided.
         """
+        if self._arca is None:
+            raise LazySettingProperty.SettingsNotReady
         return self._arca.settings.get(*self.get_settings_keys(key), default=default)
 
     def get_requirements_file(self, path: Path) -> Optional[Path]:

arca/backend/current_environment.py

@@ -40,10 +40,8 @@ class CurrentEnvironmentBackend(BaseRunInSubprocessBackend):
 
     """
 
-    current_environment_requirements = LazySettingProperty(key="current_environment_requirements",
-                                                           default="requirements.txt")
-    requirements_strategy = LazySettingProperty(key="requirements_strategy",
-                                                default=RequirementsStrategy.RAISE,
+    current_environment_requirements = LazySettingProperty(default="requirements.txt")
+    requirements_strategy = LazySettingProperty(default=RequirementsStrategy.RAISE,
                                                 convert=RequirementsStrategy)
 
     def install_requirements(self, *, path: Optional[Path] = None, requirements: Optional[Iterable[str]] = None,

arca/backend/docker.py

@@ -40,13 +40,13 @@ class DockerBackend(BaseBackend):
     * **registry_pull_only** - only use the registry to pull images, don't push updated
     """
 
-    python_version = LazySettingProperty(key="python_version", default=None)
-    keep_container_running = LazySettingProperty(key="keep_container_running", default=False)
-    apk_dependencies = LazySettingProperty(key="apk_dependencies", default=None)
-    disable_pull = LazySettingProperty(key="disable_pull", default=False)  # so the build can be tested
-    inherit_image = LazySettingProperty(key="inherit_image", default=None)
-    use_registry_name = LazySettingProperty(key="use_registry_name", default=None)
-    registry_pull_only = LazySettingProperty(key="registry_pull_only", default=False)
+    python_version = LazySettingProperty(default=None)
+    keep_container_running = LazySettingProperty(default=False)
+    apk_dependencies = LazySettingProperty(default=None)
+    disable_pull = LazySettingProperty(default=False)  # so the build can be tested
+    inherit_image = LazySettingProperty(default=None)
+    use_registry_name = LazySettingProperty(default=None)
+    registry_pull_only = LazySettingProperty(default=False)
 
     NO_REQUIREMENTS_HASH = "no_req"
     NO_DEPENDENCIES_HASH = "no_dep"

arca/backend/vagrant.py

@@ -36,10 +36,10 @@ class VagrantBackend(DockerBackend):
 
     # Box has to either not contain docker at all (will be installed in that case, takes a long time)
     # or has to contain Docker with version >= 1.8 (Versions < 1.8 can't copy files from host to container)
-    box = LazySettingProperty(key="box", default="ailispaw/barge")
-    provider = LazySettingProperty(key="provider", default="virtualbox")
-    quiet = LazySettingProperty(key="quiet", default=True, convert=bool)
-    destroy = LazySettingProperty(key="destroy", default=True, convert=bool)
+    box = LazySettingProperty(default="ailispaw/barge")
+    provider = LazySettingProperty(default="virtualbox")
+    quiet = LazySettingProperty(default=True, convert=bool)
+    destroy = LazySettingProperty(default=True, convert=bool)
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)

arca/utils.py

@@ -1,5 +1,6 @@
 import importlib
 import logging
+import os
 from pathlib import Path
 from typing import Any, Dict, Optional, Callable, Union
 
@@ -50,18 +51,24 @@ class LazySettingProperty:
     The property is evaluated lazily when accessed, getting the value from settings
     using the instances method ``get_setting``. The property can be overridden by the constructor.
     """
-    def __init__(self, *, key, default=NOT_SET, convert: Callable=None) -> None:
+    class SettingsNotReady(Exception):
+        pass
+
+    def __init__(self, *, key=None, default=NOT_SET, convert: Callable=None) -> None:
         self.key = key
         self.default = default
         self.convert = convert
 
     def __set_name__(self, cls, name):
         self.name = name
+        if self.key is None:
+            self.key = name
 
     def __get__(self, instance, cls):
-        if instance is None or (hasattr(instance, "_arca") and instance._arca is None):
+        try:
+            result = instance.get_setting(self.key, self.default)
+        except self.SettingsNotReady:
             return self
-        result = instance.get_setting(self.key, self.default)
 
         if self.convert is not None:
             result = self.convert(result)
@@ -77,7 +84,11 @@ class Settings:
     PREFIX = "ARCA"
 
     def __init__(self, data: Optional[Dict[str, Any]]=None) -> None:
-        self._data = data or {}
+        self._data = dict(data) if data else {}
+
+        for key, val in os.environ.items():
+            if key.startswith(Settings.PREFIX):
+                self.set(key, val)
 
     def set(self, key, value):
         self._data[key] = value