envstack 1.0.1__tar.gz → 1.0.3__tar.gz

{envstack-1.0.1/lib/envstack.egg-info → envstack-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 1.0.1
+Version: 1.0.3
 Summary: Environment variable composition layer for tools and processes.
 Author-email: Ryan Galloway <ryan@rsgalloway.com>
 License: BSD 3-Clause License
@@ -20,11 +20,15 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=5.1.2
-Requires-Dist: cryptography>=43.0.1
+Requires-Dist: cryptography<47,>=43.0.1; python_version < "3.9"
+Requires-Dist: cryptography>=43.0.1; python_version >= "3.9"
 
 envstack
 ========

{envstack-1.0.1 → envstack-1.0.3}/lib/envstack/__init__.py

@@ -34,7 +34,7 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 
 from envstack.env import clear, init, revert, save  # noqa: F401
 from envstack.env import load_environ, resolve_environ  # noqa: F401

{envstack-1.0.1 → envstack-1.0.3}/lib/envstack/encrypt.py

@@ -37,22 +37,53 @@ import base64
 import binascii
 import os
 import secrets
+import warnings
 from base64 import b64decode, b64encode
+from functools import wraps
 
 from envstack.logger import log
 
 # cryptography and _rust dependency may not be available everywhere
 # ImportError: DLL load failed while importing _rust: Module not found.
+CRYPTOGRAPHY_AVAILABLE = False
 Fernet = None
+InvalidToken = type("InvalidToken", (Exception,), {})
+InvalidTag = type("InvalidTag", (Exception,), {})
+padding = None
+Cipher = None
+algorithms = None
+modes = None
 try:
-    import cryptography.exceptions
-    from cryptography.fernet import Fernet, InvalidToken
-    from cryptography.hazmat.primitives import padding
-    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+    # cryptography emits a Python 3.8 deprecation warning during import.
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message=r"Python 3\.8 is no longer supported by the Python core team.*",
+            category=DeprecationWarning,
+            module=r"cryptography(\..*)?$",
+        )
+        from cryptography.fernet import Fernet, InvalidToken
+        from cryptography.exceptions import InvalidTag
+        from cryptography.hazmat.primitives import padding
+        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+    CRYPTOGRAPHY_AVAILABLE = True
 except ImportError as err:
     log.debug("cryptography module not available: %s", err)
 
 
+def require_cryptography(func):
+    """Guard crypto-backed functions when cryptography is unavailable."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if not CRYPTOGRAPHY_AVAILABLE:
+            raise RuntimeError("cryptography support is not available")
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
 class Base64Encryptor(object):
     """Encrypt and decrypt secrets using base64 encoding."""
 
@@ -84,6 +115,7 @@ class FernetEncryptor(object):
             self.key = self.get_key(env)
 
     @classmethod
+    @require_cryptography
     def generate_key(csl):
         """Generate a new 256-bit encryption key."""
         if Fernet:
@@ -104,6 +136,7 @@ class FernetEncryptor(object):
             return Fernet(key)
         return key
 
+    @require_cryptography
     def encrypt(self, data: str):
         """Encrypt a secret using Fernet.
 
@@ -121,9 +154,9 @@ class FernetEncryptor(object):
             log.error("invalid value: %s", e)
         except Exception as e:
             log.error("unhandled error: %s", e)
-        finally:
-            return results
+        return results
 
+    @require_cryptography
     def decrypt(self, data: str):
         """Decrypt a secret using Fernet.
 
@@ -153,6 +186,7 @@ class AESGCMEncryptor(object):
             self.key = self.get_key(env)
 
     @classmethod
+    @require_cryptography
     def generate_key(csl):
         """Generate a new 256-bit encryption key."""
         key = secrets.token_bytes(32)
@@ -171,6 +205,7 @@ class AESGCMEncryptor(object):
                 raise ValueError("invalid base64 encoding: %s" % e)
         return key
 
+    @require_cryptography
     def encrypt_data(self, secret: str):
         """Encrypt a secret using AES-GCM.
 
@@ -189,6 +224,7 @@ class AESGCMEncryptor(object):
             "tag": b64encode(encryptor.tag).decode(),
         }
 
