wizlib 3.3.5__tar.gz → 3.3.6__tar.gz

{wizlib-3.3.5 → wizlib-3.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wizlib
-Version: 3.3.5
+Version: 3.3.6
 Summary: Framework for flexible and powerful command-line applications
 License: MIT
 Author: Steampunk Wizard

{wizlib-3.3.5 → wizlib-3.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wizlib"
-version = "3.3.5"
+version = "3.3.6"
 description = "Framework for flexible and powerful command-line applications"
 authors = ["Steampunk Wizard <wizlib@steampunkwizard.ca>"]
 license = "MIT"

{wizlib-3.3.5 → wizlib-3.3.6}/wizlib/config_handler.py

@@ -1,4 +1,5 @@
 from argparse import Namespace
+from functools import cached_property
 from pathlib import Path
 import os
 from dataclasses import dataclass
@@ -7,10 +8,9 @@ import shlex
 import subprocess
 from unittest.mock import patch
 
-from yaml import load
-from yaml import Loader
-from wizlib.handler import Handler
+import yaml
 
+from wizlib.handler import Handler
 from wizlib.error import ConfigHandlerError
 from wizlib.parser import WizParser
 
@@ -27,20 +27,32 @@ class ConfigHandler(Handler):
 
     name = 'config'
 
-    def __init__(self, file=None, yaml=None):
+    @classmethod
+    def setup(cls, val):
+        """Allow for alternative setup, passing in an injected data value as a
+        dict, bypassing file loading, for testing. Possible long-term
+        alternative to .fake() below."""
+
+        if isinstance(val, str) or isinstance(val, Path):
+            return cls(file=val)
+        elif isinstance(val, dict) or isinstance(val, list):
+            return cls(data=val)
+
+    def __init__(self, file: str = None, data: dict = None):
+        """Initiatlize with either a yaml file path or a data block to inject
+        (for testing)"""
         self.file = file
-        self.yaml_dict = yaml
+        self.injected_data = data
         self.cache = {}
 
-    @property
-    def yaml(self):
-        if hasattr(self, '_yaml'):
-            return self._yaml
+    @cached_property
+    def data(self):
+        """Returns the full set of configuration data, typically loaded from a
+        yaml file. Is cached in code."""
 
         # If yaml_dict was provided, use it directly
-        if self.yaml_dict is not None:
-            self._yaml = self.yaml_dict
-            return self._yaml
+        if self.injected_data is not None:
+            return self.injected_data
 
         path = None
         if self.file:
@@ -56,35 +68,41 @@ class ConfigHandler(Handler):
                 path = homepath
         if path:
             with open(path) as file:
-                self._yaml = load(file, Loader=Loader)
-                return self._yaml
+                data = yaml.safe_load(file)
+                return data
 
     @staticmethod
     def env(name):
         if (envvar := name.upper().replace('-', '_')) in os.environ:
             return os.environ[envvar]
 
-    def get(self, key: str):
-        """Return the value for the requested config entry"""
+    def get(self, data_path: str):
+        """Return the value for the requested config entry. If the value is a
+        string, evaluate it for shell-type expressions using $(...) syntax. Can
+        also return a dict or array. Note that the value returned is cached
+        against the data_path, so future calls may not address nested paths.
+
+        data_path: Hyphen-separated path through the yaml/dict hierarchy."""
 
         # If we already found the value, return it
-        if key in self.cache:
-            return self.cache[key]
+        if data_path in self.cache:
+            return self.cache[data_path]
 
         # Environment variables take precedence
-        if (result := self.env(key)):
-            self.cache[key] = result
+        if (result := self.env(data_path)):
+            self.cache[data_path] = result
             return result
 
-        # Otherwise look at the YAML
-        if (yaml := self.yaml):
-            split = key.split('-')
-            while (val := split.pop(0)) and (val in yaml):
-                yaml = yaml[val] if val in yaml else None
+        # Otherwise look at the YAML or injected data
+        if (data := self.data):
+            split = data_path.split('-')
+            while (key := split.pop(0)) and (key in data):
+                data = data[key] if key in data else None
                 if not split:
-                    result = evaluate_yaml_value(yaml)
-                    self.cache[key] = result
-                    return result
+                    if isinstance(data, str):
+                        data = evaluate_string(data)
+                    self.cache[data_path] = data
+                    return data
 
     @classmethod
     def fake(cls, **vals):
@@ -95,14 +113,14 @@ class ConfigHandler(Handler):
 
 
 def os_process(match):
-    """Run a subprocess"""
+    """Run a subprocess in shell form"""
     command_string = match.group(1).strip()
     command = shlex.split(command_string)
     result = subprocess.run(command, capture_output=True)
     return result.stdout.decode().strip()
 
 
-def evaluate_yaml_value(yaml: str) -> str:
-    """When getting a value from YAML, evaluate shell commands"""
+def evaluate_string(yaml: str) -> str:
+    """Evaluate shell commands in string values"""
     text = yaml.strip()
     return re.sub(r'\$\((.*?)\)', os_process, text)