docker-stack 0.2.3__tar.gz → 0.2.5__tar.gz

{docker-stack-0.2.3 → docker-stack-0.2.5}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: docker-stack
-Version: 0.2.3
+Version: 0.2.5
 Summary: CLI for deploying and managing Docker stacks.
-Home-page: https://github.com/mesuidp/docker-stack
+Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai
 Author-email: sudip@bhattarai.me
 Classifier: Programming Language :: Python :: 3

{docker-stack-0.2.3 → docker-stack-0.2.5}/docker_stack/cli.py

@@ -61,38 +61,42 @@ class DockerStack:
         with open(compose_file) as f:
            return self.decode_yaml(f.read())
     
-    def rendered_compose_file(self,compose_file,stack=None)->str:
+    def rendered_compose_file(self,compose_file,stack=None,include_build=True)->str:
         with open(compose_file) as f:
             template_content = f.read()
         # Parse the YAML content
         compose_data = self.decode_yaml(template_content)
+        if not include_build:
+            services: dict=compose_data.get('services',{})
+            for (k,v) in services.items():
+                if 'build' in v:
+                    del v['build']
         if stack:
             base_dir = os.path.dirname(os.path.abspath(compose_file))
             if "configs" in compose_data:
                 compose_data["configs"] = self._process_x_content(compose_data["configs"], self.docker.config,base_dir=base_dir,stack=stack)
             if "secrets" in compose_data:
                 compose_data["secrets"] = self._process_x_content(compose_data["secrets"], self.docker.secret,base_dir=base_dir,stack=stack)
-        return envsubst(yaml.dump(compose_data))
+        
+        # Define the replacements for '$' to '$$' for env variables in compose files
+        replacements_map = {"$": "$$"}
+        return envsubst(yaml.dump(compose_data), replacements=replacements_map)
     
     def decode_yaml(self,data:str)->dict:
         return yaml.safe_load(data)
         
-    def render_compose_file(self, compose_file,stack=None):
+    def render_compose_file(self, compose_file,stack=None,include_build=True):
         """
         Render the Docker Compose file with environment variables and create Docker configs/secrets.
         """
         
         # Convert the modified data back to YAML
-        rendered_content = self.rendered_compose_file(compose_file,stack)
+        rendered_content = self.rendered_compose_file(compose_file,stack,include_build=include_build)
 
         # Write the rendered file
         rendered_filename = Path(compose_file).with_name(
             f"{Path(compose_file).stem}-rendered{Path(compose_file).suffix}"
         )
-        with open(rendered_filename, "w") as f:
-            f.write(rendered_content)
-        with open(rendered_filename.as_posix()+".json","w") as f:
-            f.write(json.dumps(rendered_content,indent=2))
         return (rendered_filename,rendered_content)
 
 
@@ -262,7 +266,7 @@ class DockerStack:
         self.commands.append(Command(cmd,give_console=True))
 
     def deploy(self, stack_name, compose_file, with_registry_auth=False,tag=None):
-        rendered_filename, rendered_content = self.render_compose_file(compose_file,stack=stack_name)
+        rendered_filename, rendered_content = self.render_compose_file(compose_file,stack=stack_name,include_build=False)
         labels = [f"mesudip.stack.name={stack_name}"]
         if tag:
             labels.append(f"mesudip.stack.tag={tag}")
@@ -361,9 +365,9 @@ def main(args:List[str]=None):
     # Ls command
     subparsers.add_parser("ls",help="List docker-stacks")
     
-    cat_parser = subparsers.add_parser("cat",help="Print the docker compose of specific version")
+    cat_parser = subparsers.add_parser("cat",help="Print the docker compose of specific version. Defaults to latest version if not specified.")
     cat_parser.add_argument("stack_name", help="Name of the stack")
-    cat_parser.add_argument("version", help="Stack version to cat")
+    cat_parser.add_argument("version", nargs='?', help="Stack version to cat. Defaults to latest if omitted.")
     
     checkout_parser = subparsers.add_parser("checkout",help="Deploy specific version of the stack")
     checkout_parser.add_argument("stack_name", help="Name of the stack")