+    @require_cryptography
     def decrypt_data(self, encrypted_data: dict):
         """Decrypt a secret using AES-GCM.
 
@@ -218,14 +254,13 @@ class AESGCMEncryptor(object):
             results = compact_store(encrypted_data)
         except binascii.Error as e:
             log.error("invalid base64 encoding: %s", e)
-        except cryptography.exceptions.InvalidTag:
+        except InvalidTag:
             log.error("invalid encryption key")
         except ValueError as e:
             log.error("invalid value: %s", e)
         except Exception as e:
             log.error("unhandled error: %s", e)
-        finally:
-            return results
+        return results
 
     def decrypt(self, data: str):
         """Convenience function to decrypt a secret using AES-GCM.
@@ -239,7 +274,7 @@ class AESGCMEncryptor(object):
             return decrypted.decode()
         except binascii.Error as e:
             log.debug("invalid base64 encoding: %s", e)
-        except cryptography.exceptions.InvalidTag:
+        except InvalidTag:
             log.debug("invalid encryption key")
         except ValueError as e:
             log.debug("invalid value: %s", e)
@@ -248,6 +283,7 @@ class AESGCMEncryptor(object):
         return data
 
 
+@require_cryptography
 def pad_data(data: str):
     """Pad data to be block-aligned for AES encryption.
 
@@ -258,6 +294,7 @@ def pad_data(data: str):
     return padder.update(str(data).encode()) + padder.finalize()
 
 
+@require_cryptography
 def unpad_data(data: dict):
     """Unpad data after decryption.
 

{envstack-1.0.1 → envstack-1.0.3}/lib/envstack/env.py

