envstack 0.1.0__tar.gz → 0.2.0__tar.gz

{envstack-0.1.0 → envstack-0.2.0}/PKG-INFO

@@ -1,33 +1,38 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.1.0
+Version: 0.2.0
 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
-Requires-Dist: PyYAML==6.0.2
+Requires-Dist: PyYAML>=5.1.2
+Requires-Dist: siteconf>=0.1.3
 
 envstack
 ========
 
-Stacked environment variable management system.
+Stacked environment variable management system. The lightweight, easy to use
+"rez" alternative for production pipelines.
 
 Environment variables are declared in namespaced .env files using yaml syntax.
-The default namespace is `stack` and variables are declared in `stack.env`
-files.
+The default stack is `stack` and variables are declared in `stack.env`
+files. You can create any new stack by creating new `.env` files, e.g. creating
+a new `test` stack just create `test.env` files.
+
+Envstack works best combined with [siteconf](https://github.com/rsgalloway/siteconf).
 
 ## Quickstart
 
 To create a new environment stack, create a new namespaced .env file.
-For example, here is a simple `thing.env` file (namespace is "thing"):
+For example, here is a simple `thing.env` file (the stack namespace is "thing"):
 
 ```yaml
 all: &default
   FOO: bar
 ```
 
-To see the resolved environment for the `thing` stack, run:
+To see the resolved environment for the `thing` environment stack, run:
 
 ```bash
 $ envstack thing
@@ -84,23 +89,47 @@ $ envstack
 To see the resolved environment for a given namespace.
 
 ```bash
-$ envstack <namespace> [OPTIONS]
+$ envstack <stack> [OPTIONS]
 ```
 
-To resolve a $VAR declaration for a given namespace:
+To resolve a `$VAR` declaration for a given environment stack:
 
 ```bash
-$ envstack <namespace> -r <VAR>
+$ envstack <stack> -r <VAR>
 ```
 
-To trace where a $VAR declaration is being set:
+To trace where a `$VAR` declaration is being set:
 
 ```bash
-$ envstack <namespace> -t <VAR>
+$ envstack <stack> -t <VAR>
 ```
 
 To see an environment stack on another platform:
 
 ```bash
-$ envstack <namespace> -p <platform>
+$ envstack <stack> -p <platform>
+```
+
+Running Commands
+----------------
+
+To run any command line executable inside of an environment stack, where `<command>`
+is the command to run:
+
+```bash
+$ enstack <stack> -- <command>
+```
+
+For example, running python in the default stack (reading from the default `stack.env` file):
+
+```bash
+$ envstack -- python -c "from envstack.env import environ; print(environ['HELLO'])"
+world
+```
+
+Same command but using the "thing" stack"
+
+```bash
+$ envstack thing -- python -c "from envstack.env import environ; print(environ['FOO'])"
+bar
 ```

envstack-0.2.0/README.md

@@ -0,0 +1,124 @@
+envstack
+========
+
+Stacked environment variable management system. The lightweight, easy to use
+"rez" alternative for production pipelines.
+
+Environment variables are declared in namespaced .env files using yaml syntax.
+The default stack is `stack` and variables are declared in `stack.env`
+files. You can create any new stack by creating new `.env` files, e.g. creating
+a new `test` stack just create `test.env` files.
+
+Envstack works best combined with [siteconf](https://github.com/rsgalloway/siteconf).
+
+## Quickstart
+
+To create a new environment stack, create a new namespaced .env file.
+For example, here is a simple `thing.env` file (the stack namespace is "thing"):
+
+```yaml
+all: &default
+  FOO: bar
+```
+
+To see the resolved environment for the `thing` environment stack, run:
+
+```bash
+$ envstack thing
+FOO 'bar'
+```
+
+Environment stacks are hierarchical, so values for `$FOO` defined in .env files lower
+in the filesystem (lower in scope) override those defined higher up (higher in scope):
+
+```
+/show/thing.env
+/show/seq/thing.env
+/show/seq/shot/thing.env
+/show/seq/shot/task/thing.env
+```
+
+Variables can reference other variables defined elsewhere (but cannot be circular):
+
+```yaml
+all: &default
+  BAR: $FOO
+```
+
+Variables can be platform specific (and inherit the defaults):
+
+```yaml
+linux:
+  <<: *default
+  HELLO: world
+```
+
+Environment files can include other namespaced environments:
+```yaml
+include: ['other']
+```
+
+Installation
+------------
+
+The easiest way to install:
+
+```bash
+$ pip install envstack
+```
+
+## Usage
+
+To see the default resolved environment for any given scope (directory):
+
+```bash
+$ envstack
+```
+
+To see the resolved environment for a given namespace.
+
+```bash
+$ envstack <stack> [OPTIONS]
+```
+
+To resolve a `$VAR` declaration for a given environment stack:
+
+```bash
+$ envstack <stack> -r <VAR>
+```
+
+To trace where a `$VAR` declaration is being set:
+
+```bash
+$ envstack <stack> -t <VAR>
+```
+
+To see an environment stack on another platform:
+
+```bash
+$ envstack <stack> -p <platform>
+```
+
+Running Commands
+----------------
+
+To run any command line executable inside of an environment stack, where `<command>`
+is the command to run:
+
+```bash
+$ enstack <stack> -- <command>
+```
+
+For example, running python in the default stack (reading from the default `stack.env` file):
+
+```bash
+$ envstack -- python -c "from envstack.env import environ; print(environ['HELLO'])"
+world
+```
+
+Same command but using the "thing" stack"
+
+```bash
+$ envstack thing -- python -c "from envstack.env import environ; print(environ['FOO'])"
+bar
+```

{envstack-0.1.0 → envstack-0.2.0}/lib/envstack/__init__.py

@@ -34,4 +34,4 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{envstack-0.1.0 → envstack-0.2.0}/lib/envstack/cli.py

@@ -33,6 +33,7 @@ __doc__ = """
 Contains command line interface for envstack.
 """
 
+import argparse
 import os
 import sys
 import pprint
@@ -40,13 +41,24 @@ import traceback
 
 from envstack import __version__
 from envstack import config
-from envstack.env import expandvars, load_environ, trace_var
+from envstack.env import expandvars, load_environ, trace_var, build_sources
+from envstack.wrapper import run_command
 
 
 def parse_args():
-    """Command line argument parser."""
+    """Command line argument parser.
 
-    import argparse
+    Returns:
+        tuple: (args, command)
+    """
+
+    if "--" in sys.argv:
+        dash_index = sys.argv.index("--")
+        args_after_dash = sys.argv[dash_index + 1 :]
+        args_before_dash = sys.argv[1:dash_index]
+    else:
+        args_after_dash = []
+        args_before_dash = sys.argv[1:]
 
     parser = argparse.ArgumentParser(
         description=__doc__, formatter_class=argparse.RawTextHelpFormatter
@@ -59,10 +71,10 @@ def parse_args():
     )
     parser.add_argument(
         "namespace",
-        metavar="NAMESPACE",
+        metavar="STACK",
         nargs="?",
         default=config.DEFAULT_NAMESPACE,
-        help="the namespace to use",
+        help="the environment stack to use (default '%s')" % config.DEFAULT_NAMESPACE,
     )
     parser.add_argument(
         "-p",
@@ -77,6 +89,11 @@ def parse_args():
         metavar="VAR",
         help="resolve an environment variable",
     )
+    parser.add_argument(
+        "--sources",
+        action="store_true",
+        help="list the sources for a stack",
+    )
     parser.add_argument(
         "-t",
         "--trace",
@@ -84,14 +101,14 @@ def parse_args():
         help="trace where a variable is getting set",
     )
 
-    args = parser.parse_args()
+    args = parser.parse_args(args_before_dash)
 
-    return args, parser
+    return args, args_after_dash
 
 
 def main():
     """Main thread."""
-    args, _ = parse_args()
+    args, command = parse_args()
 
     try:
         if args.resolve:
@@ -103,6 +120,12 @@ def main():
         elif args.trace:
             path = trace_var(args.namespace, args.trace)
             print("{0}: {1}".format(args.trace, path))
+        elif args.sources:
+            sources = build_sources(args.namespace)
+            for source in sources:
+                print(source)
+        elif command:
+            return run_command(args.namespace, command)
         else:
             env = load_environ(args.namespace, platform=args.platform, includes=True)
             for k, v in env.items():

{envstack-0.1.0 → envstack-0.2.0}/lib/envstack/wrapper.py

@@ -35,6 +35,7 @@ Contains executable wrapper classes and functions.
 
 import os
 import subprocess
+import traceback
 
 from envstack import logger
 from envstack.env import load_environ, expandvars
@@ -126,20 +127,19 @@ class Wrapper(object):
         """Launches the wrapped tool in a subprocess with env."""
         exitcode = 0
 
-        # expand command vars before passing to subprocess
+        # expand and resolve command and environment vars
         cmd = expandvars(self.executable(), self.env, recursive=True)
+        env = encode(self.get_subprocess_env())
 
         # run command in subprocess
         try:
             process = subprocess.Popen(
                 args=to_args(cmd) + self.args,
                 bufsize=0,
-                env=encode(self.get_subprocess_env()),
+                env=env,
             )
 
         except Exception as err:
-            import traceback
-
             traceback.print_exc()
             exitcode = 1
 
@@ -157,3 +157,29 @@ class Wrapper(object):
         is called on the wrapper.
         """
         return self.env
+
+
+class CommandWrapper(Wrapper):
+    """Wrapper class for running wrapped commands from the command-line."""
+
+    def __init__(self, name, args=[]):
+        super(CommandWrapper, self).__init__(name, args)
+        self.log.debug("running command [stack: %s] %s", name, args)
+        self.cmd = args[0]
+        self.args = args[1:]
+
+    def executable(self):
+        return self.cmd
+
+
+def run_command(namespace, command):
+    """
+    Runs a given command with the given stack namespace.
+
+    :param namespace: stack namespace
+    :param command: command to run as arg list
+    :returns: exit code
+    """
+    logger.setup_stream_handler()
+    cmd = CommandWrapper(namespace, command)
+    return cmd.launch()

{envstack-0.1.0 → envstack-0.2.0}/lib/envstack.egg-info/PKG-INFO

@@ -1,33 +1,38 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.1.0
+Version: 0.2.0
 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
-Requires-Dist: PyYAML==6.0.2
+Requires-Dist: PyYAML>=5.1.2
+Requires-Dist: siteconf>=0.1.3
 
 envstack
 ========
 
-Stacked environment variable management system.
+Stacked environment variable management system. The lightweight, easy to use
+"rez" alternative for production pipelines.
 
 Environment variables are declared in namespaced .env files using yaml syntax.
-The default namespace is `stack` and variables are declared in `stack.env`
-files.
+The default stack is `stack` and variables are declared in `stack.env`
+files. You can create any new stack by creating new `.env` files, e.g. creating
+a new `test` stack just create `test.env` files.
+
+Envstack works best combined with [siteconf](https://github.com/rsgalloway/siteconf).
 
 ## Quickstart
 
 To create a new environment stack, create a new namespaced .env file.
-For example, here is a simple `thing.env` file (namespace is "thing"):
+For example, here is a simple `thing.env` file (the stack namespace is "thing"):
 
 ```yaml
 all: &default
   FOO: bar
 ```
 
-To see the resolved environment for the `thing` stack, run:
+To see the resolved environment for the `thing` environment stack, run:
 
 ```bash
 $ envstack thing
@@ -84,23 +89,47 @@ $ envstack
 To see the resolved environment for a given namespace.
 
 ```bash
-$ envstack <namespace> [OPTIONS]
+$ envstack <stack> [OPTIONS]
 ```
 
-To resolve a $VAR declaration for a given namespace:
+To resolve a `$VAR` declaration for a given environment stack:
 
 ```bash
-$ envstack <namespace> -r <VAR>
+$ envstack <stack> -r <VAR>
 ```
 
-To trace where a $VAR declaration is being set:
+To trace where a `$VAR` declaration is being set:
 
 ```bash
-$ envstack <namespace> -t <VAR>
+$ envstack <stack> -t <VAR>
 ```
 
 To see an environment stack on another platform:
 
 ```bash
-$ envstack <namespace> -p <platform>
+$ envstack <stack> -p <platform>
+```
+
+Running Commands
+----------------
+
+To run any command line executable inside of an environment stack, where `<command>`
+is the command to run:
+
+```bash
+$ enstack <stack> -- <command>
+```
+
+For example, running python in the default stack (reading from the default `stack.env` file):
+
+```bash
+$ envstack -- python -c "from envstack.env import environ; print(environ['HELLO'])"
+world
+```
+
+Same command but using the "thing" stack"
+
+```bash
+$ envstack thing -- python -c "from envstack.env import environ; print(environ['FOO'])"
+bar
 ```

envstack-0.2.0/lib/envstack.egg-info/requires.txt

@@ -0,0 +1,2 @@
+PyYAML>=5.1.2
+siteconf>=0.1.3

{envstack-0.1.0 → envstack-0.2.0}/setup.py

@@ -38,7 +38,7 @@ with open(os.path.join(here, "README.md")) as f:
 
 setup(
     name="envstack",
-    version="0.1.0",
+    version="0.2.0",
     description="Stacked environment variable management system.",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -52,8 +52,6 @@ setup(
             "envstack = envstack.cli:main",
         ],
     },
-    install_requires=[
-        "PyYAML==6.0.2",
-    ],
+    install_requires=open("requirements.txt").readlines(),
     zip_safe=False,
 )