@@ -398,7 +402,17 @@ def main(args:List[str]=None):
     elif args.command == "rm":
         docker.stack.rm(args.stack_name)
     elif args.command == 'cat':
-        print(docker.stack.cat(args.stack_name,args.version))
+        version_to_cat = args.version
+        if version_to_cat is None:
+            versions_list = docker.stack.versions(args.stack_name)
+            if versions_list:
+                # Assuming versions are integers, find the maximum
+                latest_version = max(int(v[0]) for v in versions_list if v[0].isdigit())
+                version_to_cat = str(latest_version)
+            else:
+                print(f"No versions found for stack '{args.stack_name}'.")
+                sys.exit(1)
+        print(docker.stack.cat(args.stack_name, version_to_cat))
     elif args.command == 'checkout':
         docker.stack.checkout(args.stack_name,args.version)
     elif args.command == 'versions' or args.command == "version":

docker-stack-0.2.5/docker_stack/envsubst.py

@@ -0,0 +1,206 @@
+#!/usr/bin/python3
+"""
+NAME
+       envsubst.py - substitutes environment variables in bash format strings
+
+DESCRIPTION
+    envsubst.py is an upgrade of the POSIX command `envsubst`
+
+    supported syntax:
+      normal       - ${VARIABLE1} or $VARIABLE1
+      with default - ${VARIABLE1:-somevalue}
+"""
+
+from dataclasses import dataclass
+import os
+import re
+import sys
+from typing import Dict, List, Literal, Optional
+
+
+@dataclass
+class LineCheckResult:
+    line_no: int
+    line_content: str
+    variable_name: Optional[str] = None  # None means no error
+    start_index: Optional[int] = None # Start index of the variable in the line_content
+
+    @property
+    def has_error(self) -> bool:
+        return self.variable_name is not None
+
+    def __str__(self):
+        if self.has_error:
+            return (f"ERROR :: Missing variable: '{self.variable_name}' "
+                    f"on line {self.line_no}: '{self.line_content}'")
+        return f"OK    :: Line {self.line_no}: '{self.line_content}'"
+
+
+class SubstitutionError(Exception):
+    """Custom exception to collect multiple substitution errors with detailed information."""
+    def __init__(self, results: List[LineCheckResult], template_str: str, underline_char: str = '\u0333'):
+        self.results = results
+        self.template_lines = template_str.splitlines(keepends=False)
+        self.underline_char = underline_char
+        super().__init__(self._format_messages(results))
+
+    def _format_messages(self, results: List[LineCheckResult]) -> str:
+        formatted_messages = []
+        
+        # Group results by line number
+        errors_by_line = {}
+        for result in results:
+            if result.has_error:
+                if result.line_no not in errors_by_line:
+                    errors_by_line[result.line_no] = {
+                        'line_content': result.line_content,
+                        'variables': []
+                    }
+                errors_by_line[result.line_no]['variables'].append({
+                    'name': result.variable_name,
+                    'start_index': result.start_index
+                })
+        
+        # Sort line numbers
+        sorted_line_nos = sorted(errors_by_line.keys())
+        
+        last_printed_line = 0
+
+        for line_no in sorted_line_nos:
+            # Add separator if there's a gap from the last context block
+            if last_printed_line > 0 and (line_no - 2) > (last_printed_line + 1):
+                formatted_messages.append("")
+
+            # Determine context lines to display
+            start_context_line = max(last_printed_line + 1, line_no - 2)
+            end_context_line = min(len(self.template_lines), line_no + 2)
+
+            for current_ln in range(start_context_line, end_context_line + 1):
+                line_text = self.template_lines[current_ln - 1]
+                
+                # If this is an error line, apply the underlining
+                if current_ln in errors_by_line:
+                    current_line_errors = errors_by_line[current_ln]['variables']
+                    
+                    # Sort errors by start_index in reverse to avoid index shifting issues
+                    current_line_errors.sort(key=lambda x: x['start_index'], reverse=True)
+                    
+                    modified_line_text_chars = list(line_text) # Convert to list for mutability
+                    
+                    for var_info in current_line_errors:
+                        var_name = var_info['name']
+                        start_idx = var_info['start_index']
+                        
+                        # Insert underline_char after each character of the variable name
+                        for k in range(len(var_name) - 1, -1, -1):
+                            insert_pos = start_idx + k + 1 # Position after the character
+                            modified_line_text_chars.insert(insert_pos, self.underline_char)
+                    
+                    line_text = "".join(modified_line_text_chars)
+
+                formatted_messages.append(f"{current_ln:3d}   {line_text}")
+            
+            last_printed_line = end_context_line
+
+        return "\n".join(formatted_messages)
+
+
+
+def envsubst(template_str, env=os.environ, replacements: Dict[str, str] = None, on_error: Literal['exit','throw'] = 'exit'):
+    """Substitute environment variables in the template string, supporting default values."""
+
+    # Combined regex for ${VAR:-default} and $VAR, and also $$
+    pattern = re.compile(r"\$\_ESCAPED_DOLLAR_|\$\{([^}:\s]+)(?::-(.*?))?\}|\$([a-zA-Z_][a-zA-Z0-9_]*)")
+
+    # Handle escaped dollars
+    template_str = template_str.replace("$$", "$_ESCAPED_DOLLAR_")
+
+    lines = template_str.splitlines(True) # keepends=True
+    processed_lines = []
+    error_results: List[LineCheckResult] = []
+
+    for i, original_line in enumerate(lines):
+        line_no = i + 1
+        
+        line_errors_raw = [] # Store (var_name, start_index) tuples
+
+        def replacer(match: re.Match[str]):
+            if match.group(0) == '$_ESCAPED_DOLLAR_':
+                return '$$'
+            # Group 1, 2 for ${VAR:-default}
+            if match.group(1) is not None:
+                var = match.group(1)
+                default_value = match.group(2) if match.group(2) is not None else None
+                result = env.get(var, default_value)
+                if result is None:
+                    line_errors_raw.append((var, match.start(1))) # Use match.start(1) for ${VAR}
+                    return match.group(0) # Keep original if variable not found
+            # Group 3 for $VAR
+            else:
+                var = match.group(3)
+                result = env.get(var, None)
+                if result is None:
+                    line_errors_raw.append((var, match.start(3))) # Use match.start(3) for $VAR
+                    return match.group(0) # Keep original if variable not found
+            
+            if replacements:
+                for old, new in replacements.items():
+                    result = result.replace(old, new)
+            return result
+
+        processed_line = pattern.sub(replacer, original_line)
+        
+        processed_lines.append(processed_line)
+        
+        if line_errors_raw:
+            # The original line content for error reporting should not have the escaped dollar placeholder.
+            # It should also retain its leading/trailing whitespace for accurate caret positioning.
+            error_line_content_for_report = original_line.replace("$_ESCAPED_DOLLAR_", "$$").rstrip('\n') # Remove only trailing newline
+            
+            # Use a set of tuples to store unique (var_name, start_index) pairs for this line
+            unique_errors_on_line = set()
+            for var_name, start_index in line_errors_raw:
+                unique_errors_on_line.add((var_name, start_index))
+
+            for var_name, start_index in sorted(list(unique_errors_on_line), key=lambda x: x[1]): # Sort by start_index
+                error_results.append(LineCheckResult(line_no=line_no, line_content=error_line_content_for_report, variable_name=var_name, start_index=start_index))
+
+    if error_results:
+        # Sort errors by line number, then by start_index
+        error_results.sort(key=lambda x: (x.line_no, x.start_index))
+        if on_error == 'exit':
+            error_output = SubstitutionError(error_results, template_str)._format_messages(error_results) # Pass template_str
+            print(error_output, file=sys.stderr)
+            exit(1)
+        elif on_error == 'throw':
+            raise SubstitutionError(error_results, template_str) # Pass template_str
+
+    result_str = "".join(processed_lines)
+    # Restore escaped dollars
+    result_str = result_str.replace("$_ESCAPED_DOLLAR_", "$$")
+
+    return result_str
+
+
+def envsubst_load_file(template_file, env=os.environ, replacements: Dict[str, str] = None, on_error: str = 'exit'):
+    with open(template_file) as file:
+        return envsubst(file.read(), env, replacements, on_error)
+
+def main():
+    if len(sys.argv) > 2:
+        print("Usage: python envsubst.py [template_file]")
+        sys.exit(1)
+
+    if len(sys.argv) == 2:
+        template_file = sys.argv[1]
+        with open(template_file, "r") as file:
+            template_str = file.read()
+    else:
+        template_str = sys.stdin.read()
+
+    result = envsubst(template_str)
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