@@ -248,7 +248,7 @@ class EnvVar(string.Template, str):
         >>> v.vars()
         ['FOO', 'BAR']
         """
-        matches = super(EnvVar, self).pattern.findall(str(self.template))
+        matches = type(self).pattern.findall(str(self.template))
         return [key for match in matches for key in match if key]
 
 

{envstack-1.0.1 → envstack-1.0.3/lib/envstack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 1.0.1
+Version: 1.0.3
 Summary: Environment variable composition layer for tools and processes.
 Author-email: Ryan Galloway <ryan@rsgalloway.com>
 License: BSD 3-Clause License
@@ -20,11 +20,15 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=5.1.2
-Requires-Dist: cryptography>=43.0.1
+Requires-Dist: cryptography<47,>=43.0.1; python_version < "3.9"
+Requires-Dist: cryptography>=43.0.1; python_version >= "3.9"
 
 envstack
 ========

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

@@ -0,0 +1,7 @@
+PyYAML>=5.1.2
+
+[:python_version < "3.9"]
+cryptography<47,>=43.0.1
+
+[:python_version >= "3.9"]
+cryptography>=43.0.1

{envstack-1.0.1 → envstack-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "envstack"
-version = "1.0.1"
+version = "1.0.3"
 description = "Environment variable composition layer for tools and processes."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.6"
@@ -12,7 +12,8 @@ license = { text = "BSD 3-Clause License" }
 authors = [{ name = "Ryan Galloway", email = "ryan@rsgalloway.com" }]
 dependencies = [
   "PyYAML>=5.1.2",
-  "cryptography>=43.0.1",
+  'cryptography>=43.0.1,<47; python_version < "3.9"',
+  'cryptography>=43.0.1; python_version >= "3.9"',
 ]
 classifiers = [
   "Development Status :: 4 - Beta",
@@ -25,6 +26,9 @@ classifiers = [
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 keywords = [
   "environment",

envstack-1.0.1/lib/envstack/wrapper.py

@@ -1,335 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright (c) 2024-2026, Ryan Galloway (ryan@rsgalloway.com)
-#
-# 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 software 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.
-#
-
-__doc__ = """
-Contains executable wrapper classes and functions.
-"""
-
-import os
-import re
-import shlex
-import subprocess
-import traceback
-
-from envstack import config, logger
-from envstack.env import load_environ, resolve_environ
-from envstack.util import encode, evaluate_modifiers
-
-
-def to_args(cmd: str):
-    """
-    Converts a command line string to an arg list to be passed to
-    subprocess.Popen that preserves args with quotes.
-
-    :param cmd: command line string.
-    """
-    return shlex.split(cmd)
-
-
-def shell_join(args):
-    """
-    Joins a list of arguments into a single quoted shell string.
-
-    :param args: list of arguments.
-    :returns: shell string.
-    """
-    argstr = ".".join(args)
-    if '"' in argstr or "'" in argstr:
-        try:
-            return shlex.join(args)
-        except AttributeError:
-            return " ".join(shlex.quote(arg) for arg in args)
-    else:
-        return " ".join(args)
-
-
-class Wrapper(object):
-    """Wrapper class for executables. Subprocessed with preconfigured environment.
-
-    Subclasses should override executable():
-
-        class ToolWrapper(Wrapper):
-            def __init__(self, namespace, args):
-                super(ToolWrapper, self).__init__(namespace, args)
-            def executable(self):
-                return '$TOOL_ROOT/bin/tool'
-
-    To launch 'tool', create an instance of the wrapper, and pass as the first
-    argument the namespace continaining config options, then call launch():
-
-        tool = ToolWrapper('tool', sys.argv[1:])
-        tool.launch()
-
-    The log attribute can be set to a custom logger:
-
-        tool.log = MyLogger()
-    """
-
-    shell: bool = False
-
-    def __init__(self, namespace, args=[]):
-        """Initializes the wrapper with the given namespace and args.
-
-        :param namespace: environment stack namespace.
-        :param args: command line arguments.
-        """
-        super(Wrapper, self).__init__()
-        self.args = args
-        self.name = namespace
-        self.shell = self.shell
-        self.log = logger.log
-        self.env = load_environ(namespace)
-
-    def executable(self):
-        """Returns the path to the executable."""
-        raise NotImplementedError
-
-    def launch(self):
-        """Launches the wrapped tool in a subprocess with env."""
-        env = self.get_subprocess_env()
-        command = self.get_subprocess_command(env)
-
-        try:
-            proc = subprocess.run(
-                command,
-                env=encode(env),
-                shell=self.shell,
-                check=False,
-            )
-            return proc.returncode
-        except Exception:
-            traceback.print_exc()
-            return 1
-
-    def get_subprocess_args(self, cmd):
-        """Returns the arguments to be passed to the subprocess."""
-        return self.args
-
-    def get_subprocess_command(self, env):
-        """Returns argv (preferred) or a command string if shell=True."""
-        cmd = evaluate_modifiers(self.executable(), env)
-        args = self.get_subprocess_args(cmd)
-
-        if self.shell:
-            return " ".join([cmd] + args)
-
-        return [cmd] + args
-
-    def get_subprocess_env(self):
-        """
-        Returns the environment that gets passed to the subprocess when launch()
-        is called on the wrapper.
-        """
-        env = os.environ.copy()
-        env.update(resolve_environ(self.env))
-        return env
-
-
-class CommandWrapper(Wrapper):
-    """Wrapper class for running wrapped commands from the command-line."""
-
-    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
-        """
-        Initializes the command wrapper with the given namespace and args, e.g.:
-
-            >>> cmd = CommandWrapper(stack, ['ls', '-al'])
-            >>> print(cmd.executable())
-            ls
-            >>> print(cmd.args)
-            ['-al']
-
-        :param namespace: environment stack name (default: 'default').
-        :param args: command and arguments as a list.
-        """
-        super(CommandWrapper, self).__init__(namespace, args)
-        self.cmd = list(args)
-
-    def executable(self):
-        """Returns the command to run."""
-        return self.cmd[0]
-
-    def get_subprocess_args(self, cmd):
-        return self.cmd[1:]
-
-
-class ShellWrapper(Wrapper):
-    """
-    Runs a *string expression* under the user's shell using -c.
-    Useful for wrapping shell expressions that need variable expansion:
-
-        >>> shell = ShellWrapper('default', 'echo {HOME}')
-    """
-
-    def __init__(self, namespace=config.DEFAULT_NAMESPACE, expr: str = ""):
-        super().__init__(namespace, args=[])
-        self.expr = expr
-
-    def get_interactive(self, env: dict = os.environ):
-        override = env.get("INTERACTIVE")
-        if override is not None:
-            return str(override).lower() in {"1", "true", "yes", "on"}
-        return False  # default safe
-
-    def get_subprocess_command(self, env: dict = os.environ):
-        interactive = self.get_interactive(env)
-        if interactive:
-            return [config.SHELL, "-i", "-c", self.expr]
-        return [config.SHELL, "-c", self.expr]
-
-    def executable(self):
-        """Returns the shell command to run the original command."""
-        return self.cmd
-
-
-class CmdWrapper(CommandWrapper):
-    """Wrapper class for running wrapped commands in Windows cmd.exe."""
-
-    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
-        super().__init__(namespace, args)
-
-        # Always run through cmd.exe explicitly
-        self.shell = False
-        self._cmd_exe = config.SHELL  # expected: "cmd" or "cmd.exe"
-
-        # Join the intended argv into one command-line string for /c
-        cmdline = shell_join(self.cmd)
-
-        # cmd.exe /c <command>
-        self._subprocess_argv = [self._cmd_exe, "/c", cmdline]
-
-    def executable(self):
-        return self._cmd_exe
-
-    def get_subprocess_args(self, cmd):
-        # Not used (we override get_subprocess_command)
-        return []
-
-    def get_subprocess_command(self, env):
-        return list(self._subprocess_argv)
-
-
-def capture_output(
-    command: str,
-    namespace: str = config.DEFAULT_NAMESPACE,
-    timeout: int = config.COMMAND_TIMEOUT,
-):
-    """
-    Runs a command (string or argv) with the given stack namespace and captures stdout/stderr.
-
-    Returns: (returncode, stdout, stderr)
-    """
-    import errno
-
-    shellname = os.path.basename(config.SHELL).lower()
-    argv = list(command) if isinstance(command, (list, tuple)) else to_args(command)
-
-    # build env exactly like Wrapper.launch()
-    env = os.environ.copy()
-    env.update(resolve_environ(load_environ(namespace)))
-
-    # prefer argv execution where possible
-    if shellname in ["bash", "sh", "zsh"]:
-        needs_shell = any(re.search(r"\{(\w+)\}", a) for a in argv)
-        if needs_shell:
-            expr_argv = [re.sub(r"\{(\w+)\}", r"${\1}", a) for a in argv]
-            expr = shell_join(expr_argv)
-            cmd = [config.SHELL, "-c", expr]
-        else:
-            cmd = argv
-
-    # for cmd always use original command string
-    elif shellname in ["cmd"]:
-        cmd = command
-
-    else:
-        cmd = argv
-
-    try:
-        proc = subprocess.run(
-            cmd,
-            env=encode(env),
-            shell=False,
-            check=False,
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-        return proc.returncode, proc.stdout, proc.stderr
-    except FileNotFoundError as e:
-        # no process ran; synthesize a bash-like error and code
-        # 127 is the conventional "command not found" code in shells
-        missing = e.filename or (
-            cmd[0] if isinstance(cmd, list) and cmd else str(command)
-        )
-        return 127, "", f"{missing}: command not found"
-    except OSError as e:
-        # Other OS-level execution errors (permission, exec format, etc.)
-        rc = 126 if getattr(e, "errno", None) in (errno.EACCES,) else 1
-        return rc, "", str(e)
-    except subprocess.TimeoutExpired as e:
-        return 124, "", f"Command timed out after {timeout} seconds"
-
-
-def run_command(command: str, namespace: str = config.DEFAULT_NAMESPACE):
-    """
-    Runs a given command with the given stack namespace.
-
-        >>> run_command(['ls', '-l'])
-
-    Or to run in a specific stack namespace:
-
-        >>> run_command(['ls', '-l'], 'my-stack')
-
-     - Automatically detects the shell to use.
-     - Converts {VAR} to $VAR for bash, sh, zsh, and %VAR% for cmd.
-
-    :param command: command to run as a list of arguments.
-    :param namespace: environment stack name (default: 'default').
-    :returns: command exit code
-    """
-    logger.setup_stream_handler()
-    shellname = os.path.basename(config.SHELL).lower()
-    argv = list(command) if isinstance(command, (list, tuple)) else to_args(command)
-
-    if shellname in ["bash", "sh", "zsh"]:
-        needs_shell = any(re.search(r"\{(\w+)\}", a) for a in argv)
-        if needs_shell:
-            expr_argv = [re.sub(r"\{(\w+)\}", r"${\1}", a) for a in argv]
-            expr = shell_join(expr_argv)
-            return ShellWrapper(namespace, expr).launch()
-
-        return CommandWrapper(namespace, argv).launch()
-
-    if shellname in ["cmd"]:
-        expr = [re.sub(r"\{(\w+)\}", r"%\1%", a) for a in argv]
-        return CmdWrapper(namespace, expr).launch()
-
-    return CommandWrapper(namespace, argv).launch()

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

@@ -1,2 +0,0 @@
-PyYAML>=5.1.2
-cryptography>=43.0.1