envstack 0.5.2__tar.gz → 0.5.4__tar.gz

envstack-0.5.4/LICENSE

@@ -0,0 +1,12 @@
+envstack
+
+Copyright (c) 2024, Ryan Galloway (ryan@rsgalloway.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{envstack-0.5.2 → envstack-0.5.4}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.5.2
+Version: 0.5.4
 Summary: Stacked environment variable management system.
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
 Author-email: ryan@rsgalloway.com
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: PyYAML>=5.1.2
 
 envstack
@@ -171,8 +172,8 @@ To init the environment stack, use the `init` function:
 'bar'
 ```
 
-Alternatively, `envstack.getenv` uses the default environment stack `stack` and
-can be a drop-in replacement for `os.getenv` 
+Alternatively, `envstack.getenv` can be a drop-in replacement for `os.getenv`
+for the default environment stack:
 
 ```python
 >>> import envstack
@@ -217,18 +218,49 @@ $ envstack thing -- python -c "import os; print(os.environ['FOO'])"
 bar
 ```
 
-To source the environment in your current shell, source the output of --export
-(and create an alias for convenience):
+## Shells
 
+In order to set an environment stack in your current shell, the stack must be
+sourced (that's because Python processes and subshells cannot alter the
+environment of the parent process).
+
+To source the environment in your current shell, create an alias that sources
+the output of the `--export` command:
+
+#### bash
 ```bash
-$ source <(envstack --export)
-$ alias stack='source <(envstack $ARG --export)'
+alias envstack-set='source <(envstack "$1" --export)';
+```
+
+#### cmd
+```cmd
+doskey envstack-set=for /f "usebackq" %i in (`envstack --export $*`) do %%i
 ```
 
-In Windows command prompt:
+Then you can set the environment stack in your shell with the `envstack-set`
+command. To clear the environment in your current shell, create an alias that
+sources the output of the `--clear` command:
+
+#### bash
+```bash
+alias envstack-clear='source <(envstack "$1" --clear)';
+```
+
+#### cmd
+```cmd
+doskey envstack-clear=for /f "usebackq" %i in (`envstack --clear $*`) do %%i
+```
+
+Create a function for convenience that does both in one command:
+
+#### bash
+```bash
+envstack-init() { envstack-clear "$1"; envstack-set "$1"; }
+```
 
+#### cmd
 ```cmd
-for /f "usebackq" %i in (`envstack --export`) do %i
+doskey envstack-init=envstack-clear $* & envstack-set $*
 ```
 
 ## Config

{envstack-0.5.2 → envstack-0.5.4}/README.md

@@ -161,8 +161,8 @@ To init the environment stack, use the `init` function:
 'bar'
 ```
 
-Alternatively, `envstack.getenv` uses the default environment stack `stack` and
-can be a drop-in replacement for `os.getenv` 
+Alternatively, `envstack.getenv` can be a drop-in replacement for `os.getenv`
+for the default environment stack:
 
 ```python
 >>> import envstack
@@ -207,18 +207,49 @@ $ envstack thing -- python -c "import os; print(os.environ['FOO'])"
 bar
 ```
 
-To source the environment in your current shell, source the output of --export
-(and create an alias for convenience):
+## Shells
 
+In order to set an environment stack in your current shell, the stack must be
+sourced (that's because Python processes and subshells cannot alter the
+environment of the parent process).
+
+To source the environment in your current shell, create an alias that sources
+the output of the `--export` command:
+
+#### bash
 ```bash
-$ source <(envstack --export)
-$ alias stack='source <(envstack $ARG --export)'
+alias envstack-set='source <(envstack "$1" --export)';
+```
+
+#### cmd
+```cmd
+doskey envstack-set=for /f "usebackq" %i in (`envstack --export $*`) do %%i
 ```
 
-In Windows command prompt:
+Then you can set the environment stack in your shell with the `envstack-set`
+command. To clear the environment in your current shell, create an alias that
+sources the output of the `--clear` command:
+
+#### bash
+```bash
+alias envstack-clear='source <(envstack "$1" --clear)';
+```
+
+#### cmd
+```cmd
+doskey envstack-clear=for /f "usebackq" %i in (`envstack --clear $*`) do %%i
+```
+
+Create a function for convenience that does both in one command:
+
+#### bash
+```bash
+envstack-init() { envstack-clear "$1"; envstack-set "$1"; }
+```
 
+#### cmd
 ```cmd
-for /f "usebackq" %i in (`envstack --export`) do %i
+doskey envstack-init=envstack-clear $* & envstack-set $*
 ```
 
 ## Config

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack/__init__.py

@@ -34,7 +34,7 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "0.5.2"
+__version__ = "0.5.4"
 
 from envstack.env import Env
 from envstack.env import getenv, init, load_file

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack/cli.py

@@ -73,10 +73,15 @@ def parse_args():
         default=config.DEFAULT_NAMESPACE,
         help="the environment stack to use (default '%s')" % config.DEFAULT_NAMESPACE,
     )