envstack-0.1.0/README.md

@@ -1,96 +0,0 @@
-envstack
-========
-
-Stacked environment variable management system.
-
-Environment variables are declared in namespaced .env files using yaml syntax.
-The default namespace is `stack` and variables are declared in `stack.env`
-files.
-
-## Quickstart
-
-To create a new environment stack, create a new namespaced .env file.
-For example, here is a simple `thing.env` file (namespace is "thing"):
-
-```yaml
-all: &default
-  FOO: bar
-```
-
-To see the resolved environment for the `thing` stack, run:
-
-```bash
-$ envstack thing
-FOO 'bar'
-```
-
-Environment stacks are hierarchical, so values for `$FOO` defined in .env files lower
-in the filesystem (lower in scope) override those defined higher up (higher in scope):
-
-```
-/show/thing.env
-/show/seq/thing.env
-/show/seq/shot/thing.env
-/show/seq/shot/task/thing.env
-```
-
-Variables can reference other variables defined elsewhere (but cannot be circular):
-
-```yaml
-all: &default
-  BAR: $FOO
-```
-
-Variables can be platform specific (and inherit the defaults):
-
-```yaml
-linux:
-  <<: *default
-  HELLO: world
-```
-
-Environment files can include other namespaced environments:
-```yaml
-include: ['other']
-```
-
-Installation
-------------
-
-The easiest way to install:
-
-```bash
-$ pip install envstack
-```
-
-## Usage
-
-To see the default resolved environment for any given scope (directory):
-
-```bash
-$ envstack
-```
-
-To see the resolved environment for a given namespace.
-
-```bash
-$ envstack <namespace> [OPTIONS]
-```
-
-To resolve a $VAR declaration for a given namespace:
-
-```bash
-$ envstack <namespace> -r <VAR>
-```
-
-To trace where a $VAR declaration is being set:
-
-```bash
-$ envstack <namespace> -t <VAR>
-```
-
-To see an environment stack on another platform:
-
-```bash
-$ envstack <namespace> -p <platform>
-```

envstack-0.1.0/lib/envstack.egg-info/requires.txt

@@ -1 +0,0 @@
-PyYAML==6.0.2