{docker-stack-0.2.3 → docker-stack-0.2.5}/docker_stack/envsubst_merge.py

@@ -11,9 +11,11 @@ DESCRIPTION
 import os
 import re
 import sys
+from typing import Dict
+from .envsubst import SubstitutionError, envsubst as base_envsubst
 
 
-def envsubst(template_str, env=os.environ):
+def envsubst(template_str, env=os.environ, replacements: Dict[str, str] = None, on_error: str = 'exit'):
     """Substitute environment variables in the template string, supporting default values."""
 
     # Regex for ${VARIABLE} with optional default
@@ -29,6 +31,10 @@ def envsubst(template_str, env=os.environ):
         if result is None:
             print(f"Missing template variable with default: {var}", file=sys.stderr)
             exit(1)
+        
+        if replacements:
+            for old, new in replacements.items():
+                result = result.replace(old, new)
         return result
 
     def replace_without_default(match):
@@ -37,6 +43,10 @@ def envsubst(template_str, env=os.environ):
         if result is None:
             print(f"Missing template variable: {var}", file=sys.stderr)
             exit(1)
+        
+        if replacements:
+            for old, new in replacements.items():
+                result = result.replace(old, new)
         return result
 
     # Substitute variables with default values
@@ -48,7 +58,7 @@ def envsubst(template_str, env=os.environ):
     return template_str
 
 