+    parser.add_argument(
+        "--clear",
+        action="store_true",
+        help="generate shell unset commands for a given stack",
+    )
     parser.add_argument(
         "--export",
         action="store_true",
-        help="generate export commands for the current shell",
+        help="generate shell export commands for a given stack",
     )
     parser.add_argument(
         "-p",
@@ -133,12 +138,16 @@ def main():
             sources = build_sources(args.namespace)
             for source in sources:
                 print(source)
+        elif args.clear:
+            print(export(args.namespace, config.SHELL, clear=True))
         elif args.export:
             print(export(args.namespace, config.SHELL))
         elif command:
-            return run_command(args.namespace, command)
+            return run_command(command, args.namespace)
         else:
-            env = load_environ(args.namespace, platform=args.platform, includes=True)
+            env = load_environ(
+                args.namespace, environ=None, platform=args.platform, includes=True
+            )
             for k, v in env.items():
                 print(f"{k}={v}")
 

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack/env.py

@@ -179,7 +179,7 @@ class EnvVar(string.Template, str):
 
     def value(self):
         """Returns EnvVar value."""
-        return safe_eval(self.template)
+        return re.sub(r"(?<!\b[A-Za-z]):", os.pathsep, safe_eval(self.template))
 
     def vars(self):
         """Returns a list of embedded, named variables, e.g.: ::
@@ -504,33 +504,52 @@ def expandvars(var, env=None, recursive=False):
     return EnvVar(var).expand(env, recursive=recursive)
 
 
-def export(name, shell="bash", resolve=False, scope=None):
+def export(name, shell="bash", resolve=False, scope=None, clear=False):
     """Returns environment commands that can be sourced.
 
        $ source <(envstack --export)
 
-    List of shell names: bash, tcsh, cmd, pwsh
+    or to clear existing values:
+
+        $ source <(envstack --clear)
+
+    List of shell names: bash, sh, tcsh, cmd, pwsh
     (see output of config.detect_shell()).
 
-    :param name: stack namespace
-    :param shell: name of shell (default: bash)
-    :param resolve: resolve values (default: True)
-    :param scope: environment scope (default: cwd)
-    :returns: shell commands as string
+    :param name: stack namespace.
+    :param shell: name of shell (default: bash).
+    :param resolve: resolve values (default: True).
+    :param scope: environment scope (default: cwd).
+    :param clear: clear existing values (default: False).
+    :returns: shell commands as string.
     """
     env = load_environ(name, scope=scope)
     expList = list()
     for k, v in env.items():
         if resolve:
             v = expandvars(v, env, recursive=False)
-        if shell == "bash":
-            expList.append('export {0}="{1}"'.format(k, v))
+        if shell in ["bash", "sh", "zsh"]:
+            if clear:
+                expList.append(f"unset {k}")
+            else:
+                expList.append(f'export {k}="{v}"')
         elif shell == "tcsh":
-            expList.append('setenv {0}:"{1}"'.format(k, v))
+            if clear:
+                expList.append(f"unsetenv {k}")
+            else:
+                expList.append(f'setenv {k}:"{v}"')
         elif shell == "cmd":
-            expList.append('set {0}="{1}"'.format(k, v))
+            if clear:
+                expList.append(f"set {k}=")
+            else:
+                expList.append(f'set {k}="{v}"')
         elif shell == "pwsh":
-            expList.append('$env:{0}="{1}"'.format(k, v))
+            if clear:
+                expList.append(f"Remove-Item Env:{k}")
+            else:
+                expList.append(f'$env:{k}="{v}"')
+        elif shell == "unknown":
+            raise Exception("unknown shell")
     expList.sort()
     exp = "\n".join(expList)
     return exp
@@ -626,7 +645,7 @@ def load_file(path):
     return data
 
 
-def merge(env, other):
+def merge(env, other, strict=False):
     """Merges values from other into env. For example, to merge values from
     the local environment into an env instance:
 
@@ -638,12 +657,24 @@ def merge(env, other):
 
     :param env: source env
     :param other: env to merge
+    :param strict: env value takes precedence (default: False)
     :returns: merged env
     """
     merged = env.copy()
-    for key in merged:
+    for key, value in merged.items():
+        var = "${%s}" % key
         if key in other:
-            merged[key] = other.get(key)
+            if var in str(value):
+                value = re.sub(
+                    r"\${(\w+)}",
+                    lambda match: other.get(match.group(1), match.group(0)),
+                    value,
+                )
+            elif not strict:
+                value = other.get(key)
+        else:
+            value = value.replace(var, "")
+        merged[key] = value
     return merged
 
 

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack/wrapper.py

@@ -37,13 +37,14 @@ import os
 import subprocess
 import traceback
 
+from envstack import config
 from envstack import logger
 from envstack.env import encode, expandvars, load_environ
 
 
 def to_args(cmd):
-    """Converts a command line string to an arg list to be passed to subprocess.Popen
-    that preserves args with quotes."""
+    """Converts a command line string to an arg list to be passed to
+    subprocess.Popen that preserves args with quotes."""
 
     import shlex
 
@@ -81,6 +82,7 @@ class Wrapper(object):
         super(Wrapper, self).__init__()
         self.args = args
         self.name = namespace
+        self.shell = True
         self.log = logger.log
         self.env = load_environ(namespace)
 
@@ -91,19 +93,16 @@ class Wrapper(object):
     def launch(self):
         """Launches the wrapped tool in a subprocess with env."""
         exitcode = 0
-
-        # get subprocess env, cmd and args
         env = self.get_subprocess_env()
         cmd = expandvars(self.executable(), env, recursive=True)
-        args = " ".join(['"%s"' % arg for arg in to_args(cmd) + self.args])
+        args = self.get_subprocess_args(cmd)
 
-        # run command in subprocess
         try:
             process = subprocess.Popen(
                 args=args,
                 bufsize=0,
                 env=env,
-                shell=True,
+                shell=self.shell,
             )
 
         except Exception:
@@ -119,6 +118,10 @@ class Wrapper(object):
 
         return exitcode
 
+    def get_subprocess_args(self, cmd):
+        """Returns the arguments to be passed to the subprocess."""
+        return self.args
+
     def get_subprocess_env(self):
         """
         Returns the environment that gets passed to the subprocess when launch()
@@ -132,30 +135,109 @@ class Wrapper(object):
 class CommandWrapper(Wrapper):
     """Wrapper class for running wrapped commands from the command-line."""
 
-    def __init__(self, namespace, args=[]):
+    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
         """
-        Initializes the command wrapper with the given namespace and args.
+        Initializes the command wrapper with the given namespace and args, e.g.:
 
-        :param namespace: stack namespace
-        :param args: command line arguments
+            >>> cmd = CommandWrapper('stack', ['ls', '-al'])
+            >>> print(cmd.executable())
+            ls
+            >>> print(cmd.args)
+            ['-al']
+
+        :param namespace: stack namespace (default: 'stack')
+        :param args: command and arguments as a list
         """
         super(CommandWrapper, self).__init__(namespace, args)
         self.log.debug("running command [stack: %s] %s", namespace, args)
         self.cmd = args[0]
         self.args = args[1:]
 
+    def get_subprocess_args(self, cmd):
+        """Returns the arguments to be passed to the subprocess."""
+        return " ".join(['"%s"' % arg for arg in to_args(cmd) + self.args])
+
+    def executable(self):
+        """Returns the command to run."""
+        return self.cmd
+
+
+class ShellWrapper(CommandWrapper):
+    """Wrapper class for running wrapped commands in bash, sh, or zsh."""
+
+    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
+        """
+        Initializes the command wrapper with the given namespace and args,
+        replacing the original command with the shell command, e.g.:
+
+            >>> cmd = ShellWrapper('stack', ['ls', '-l'])
+            >>> print(cmd.executable())
+            bash
+            >>> print(cmd.args)
+            ['-i', '-c', 'ls -l']
+
+        :param namespace: stack namespace (default: 'stack')
+        :param args: command and arguments as a list
+        """
+        super(ShellWrapper, self).__init__(namespace, args)
+        self.args = ["-i", "-c", "%s" % " ".join([self.cmd] + self.args)]
+
     def executable(self):
+        """Returns the shell command to run the original command."""
+        self.cmd = config.SHELL
         return self.cmd
 
 
-def run_command(namespace, command):
+class CmdWrapper(CommandWrapper):
+    """Wrapper class for running wrapped commands in command prompt."""
+
+    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
+        """
+        Initializes the command wrapper with the given namespace and args,
+        replacing the original command with the shell command, e.g.:
+
+            >>> cmd = CmdWrapper('stack', ['ls', '-l'])
+            >>> print(cmd.executable())
+            bash
+            >>> print(cmd.args)
+            ['-i', '-c', 'ls -l']
+
+        :param namespace: stack namespace (default: 'stack')
+        :param args: command and arguments as a list
+        """
+        super(CmdWrapper, self).__init__(namespace, args)
+        self.args = ["/c", "%s" % " ".join([self.cmd] + self.args)]
+        self.shell = False
+
+    def get_subprocess_args(self, cmd):
+        """Returns the arguments to be passed to the subprocess."""
+        return [cmd] + self.args
+
+    def executable(self):
+        """Returns the shell command to run the original command."""
+        self.cmd = config.SHELL
+        return self.cmd
+
+
+def run_command(command, namespace=config.DEFAULT_NAMESPACE):
     """
     Runs a given command with the given stack namespace.
 
-    :param namespace: stack namespace
-    :param command: command to run as arg list
+        >>> run_command(['ls', '-l'])
+
+    Or to run in a specific stack namespace:
+
+        >>> run_command(['ls', '-l'], 'my-stack')
+
+    :param command: command to run as a list of arguments
+    :param namespace: environment stack namespace (default: 'stack')
     :returns: exit code
     """
     logger.setup_stream_handler()
-    cmd = CommandWrapper(namespace, command)
+    if config.SHELL in ["bash", "sh", "zsh"]:
+        cmd = ShellWrapper(namespace, command)
+    elif config.SHELL in ["cmd"]:
+        cmd = CmdWrapper(namespace, command)
+    else:
+        cmd = CommandWrapper(namespace, command)
     return cmd.launch()

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.5.2
+Version: 0.5.4
 Summary: Stacked environment variable management system.
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
 Author-email: ryan@rsgalloway.com
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: PyYAML>=5.1.2
 
 envstack
@@ -171,8 +172,8 @@ To init the environment stack, use the `init` function:
 'bar'
 ```
 
-Alternatively, `envstack.getenv` uses the default environment stack `stack` and
-can be a drop-in replacement for `os.getenv` 
+Alternatively, `envstack.getenv` can be a drop-in replacement for `os.getenv`
+for the default environment stack:
 
 ```python
 >>> import envstack
@@ -217,18 +218,49 @@ $ envstack thing -- python -c "import os; print(os.environ['FOO'])"
 bar
 ```
 
-To source the environment in your current shell, source the output of --export
-(and create an alias for convenience):
+## Shells
 
+In order to set an environment stack in your current shell, the stack must be
+sourced (that's because Python processes and subshells cannot alter the
+environment of the parent process).
+
+To source the environment in your current shell, create an alias that sources
+the output of the `--export` command:
+
+#### bash
 ```bash
-$ source <(envstack --export)
-$ alias stack='source <(envstack $ARG --export)'
+alias envstack-set='source <(envstack "$1" --export)';
+```
+
+#### cmd
+```cmd
+doskey envstack-set=for /f "usebackq" %i in (`envstack --export $*`) do %%i
 ```
 
-In Windows command prompt:
+Then you can set the environment stack in your shell with the `envstack-set`
+command. To clear the environment in your current shell, create an alias that
+sources the output of the `--clear` command:
+
+#### bash
+```bash
+alias envstack-clear='source <(envstack "$1" --clear)';
+```
+
+#### cmd
+```cmd
+doskey envstack-clear=for /f "usebackq" %i in (`envstack --clear $*`) do %%i
+```
+
+Create a function for convenience that does both in one command:
+
+#### bash
+```bash
+envstack-init() { envstack-clear "$1"; envstack-set "$1"; }
+```
 
+#### cmd
 ```cmd
-for /f "usebackq" %i in (`envstack --export`) do %i
+doskey envstack-init=envstack-clear $* & envstack-set $*
 ```
 
 ## Config

{envstack-0.5.2 → envstack-0.5.4}/lib/envstack.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 setup.py
 stack.env

{envstack-0.5.2 → envstack-0.5.4}/setup.py

@@ -74,7 +74,7 @@ class PostInstallCommand(install):
 
 setup(
     name="envstack",
-    version="0.5.2",
+    version="0.5.4",
     description="Stacked environment variable management system.",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -85,7 +85,7 @@ setup(
     packages=find_packages("lib"),
     entry_points={
         "console_scripts": [
-            "envstack = envstack.cli:main",
+            "envstack=envstack.cli:main",
         ],
     },
     install_requires=[

envstack-0.5.4/stack.env

@@ -0,0 +1,34 @@
+# Stacked environment variable management system.
+#
+# Environment variables are declared in namespaced .env files using yaml syntax.
+# The default stack declares env variables in stack.env files.
+# Create any new stack by creating new .env files, e.g. to create a new stack
+# called "thing", just create thing.env files in any given context.
+#
+# $ pip install envstack
+
+all: &default
+  ENV: prod
+  HELLO: world
+  LOG_LEVEL: INFO
+  DEFAULT_ENV_DIR: ${DEPLOY_ROOT}/env
+  DEPLOY_ROOT: ${ROOT}/${ENV}
+  BIN: ${DEPLOY_ROOT}/bin
+  LIB: ${DEPLOY_ROOT}/lib/python
+  PATH: "${BIN}:${PATH}"
+  PYTHONPATH: "${LIB}:${PYTHONPATH}"
+
+darwin:
+  <<: *default
+  ROOT: "${HOME}/Library/Application Support/envstack"
+  # ROOT: /Volumes/tools
+
+linux:
+  <<: *default
+  ROOT: ${HOME}/.local/envstack
+  # ROOT: /mnt/tools
+
+windows:
+  <<: *default
+  ROOT: C:/ProgramData/envstack
+  # ROOT: //server/tools

envstack-0.5.2/stack.env

@@ -1,29 +0,0 @@
-# stack.env is the default envstack file
-#
-# https://github.com/rsgalloway/envstack
-
-all: &default
-  ENV: prod
-  HELLO: world
-  LOG_LEVEL: INFO
-  DEFAULT_ENV_DIR: ${DEPLOY_ROOT}/env
-  DEPLOY_ROOT: ${ROOT}/${ENV}
-  # BIN: ${DEPLOY_ROOT}/bin
-  # LIB: ${DEPLOY_ROOT}/lib/python
-  # PATH: "${BIN}:${PATH}"
-  # PYTHONPATH: "${LIB}/python:${PYTHONPATH}"
-
-darwin:
-  <<: *default
-  ROOT: "${HOME}/Library/Application Support/envstack"
-  # ROOT: /Volumes/tools
-
-linux:
-  <<: *default
-  ROOT: ${HOME}/.local/envstack
-  # ROOT: /mnt/tools
-
-windows:
-  <<: *default
-  ROOT: C:/ProgramData/envstack
-  # ROOT: //server/tools