envstack 0.8.2__tar.gz → 0.8.4__tar.gz

{envstack-0.8.2/lib/envstack.egg-info → envstack-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.8.2
+Version: 0.8.4
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -169,8 +169,8 @@ allows you to override the value:
 | Value | Description |
 |---------------------|-------------|
 | value |  'value' |
-| ${VAR:-default} | os.environ.get('VAR', 'default') |
 | ${VAR:=default} | VAR = VAR or 'default' |
+| ${VAR:-default} | os.environ.get('VAR', 'default') |
 | ${VAR:?error message} | if not VAR: raise ValueError() |
 
 Without the expansion modifier, values are set and do not change (but can be
@@ -208,6 +208,37 @@ $ HELLO=goodbye envstack -- echo {HELLO}
 goodbye
 ```
 
+#### Using the command-line
+
+Here we can set values using the `envstack` command:
+
+```bash
+$ envstack --set HELLO:world
+HELLO: world
+```
+
+We can also encrypt the values automatically (base64 by default):
+
+```bash
+$ envstack -s HELLO:world -e
+HELLO: d29ybGQ=
+```
+
+Add more variables (note that `$` needs to be escaped in bash or else it will
+be evaluated immediately):
+
+```bash
+$ envstack -s HELLO:world VAR:\${HELLO}
+HELLO: world
+VAR: ${HELLO}
+```
+
+To write out to a file use the `-o` option:
+
+```bash
+$ envstack -s HELLO:world -o hello.env
+```
+
 ## Creating Stacks
 
 Several example or starter stacks are available in the [env folder of the
@@ -235,6 +266,13 @@ windows:
   <<: *all
 ```
 
+Or using Python:
+
+```python
+>>> env = Env({"FOO": "bar", "BAR": "${FOO}"})
+>>> env.write("foobar.env")
+```
+
 Get the resolved environment for the `foobar` stack:
 
 ```bash
@@ -277,6 +315,19 @@ BIZ=foo
 FOO=foo
 ```
 
+Here is an example using nested variable expansion:
+
+```yaml
+FOO: ${BIZ:=${BAR:=${BAZ:=baz}}}
+```
+
+Resolves to:
+
+```bash
+$ envstack -r
+FOO=baz
+```
+
 #### Includes
 
 Environment stack files can include other namespaced environments (you should

{envstack-0.8.2 → envstack-0.8.4}/README.md

@@ -145,8 +145,8 @@ allows you to override the value:
 | Value | Description |
 |---------------------|-------------|
 | value |  'value' |
-| ${VAR:-default} | os.environ.get('VAR', 'default') |
 | ${VAR:=default} | VAR = VAR or 'default' |
+| ${VAR:-default} | os.environ.get('VAR', 'default') |
 | ${VAR:?error message} | if not VAR: raise ValueError() |
 
 Without the expansion modifier, values are set and do not change (but can be
@@ -184,6 +184,37 @@ $ HELLO=goodbye envstack -- echo {HELLO}
 goodbye
 ```
 
+#### Using the command-line
+
+Here we can set values using the `envstack` command:
+
+```bash
+$ envstack --set HELLO:world
+HELLO: world
+```
+
+We can also encrypt the values automatically (base64 by default):
+
+```bash
+$ envstack -s HELLO:world -e
+HELLO: d29ybGQ=
+```
+
+Add more variables (note that `$` needs to be escaped in bash or else it will
+be evaluated immediately):
+
+```bash
+$ envstack -s HELLO:world VAR:\${HELLO}
+HELLO: world
+VAR: ${HELLO}
+```
+
+To write out to a file use the `-o` option:
+
+```bash
+$ envstack -s HELLO:world -o hello.env
+```
+
 ## Creating Stacks
 
 Several example or starter stacks are available in the [env folder of the
@@ -211,6 +242,13 @@ windows:
   <<: *all
 ```
 
+Or using Python:
+
+```python
+>>> env = Env({"FOO": "bar", "BAR": "${FOO}"})
+>>> env.write("foobar.env")
+```
+
 Get the resolved environment for the `foobar` stack:
 
 ```bash
@@ -253,6 +291,19 @@ BIZ=foo
 FOO=foo
 ```
 
+Here is an example using nested variable expansion:
+
+```yaml
+FOO: ${BIZ:=${BAR:=${BAZ:=baz}}}
+```
+
+Resolves to:
+
+```bash
+$ envstack -r
+FOO=baz
+```
+
 #### Includes
 
 Environment stack files can include other namespaced environments (you should

{envstack-0.8.2 → envstack-0.8.4}/lib/envstack/__init__.py

@@ -34,6 +34,6 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "0.8.2"
+__version__ = "0.8.4"
 
 from envstack.env import clear, init, revert, save  # noqa: F401

{envstack-0.8.2 → envstack-0.8.4}/lib/envstack/cli.py

@@ -40,7 +40,9 @@ import traceback
 from envstack import __version__, config
 from envstack.env import (
     bake_environ,
-    clear,
+    Env,
+    encrypt_environ,
+    export_env_to_shell,
     export,
     load_environ,
     resolve_environ,
@@ -83,12 +85,25 @@ def parse_args():
         default=[config.DEFAULT_NAMESPACE],
         help="the environment stacks to use (default '%s')" % config.DEFAULT_NAMESPACE,
     )
+    encrypt_group = parser.add_argument_group("encryption options")
+    encrypt_group.add_argument(
+        "-e",
+        "--encrypt",
+        action="store_true",
+        help="encrypt environment values",
+    )
+    encrypt_group.add_argument(
+        "--keygen",
+        action="store_true",
+        help="generate encryption keys",
+    )
+    parser.add_argument_group(encrypt_group)
     bake_group = parser.add_argument_group("bake options")
     bake_group.add_argument(
         "-o",
         "--out",
         metavar="FILENAME",
-        help="write the env stack to a new stack file",
+        help="save the environment to an env file",
     )
     bake_group.add_argument(
         "--depth",
@@ -96,27 +111,19 @@ def parse_args():
         default=0,
         help="depth of environment stack to bake",
     )
-    bake_group.add_argument(
-        "--keygen",
-        action="store_true",
-        help="generate encryption keys",
-    )
-    bake_group.add_argument(
-        "--encrypt",
-        action="store_true",
-        help="encrypt the baked environment values",
-    )
     parser.add_argument_group(bake_group)
-    parser.add_argument(
+    export_group = parser.add_argument_group("export options")
+    export_group.add_argument(
         "--clear",
         action="store_true",
         help="generate unset commands for %s" % config.SHELL,
     )
-    parser.add_argument(
+    export_group.add_argument(
         "--export",
         action="store_true",
         help="generate export commands for %s" % config.SHELL,
     )
+    parser.add_argument_group(export_group)
     parser.add_argument(
         "-p",
         "--platform",
@@ -124,6 +131,13 @@ def parse_args():
         metavar="PLATFORM",
         help="platform to resolve variables for (linux, darwin, windows)",
     )
+    parser.add_argument(
+        "-s",
+        "--set",
+        nargs="*",
+        metavar="VAR:VALUE",
+        help="set a key:value pair in the environment",
+    )
     parser.add_argument(
         "--scope",
         metavar="SCOPE",
@@ -179,19 +193,28 @@ def main():
         elif args.keygen:
             from envstack.encrypt import generate_keys
 
-            keys = generate_keys()
+            data = generate_keys()
 
             if args.export:
-                from envstack.env import export_env_to_shell
-
-                print(export_env_to_shell(keys))
+                print(export_env_to_shell(data))
             elif args.out:
-                from envstack.util import dump_yaml
+                Env(data).write(args.out)
+            else:
+                for key, value in data.items():
+                    print(f"{key}={value}")
+
+        elif args.set:
+            data = dict(kv.split(":", 1) for kv in args.set)
 
-                dump_yaml(file_path=args.out, data=keys)
+            if args.encrypt:
+                data = encrypt_environ(data, encrypt=(not args.out))
+            if args.export:
+                print(export_env_to_shell(data))
+            elif args.out:
+                Env(data).write(args.out)
             else:
-                for key, value in keys.items():
-                    print(f"{key}: {value}")
+                for key, value in data.items():
+                    print(f"{key}={value}")
 
         elif args.out:
             bake_environ(
@@ -223,6 +246,8 @@ def main():
                 print(source.path)
 
         elif args.clear:
+            from envstack.env import clear
+
             print(clear(args.namespace, config.SHELL))
 
         elif args.export:

{envstack-0.8.2 → envstack-0.8.4}/lib/envstack/env.py

@@ -89,7 +89,7 @@ class Source(object):
         return hash(self.__repr__())
 
     def __repr__(self):
-        return f'<Source "{self.path}">'
+        return f"<Source '{self.path}'>"
 
     def __str__(self):
         return str(self.path)
@@ -294,6 +294,88 @@ class Env(dict):
         """
         self.scope = path
 
+    def bake(self, filename: str = None, depth: int = 0, encrypt: bool = False):
+        """Bakes an environment with multiple sources into a single environment
+        and writes to a new env file.
+
+            >>> env = load_environ(stack_name)
+            >>> env.bake("baked.env")
+
+        :param filename: path to save the baked environment.
+        :param depth: depth of source files to incldue (default: all).
+        :param encrypt: encrypt the values.
+        :returns: baked environment.
+        """
+        # get the sources for the given environment
+        sources = self.sources
+
+        # look for encryption keys in the environment
+        os.environ.update(get_keys_from_env(self))
+
+        # create a baked source
+        baked = Source(filename)
+
+        def get_node_class(value):
+            """Returns the node class to use for a given value."""
+            if encrypt:
+                if type(value) in custom_node_types:
+                    return value.__class__
+                else:
+                    return EncryptedNode
+            return value.__class__
+
+        # merge the sources into the outfile
+        for source in sources[-depth:]:
+            for key, value in source.data.items():
+                if isinstance(value, dict):
+                    for k, v in value.items():
+                        node_class = get_node_class(v)
+                        baked.data.setdefault(key, {})[k] = node_class(v)
+                else:
+                    node_class = get_node_class(value)
+                    baked.data[key] = node_class(value)
+
+        # clear includes if environment stack is fully baked
+        if depth <= 0:
+            baked.data["include"] = []
+
+        # write the baked environment to the file
+        if filename:
+            baked.write()
+
+        # create the baked environment from the baked source
+        baked_env = Env()
+        baked_env.load_source(baked)
+
+        return baked_env
+
+    def write(self, filename: str = None):
+        """Writes the environment to an env file.
+
+            >>> env = Env({"FOO": "${BAR}", "BAR": "bar"})
+            >>> env.write("foo.env")
+
+        To encrypt values, use EncryptedNode:
+
+            >>> env = Env({"FOO": "${BAR}", "BAR": EncryptedNode("bar")})
+            >>> env.write("encrypted.env")
+
+        :param filename: path to save the baked environment.
+        :returns: Source object.
+        """
+        # the environment was loaded from one or more sources
+        if self.sources:
+            baked = self.bake(filename)
+            return baked.sources[0]
+
+        # the environment was created from scratch
+        else:
+            source = Source(filename)
+            for k, v in self.items():
+                source.data[k] = v
+            source.write()
+            return source
+
 
 def clear_file_cache():
     """Clears global file cache."""
@@ -664,55 +746,21 @@ def bake_environ(
     :param encrypt: encrypt the values.
     :returns: baked environment.
     """
-    # load the envrinment for the given stack and get list of sources
-    env = load_environ(name, scope=scope)
-    sources = env.sources
-
-    # resolve internal environment so that encryption keys are found
-    # (encryptors looks in os.environ by default)
-    os.environ.update(util.encode(resolve_environ(env)))
+    return load_environ(name, scope=scope).bake(filename, depth, encrypt)
 
-    # create a baked source
-    baked = Source(filename)
 
-    def get_node_class(value):
-        """Returns the node class to use for a given value."""
-        if encrypt:
-            if type(value) in custom_node_types:
-                return value.__class__
-            else:
-                return EncryptedNode
-        return value.__class__
-
-    # merge the sources into the outfile
-    for source in sources[-depth:]:
-        for key, value in source.data.items():
-            if isinstance(value, dict):
-                for k, v in value.items():
-                    node_class = get_node_class(v)
-                    baked.data.setdefault(key, {})[k] = node_class(v)
-            else:
-                node_class = get_node_class(value)
-                baked.data[key] = node_class(value)
-
-    # clear includes if environment stack is fully baked
-    if depth <= 0:
-        baked.data["include"] = []
-
-    # write the baked environment to the file
-    if filename:
-        baked.write()
-
-    # create the baked environment
-    baked_env = Env()
-    baked_env.update(baked.load())
+def encrypt_environ(
+    env: dict, node_class: BaseNode = EncryptedNode, encrypt: bool = True
+):
+    """Encrypts all values in a given environment, returning a new environment.
+    Looks for encryption keys in the environment.
 
-    return baked_env
+    Python:
 
+        >>> env = {"FOO": "bar"}
+        >>> env = envstack.encrypt_environ(env)
 
-def encrypt_environ(env: dict, node_class: BaseNode = EncryptedNode):
-    """Encrypts all values in a given environment, returning a new environment.
-    Looks for encryption keys in the environment.
+    Command line:
 
         $ envstack [STACK] --encrypt
 
@@ -720,6 +768,7 @@ def encrypt_environ(env: dict, node_class: BaseNode = EncryptedNode):
     :param node_class: node class to use for encryption.
         Defaults to EncryptedNode, which looks for encryption keys in the
         environment to determine the encryption method.
+    :param encrypt: pre-encrypt the values.
     :returns: encrypted environment.
     """
     # stores the encrypted environment
@@ -736,7 +785,8 @@ def encrypt_environ(env: dict, node_class: BaseNode = EncryptedNode):
         if type(v) not in custom_node_types:
             # TODO: use to_yaml() method to serialize instead?
             node = node_class(v)
-            node.value = node.encryptor(env=resolved_env).encrypt(str(v))
+            if encrypt:
+                node.value = node.encryptor(env=resolved_env).encrypt(str(v))
             encrypted_env[k] = node
         else:
             encrypted_env[k] = v

{envstack-0.8.2 → envstack-0.8.4}/lib/envstack/util.py

@@ -49,14 +49,14 @@ from envstack.node import AESGCMNode, Base64Node, EncryptedNode, FernetNode
 # value for unresolvable variables
 null = ""
 
+# regular expression pattern for matching windows drive letters
+drive_letter_pattern = re.compile(r"(?P<sep>[:;])?(?P<drive>[A-Z]:[/\\])")
+
 # regular expression pattern for bash-like variable expansion
 variable_pattern = re.compile(
-    r"\$\{([a-zA-Z_][a-zA-Z0-9_]*)(?::([=?])(\$\{[^}]*\}[\-\w/]*|[^}]*))?\}"
+    r"\$\{([a-zA-Z_][a-zA-Z0-9_]*)(?::([-=?])((?:\$\{[^}]+\}|[^}])*))?\}"
 )
 
-# regular expression pattern for matching windows drive letters
-drive_letter_pattern = re.compile(r"(?P<sep>[:;])?(?P<drive>[A-Z]:[/\\])")
-
 
 def clear_sys_path(var: str = "PYTHONPATH"):
     """
@@ -72,9 +72,9 @@ def clear_sys_path(var: str = "PYTHONPATH"):
 def decode_value(value: str):
     """Returns a decoded value that's been encoded by a wrapper.
 
-    Decoding encoded environments can be tricky. For example, it must account for path
-    templates that include curly braces, e.g. path templates string like this must be
-    preserved:
+    Decoding encoded environments can be tricky. For example, it must account
+    for path templates that include curly braces, e.g. path templates string
+    like this must be preserved:
 
         '/path/with/{variable}'
 
@@ -270,6 +270,16 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         error message.
     """
 
+    def sanitize_value(value):
+        """Sanitize the value before returning it."""
+        # HACK: remove trailing curly braces if they exist
+        if type(value) is str and value.endswith("}") and not value.startswith("${"):
+            return value.rstrip("}")
+        # sanitize path-like values
+        elif type(value) is str and ":" in value and ("/" in value or "\\" in value):
+            return dedupe_paths(value)
+        return value
+
     def substitute_variable(match):
         """Substitute a variable match with its value."""
         var_name = match.group(1)
@@ -288,17 +298,20 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         else:
             value = value.replace(varstr, "")
 
-        if operator == "=":
+        # ${VAR:=default} or ${VAR:-default}
+        if operator in ("=", "-"):
             if override:
                 value = override
             elif variable_pattern.search(value) or value is None:
                 value = evaluate_modifiers(argument, environ)
             else:
                 value = value or argument
+        # ${VAR:?error message}
         elif operator == "?":
             if not value:
                 error_message = argument if argument else f"{var_name} is not set"
                 raise ValueError(error_message)
+        # handle recursive references
         elif variable_pattern.search(value):
             value = evaluate_modifiers(value, environ)
         # handle simple ${VAR} substitution
@@ -311,19 +324,10 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         # substitute all matches in the expression
         result = variable_pattern.sub(substitute_variable, expression)
 
-        # HACK: remove trailing curly braces if they exist
-        if result.endswith("}") and not result.startswith("${"):
-            result = result.rstrip("}")
-
         # evaluate any remaining modifiers, eg. ${VAR:=${FOO:=bar}}
         if variable_pattern.search(result):
             result = evaluate_modifiers(result, environ)
 
-        # dedupe path-like values and resolve separators
-        # TODO: replace with regex pattern to detect path-like strings
-        elif ":" in result and ("/" in result or "\\" in result):
-            result = dedupe_paths(result)
-
     # detect recursion errors
     except RecursionError:
         raise CyclicalReference(f"Cyclical reference detected in {expression}")
@@ -340,27 +344,15 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         elif isinstance(expression, FernetNode):
             result = expression.resolve(env=environ)
         elif isinstance(expression, list):
-            result = [
-                (
-                    variable_pattern.sub(substitute_variable, str(v))
-                    if isinstance(v, str)
-                    else v
-                )
-                for v in expression
-            ]
+            result = [(evaluate_modifiers(v, environ)) for v in expression]
         elif isinstance(expression, dict):
             result = {
-                k: (
-                    variable_pattern.sub(substitute_variable, str(v))
-                    if isinstance(v, str)
-                    else v
-                )
-                for k, v in expression.items()
+                k: (evaluate_modifiers(v, environ)) for k, v in expression.items()
             }
         else:
             result = expression
 
-    return result
+    return sanitize_value(result)
 
 
 def load_sys_path(
@@ -571,9 +563,9 @@ def partition_platform_data(data: dict):
     :param data: dictionary to partition.
     :returns: platform partitioned dictionary.
     """
-    # ensure all is present
+    # ensure "all" key is present
     if "all" not in data:
-        data["all"] = {}  # data.copy()
+        data["all"] = dict((k, v) for k, v in data.items() if k != "include")
 
     # platforms of interest (darwin, linux, windows)
     platforms = ["darwin", "linux", "windows"]