-def merge_files_from_directories(directories, file_extension=None):
+def merge_files_from_directories(directories, file_extension=None, on_error: str = 'exit'):
     merged_content = []
 
     for path in directories:
@@ -85,8 +95,11 @@ def merge_files_from_directories(directories, file_extension=None):
     # Strip extra empty lines from the beginning and end
     result = result.strip()
 
-    # Perform environment variable substitution on the final result
-    return envsubst(result)
+    # Define the replacements for '$' to '$$'
+    replacements_map = {"$": "$$"}
+
+    # Perform environment variable substitution on the final result with replacements
+    return base_envsubst(result, replacements=replacements_map, on_error=on_error)
 
 
 def main():

{docker-stack-0.2.3 → docker-stack-0.2.5}/docker_stack.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: docker-stack
-Version: 0.2.3
+Version: 0.2.5
 Summary: CLI for deploying and managing Docker stacks.
-Home-page: https://github.com/mesuidp/docker-stack
+Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai
 Author-email: sudip@bhattarai.me
 Classifier: Programming Language :: Python :: 3

{docker-stack-0.2.3 → docker-stack-0.2.5}/pyproject.toml

@@ -3,3 +3,6 @@ testpaths = [
     "tests", 
 ]
 pythonpath = ["docker_stack", "."]
+
+[tool.black]
+line-length = 140

{docker-stack-0.2.3 → docker-stack-0.2.5}/setup.py

@@ -2,13 +2,13 @@ from setuptools import setup, find_packages
 
 setup(
     name="docker-stack",
-    version="0.2.3",
+    version="0.2.5",
     description="CLI for deploying and managing Docker stacks.",
     long_description=open("README.md").read(),  # You can include a README file to describe your package
     long_description_content_type="text/markdown",
     author="Sudip Bhattarai",
     author_email="sudip@bhattarai.me",
-    url="https://github.com/mesuidp/docker-stack",  # Replace with your project URL
+    url="https://github.com/mesudip/docker-stack",  # Replace with your project URL
     packages=find_packages(),
     install_requires=[
         "PyYAML"

docker-stack-0.2.3/docker_stack/envsubst.py

@@ -1,109 +0,0 @@
-#!/usr/bin/python3
-"""
-NAME
-       envsubst.py - substitutes environment variables in bash format strings
-
-DESCRIPTION
-    envsubst.py is an upgrade of the POSIX command `envsubst`
-
-    supported syntax:
-      normal       - ${VARIABLE1} or $VARIABLE1
-      with default - ${VARIABLE1:-somevalue}
-"""
-
-import os
-import re
-import sys
-
-
-def envsubst(template_str, env=os.environ):
-    """Substitute environment variables in the template string, supporting default values."""
-
-    # Regex for ${VARIABLE} with optional default
-    pattern_with_default = re.compile(r"\$\{([^}:\s]+)(?::-(.*?))?\}")
-
-    # Regex for $VARIABLE without default
-    pattern_without_default = re.compile(r"\$([a-zA-Z_][a-zA-Z0-9_]*)")
-
-    template_str = template_str.replace("$$", "__ESCAPED_DOLLAR__")
-    def print_error_line(template_str, match_span):
-        """Helper function to print the error context."""
-        lines = template_str.splitlines()
-        
-        # Determine the start position and line
-        start_pos = match_span[0]
-        end_pos = match_span[1]
-
-        # Calculate line numbers based on character positions
-        char_count = 0
-        start_line = end_line = None
-        for i, line in enumerate(lines):
-            char_count += len(line) + 1  # +1 for the newline character
-            if start_line is None and char_count > start_pos:
-                start_line = i
-            if char_count >= end_pos:
-                end_line = i
-                break
-        
-        # Display lines before, the error line, and after (with line numbers)
-        start = max(start_line - 1, 0)
-        end = min(end_line + 1, len(lines) - 1)
-
-        for i in range(start, end + 1):
-            print(f"{i + 1}: {lines[i]}",file=sys.stderr)
-
-    def replace_with_default(match: re.Match[str]):
-        var = match.group(1)
-        default_value = match.group(2) if match.group(2) is not None else None
-        result = env.get(var, default_value)
-        if result is None:
-            print_error_line(template_str, match.span())
-            print(f"ERROR :: Missing template variable with default: {var}", file=sys.stderr)
-
-            exit(1)
-        return result
-
-    def replace_without_default(match: re.Match[str]):
-        var = match.group(1)
-        result = env.get(var, None)
-        if result is None:
-            print_error_line(template_str, match.span())
-            print(f"ERROR :: Missing template variable: {var}", file=sys.stderr)
-            exit(1)
-        return result
-
-    # Substitute variables with default values
-    template_str = pattern_with_default.sub(replace_with_default, template_str)
-
-    # Substitute variables without default values
-    template_str = pattern_without_default.sub(replace_without_default, template_str)
-    
-    template_str = template_str.replace("__ESCAPED_DOLLAR__", "$")
-
-    return template_str
-
-
-def envsubst_load_file(template_file,env=os.environ):
-    with open(template_file) as file:
-        return envsubst(file.read(),env)
-
-def main():
-    if len(sys.argv) > 2:
-        print("Usage: python envsubst.py [template_file]")
-        sys.exit(1)
-
-    if len(sys.argv) == 2:
-        template_file = sys.argv[1]
-        with open(template_file, "r") as file:
-            template_str = file.read()
-    else:
-        template_str = sys.stdin.read()
-
-    result = envsubst(template_str)
-
-    print(result)
-
-
-if __name__ == "__main__":
-    main()
-