utils_devops 0.1.136__py3-none-any.whl → 0.1.138__py3-none-any.whl

utils_devops/extras/docker_ops.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import subprocess
 import json
 import os
+import re
 from logging import Logger
 import re
 import sys
@@ -849,6 +850,32 @@ def health_check_docker_compose(compose_file: str) -> bool:
         logger.error(f"Health check failed: {e}")
         return False
     
+def _compute_overall_status(service_status: Dict[str, Any]) -> str:
+    """Compute overall status from Docker status and health."""
+    if not service_status:
+        return "not found"
+    
+    status = service_status.get('status', 'not found').lower()
+    health = service_status.get('health', 'none').lower()
+    
+    if status == 'restarting':
+        return "restarting"
+    
+    if status in ['created', 'paused']:  # Treat as starting or unhealthy based on context
+        return "starting" if health == 'starting' else "unhealthy"
+    
+    if status != 'running':
+        return "unhealthy"  # exited, dead, etc.
+    
+    if health == 'starting':
+        return "starting"
+    elif health == 'healthy':
+        return "healthy"
+    elif health == 'unhealthy':
+        return "unhealthy"
+    else:
+        return "unhealthy"  # unknown or none
+    
 def check_health_from_compose_ps(compose_file: str) -> Dict[str, Any]:
     """
     Direct health check by parsing docker compose ps --format json
@@ -1254,96 +1281,74 @@ def _check_missing_images(
     
     return missing_services
 
-def _perform_health_checks_with_retries(
+def _perform_health_checks(
     compose_file: str,
     services: List[str],
     timeout: int,
-    retries: int,
     interval: int,
     logger: logger,
     env_file: Optional[str] = None
 ) -> Tuple[bool, Dict[str, Any]]:
-    """Perform health checks with multiple retries and detailed logging."""
+    """Perform health checks in a single phase with total timeout."""
     health_details = {
         "success": False,
-        "attempts": [],
         "service_status": {},
         "final_healthy_count": 0,
         "final_unhealthy_count": 0
     }
-    
-    for attempt in range(1, retries + 1):
-        logger.info(f"🏥 Health check attempt {attempt}/{retries}...")
-        
-        # Use the enhanced wait_for_healthy function
-        health_success = wait_for_healthy(
-            compose_file=compose_file,
-            services=services,
-            timeout=timeout,
-            interval=interval,
-            logger=logger,
-            env_file=env_file
-        )
-        
-        # Get detailed health status for all services
-        detailed_health = _get_detailed_health_status(compose_file, services, logger)
-        
-        attempt_result = {
-            "attempt": attempt,
-            "success": health_success,
-            "timestamp": dt_ops.current_datetime().isoformat(),
-            "service_status": detailed_health
-        }
-        health_details["attempts"].append(attempt_result)
-        
-        healthy_count = sum(1 for status in detailed_health.values() if status.get('healthy', False))
-        unhealthy_count = len(services) - healthy_count
-        
-        logger.info(f"   Healthy: {healthy_count}/{len(services)}, Unhealthy: {unhealthy_count}")
-        
-        if health_success:
-            health_details["success"] = True
-            health_details["service_status"] = detailed_health
-            health_details["final_healthy_count"] = healthy_count
-            health_details["final_unhealthy_count"] = unhealthy_count
-            return True, health_details
-        
-        # Wait before retry (except on last attempt)
-        if attempt < retries:
-            retry_interval = interval * 2  # Exponential backoff
-            logger.info(f"⏳ Waiting {retry_interval}s before retry...")
-            dt_ops.time.sleep(retry_interval)
-    
-    # All retries failed
-    health_details["success"] = False
+   
+    logger.info(f"🏥 Performing health check (timeout: {timeout}s, interval: {interval}s)...")
+   
+    # Use the enhanced wait_for_healthy function
+    health_success = wait_for_healthy(
+        compose_file=compose_file,
+        services=services,
+        timeout=timeout,
+        interval=interval,
+        logger=logger,
+        env_file=env_file
+    )
+   
+    # Get detailed health status for all services
+    detailed_health = _get_detailed_health_status(compose_file, services, logger)
+   
+    healthy_count = sum(1 for status in detailed_health.values() if status.get('overall_status') == 'healthy')
+    unhealthy_count = len(services) - healthy_count
+   
+    logger.info(f"   Healthy: {healthy_count}/{len(services)}, Unhealthy: {unhealthy_count}")
+   
+    health_details["success"] = health_success
     health_details["service_status"] = detailed_health
     health_details["final_healthy_count"] = healthy_count
     health_details["final_unhealthy_count"] = unhealthy_count
-    
-    return False, health_details
+   
+    return health_success, health_details
 
 def _get_detailed_health_status(
     compose_file: str,
     services: List[str],
     logger: logger
 ) -> Dict[str, Dict[str, Any]]:
-    """Get detailed health status for each service."""
+    """Get detailed health status for each service with overall_status."""
     detailed_status = {}
-    
+   
     try:
         # Use the reliable JSON parsing method
         health_result = check_health_from_compose_ps(compose_file)
         all_services_status = health_result.get('services', {})
-        
+       
         for service in services:
             service_status = all_services_status.get(service, {})
+            overall_status = _compute_overall_status(service_status)
             detailed_status[service] = {
-                'healthy': service_status.get('healthy', False),
+                'healthy': overall_status == 'healthy',
                 'health': service_status.get('health', 'unknown'),
                 'status': service_status.get('status', 'not found'),
-                'error': service_status.get('error', 'No error details')
+                'error': service_status.get('error', 'No error details'),
+                'overall_status': overall_status
             }
-            
+            logger.info(f"   {service}: {overall_status}")
+           
     except Exception as e:
         logger.error(f"Failed to get detailed health status: {e}")
         # Fallback: mark all as unhealthy
@@ -1352,13 +1357,12 @@ def _get_detailed_health_status(
                 'healthy': False,
                 'health': 'unknown',
                 'status': 'check failed',
-                'error': str(e)
+                'error': str(e),
+                'overall_status': 'unhealthy'
             }
-    
+   
     return detailed_status
 
-import os
-import re
 
 def _expand_env_vars_in_value(value):
     """Expand environment variables in a string value."""
@@ -2135,49 +2139,55 @@ def test_compose(
     env_file: str = '.env',
     update_version: bool = False,
     version_source: str = 'git',
-    
+   
     # Test configuration
     services: Optional[List[str]] = None,
-    health_timeout: int = 510,
-    health_retries: int = 5,
+    health_timeout: int = 500,  # Changed to represent total max wait time (e.g., 500 seconds)
     health_interval: int = 10,
     capture_logs: bool = True,
     log_tail: int = 100,
-    
+   
     # Startup options
     pull_missing: bool = True,
     no_build: bool = True,
     no_pull: bool = True,
-    
+   
     # Cleanup options
-    keep_compose_up: bool = False, 
-    
+    keep_compose_up: bool = False,
+   
     # Additional options
     project_name: Optional[str] = None,
     dry_run: bool = False,
     logger: Optional[logger] = None
-    
+   
 ) -> Dict[str, Any]:
     """
     Test Docker Compose services with comprehensive health checks and logging.
-    
+   
+    Improvements:
+    - If compose up fails, capture error and skip health checks.
+    - Enhanced conflict checking: Detailed info for no conflicts, shows conflicts if found, and automatically resolves them (containers and networks; volumes skipped to avoid data loss).
+    - Health statuses expanded to: not found, starting, restarting, healthy, unhealthy.
+    - Simplified health checking: Removed outer retries, now uses a single total health_timeout (e.g., 500s) with checks every health_interval.
+    - Other upgrades: Better error handling around compose_up, more detailed logging, implemented port conflict resolution by removing conflicting containers.
+   
     Steps:
     0. Pre-Test validation
     1. Update version (if enabled)
-    2. Check for conflicts
+    2. Check for conflicts and resolve if found
     3. Start services with --no-build and --no-pull
-    4. Perform health checks with retries
+    4. Perform health checks (single phase with total timeout)
     5. Capture detailed logs for failing services
     6. Bring down services (unless keep_compose_up=True)
-    
+   
     Args:
         keep_compose_up: If True, services will not be stopped after test. Default: False.
-    
+   
     Returns: Detailed test results with logs
     """
     logger = logger or DEFAULT_LOGGER
     test_id = str(uuid.uuid4())[:8]
-    
+   
     result = {
         "test_id": test_id,
         "success": False,
@@ -2186,28 +2196,28 @@ def test_compose(
         "health_status": {},
         "failing_services": [],
         "logs_captured": {},
-        "keep_compose_up": keep_compose_up,  # <-- Track this in result
+        "keep_compose_up": keep_compose_up,
         "error": None,
         "duration": 0.0
     }
-    
+   
     start_time = dt_ops.current_datetime()
-    
+   
     try:
         logger.info(f"🧪 Starting test {test_id}")
-        logger.info(f"   Compose: {compose_file}")
-        logger.info(f"   Health timeout: {health_timeout}s, retries: {health_retries}")
-        logger.info(f"   Keep services after test: {keep_compose_up}")  # <-- Log the flag
-        
-        
+        logger.info(f" Compose: {compose_file}")
+        logger.info(f" Health timeout: {health_timeout}s, interval: {health_interval}s")
+        logger.info(f" Keep services after test: {keep_compose_up}")
+       
+       
         # Step 0: Pre-build validation
-        logger.info("📋 Step 1: Validating configuration...")
+        logger.info("📋 Step 0: Validating configuration...")
         if not files.file_exists(compose_file):
             raise DockerOpsError(f"Compose file not found: {compose_file}")
-        
+       
         if not files.file_exists(env_file):
             logger.warning(f"Environment file not found: {env_file}")
-            
+           
         # Step 1: Update version (optional)
         new_version = None
         if update_version and not dry_run:
@@ -2224,26 +2234,41 @@ def test_compose(
             logger.info("🔧 Step 1: Version update skipped (dry run)")
         else:
             logger.info("🔧 Step 1: Version update disabled")
-        
+       
         # Step 2: Check for conflicts
         logger.info("🔍 Step 2: Checking for conflicts...")
+        result["steps"]["conflict_check"] = {"status": "no_conflicts", "conflicts": None}
         if not dry_run:
             conflicts = check_conflicts(compose_file, project_name=project_name, env_file=env_file)
-            if conflicts:
+            if any(conflicts.values()):  # Check if any conflict lists are non-empty
                 logger.warning(f"⚠️ Found conflicts: {conflicts}")
                 result["steps"]["conflict_check"] = {
                     "status": "conflicts_found",
                     "conflicts": conflicts
                 }
-                # Try to resolve conflicts automatically
-                resolve_conflicts(compose_file, project_name=project_name,env_file=env_file)
-                logger.info("✅ Conflicts resolved")
+                # Resolve conflicts (auto-remove containers and networks; skip volumes)
+                resolution = resolve_conflicts(
+                    compose_file,
+                    remove_conflicting_containers=True,
+                    remove_conflicting_networks=True,
+                    remove_conflicting_volumes=False,
+                    project_name=project_name,
+                    env_file=env_file
+                )
+                if resolution["resolved"]:
+                    logger.info(f"✅ Resolved conflicts: {resolution['resolved']}")
+                    result["steps"]["conflict_resolution"] = {
+                        "status": "resolved",
+                        "resolved": resolution["resolved"],
+                        "errors": resolution["errors"]
+                    }
+                if resolution["errors"]:
+                    raise DockerOpsError(f"Failed to resolve some conflicts: {resolution['errors']}")
             else:
                 logger.info("✅ No conflicts found")
-                result["steps"]["conflict_check"] = {"status": "no_conflicts"}
         else:
             logger.info("🔍 Step 2: Conflict check skipped (dry run)")
-        
+       
         # Step 3: Start services
         logger.info("🚀 Step 3: Starting services...")
         if not dry_run:
@@ -2251,16 +2276,16 @@ def test_compose(
             compose_config = read_compose_file(compose_file, env_file)
             available_services = list(compose_config.get('services', {}).keys())
             target_services = services or available_services
-            
+           
             # Check for missing images
             missing_images = _check_missing_images(
-                compose_file, 
-                target_services, 
-                project_name, 
+                compose_file,
+                target_services,
+                project_name,
                 logger,
                 env_file
             )
-            
+           
             if missing_images and pull_missing:
                 logger.info(f"⬇️ Pulling {len(missing_images)} missing images...")
                 for service in missing_images:
@@ -2270,25 +2295,34 @@ def test_compose(
                     except Exception as e:
                         logger.error(f"❌ Failed to pull image for {service}: {e}")
                         raise DockerOpsError(f"Missing image for {service} and pull failed")
-            
+           
             elif missing_images and not pull_missing:
                 missing_list = ", ".join(missing_images)
                 raise DockerOpsError(f"Missing images for services: {missing_list}")
-            
+           
             # Start services with no-build and no-pull
             up_options = []
             if no_build:
                 up_options.append("--no-build")
             if no_pull:
                 up_options.append("--no-pull")
-                
+               
             logger.info(f"Starting services with options: {up_options}")
-            up_result = compose_up(
-                compose_file, 
-                services=services,
-                project_name=project_name,
-            )
-            
+            try:
+                up_result = compose_up(
+                    compose_file,
+                    services=services,
+                    project_name=project_name,
+                )
+                # Assuming compose_up returns a dict with 'success'; adjust if needed
+                if up_result is not True:  # If it doesn't raise, check result
+                    raise DockerOpsError(f"Compose up failed: {up_result.get('error', 'Unknown error')}")
+            except Exception as e:
+                result["error"] = str(e)
+                logger.error(f"❌ Compose up failed: {e}")
+                result["steps"]["start_services"] = {"success": False, "error": str(e)}
+                raise  # Re-raise to skip health checks and go to cleanup
+           
             result["steps"]["start_services"] = {
                 "success": True,
                 "services_started": target_services,
@@ -2303,37 +2337,36 @@ def test_compose(
             target_services = services or available_services
             result["services_tested"] = target_services
             logger.info("🚀 Step 3: Service start skipped (dry run)")
-        
-        # Step 4: Health checks with retries
+       
+        # Step 4: Health checks (single phase with total timeout)
         if not dry_run:
             logger.info("🏥 Step 4: Performing health checks...")
-            health_success, health_details = _perform_health_checks_with_retries(
+            health_success, health_details = _perform_health_checks(
                 compose_file=compose_file,
                 services=target_services,
                 timeout=health_timeout,
-                retries=health_retries,
                 interval=health_interval,
                 logger=logger,
                 env_file=env_file
             )
-            
+           
             result["steps"]["health_check"] = health_details
             result["health_status"] = health_details.get("service_status", {})
-            
-            # Identify failing services
+           
+            # Identify failing services (any not 'healthy')
             failing_services = [
                 svc for svc, status in health_details.get("service_status", {}).items()
-                if not status.get("healthy", False)
+                if status.get("overall_status") != "healthy"
             ]
             result["failing_services"] = failing_services
-            
+           
             if health_success:
                 logger.info("✅ All services healthy!")
                 result["success"] = True
             else:
                 logger.error(f"❌ Health checks failed for {len(failing_services)} services: {failing_services}")
                 result["success"] = False
-                
+               
                 # Step 5: Capture detailed logs for failing services
                 if capture_logs and failing_services:
                     logger.info("📋 Step 5: Capturing logs for failing services...")
@@ -2349,19 +2382,19 @@ def test_compose(
                         "status": "captured",
                         "services": list(logs.keys())
                     }
-                    
+                   
                     # Log the most critical errors
                     for service, log_data in logs.items():
                         if log_data.get('error_logs'):
                             logger.error(f"🔴 {service} error logs (last {log_tail} lines):")
-                            for line in log_data['error_logs'][-10:]:  # Last 10 error lines
-                                logger.error(f"   {line}")
+                            for line in log_data['error_logs'][-10:]:
+                                logger.error(f" {line}")
         else:
             logger.info("🏥 Step 4: Health checks skipped (dry run)")
             result["success"] = True  # Assume success in dry run
-        
+       
         # Step 6: Bring down services (unless keep_compose_up=True)
-        if not dry_run and not keep_compose_up:  # <-- Condition changed
+        if not dry_run and not keep_compose_up:
             logger.info("🛑 Step 6: Stopping services...")
             try:
                 down_result = compose_down(compose_file, project_name=project_name)
@@ -2375,10 +2408,10 @@ def test_compose(
             result["steps"]["cleanup"] = {"status": "skipped", "reason": "keep_compose_up=True"}
         elif dry_run:
             logger.info("🛑 Step 6: Service cleanup skipped (dry run)")
-        
+       
         # Calculate duration
         result["duration"] = (dt_ops.current_datetime() - start_time).total_seconds()
-        
+       
         if result["success"]:
             if keep_compose_up:
                 logger.info(f"🎉 Test {test_id} completed successfully in {result['duration']:.1f}s! Services kept running.")
@@ -2386,18 +2419,18 @@ def test_compose(
                 logger.info(f"🎉 Test {test_id} completed successfully in {result['duration']:.1f}s!")
         else:
             logger.error(f"💥 Test {test_id} failed in {result['duration']:.1f}s!")
-        
+       
         return result
-        
+       
     except Exception as e:
         # Failure handling
         result["duration"] = (dt_ops.current_datetime() - start_time).total_seconds()
         result["error"] = str(e)
-        
+       
         logger.error(f"💥 Test {test_id} failed: {e}")
-        
+       
         # Only try to cleanup on failure if keep_compose_up=False
-        if not dry_run and not keep_compose_up:  # <-- Condition changed
+        if not dry_run and not keep_compose_up:
             try:
                 logger.info("🛑 Emergency cleanup...")
                 compose_down(compose_file, project_name=project_name)
@@ -2405,7 +2438,7 @@ def test_compose(
             except Exception as cleanup_error:
                 logger.error(f"💥 Emergency cleanup failed: {cleanup_error}")
                 result["steps"]["emergency_cleanup"] = {"status": "failed", "error": str(cleanup_error)}
-        
+       
         return result
     
 def build_compose(
@@ -4139,12 +4172,16 @@ def check_conflicts(
     return conflicts
 
 def _get_used_ports(containers: List[ContainerInfo]) -> Dict[int, str]:
-    """Get used host ports from containers"""
+    """Get used host ports from containers with conflicting container IDs."""
     used_ports = {}
     for container in containers:
-        # This would require container inspection to get port mappings
-        # Simplified version - we'd need to inspect each container
-        pass
+        # Assuming ContainerInfo has ports as dict like {'80/tcp': [{'HostPort': '80'}]}
+        for container_port, host_bindings in container.ports.items():
+            if host_bindings:
+                for binding in host_bindings:
+                    host_port = int(binding.get('HostPort', 0))
+                    if host_port:
+                        used_ports[host_port] = container.id  # Use container ID
     return used_ports
 
 def _extract_host_port(port_mapping: Union[str, Dict]) -> Optional[int]:
@@ -4174,33 +4211,22 @@ def resolve_conflicts(
 ) -> Dict[str, Any]:
     """
     Detect and resolve conflicts for compose deployment.
-    
-    Args:
-        compose_file: Compose file to check
-        remove_conflicting_containers: Remove conflicting containers
-        remove_conflicting_networks: Remove conflicting networks (non-external only)
-        remove_conflicting_volumes: Remove conflicting volumes (non-external only)
-        force: Force removal without confirmation
-        project_name: Project name
-        
-    Returns:
-        Resolution results
     """
     conflicts = check_conflicts(
-        compose_file, 
+        compose_file,
         project_name=project_name,
         env_file=env_file,
         check_volumes=remove_conflicting_volumes
     )
-    
+   
     resolution = {
         "conflicts_found": conflicts,
         "resolved": [],
         "errors": [],
         "skipped_external": []
     }
-    
-    # Resolve container conflicts
+   
+    # Resolve container conflicts (by name)
     for conflict in conflicts.get("container_conflicts", []):
         container_id = conflict["conflicting_container"]
         try:
@@ -4211,45 +4237,55 @@ def resolve_conflicts(
                     resolution["errors"].append(f"Failed to remove container {container_id}")
         except Exception as e:
             resolution["errors"].append(str(e))
-    
+   
+    # Resolve port conflicts (by removing conflicting containers)
+    for conflict in conflicts.get("port_conflicts", []):
+        container_id = conflict["conflicting_container"]
+        try:
+            if remove_conflicting_containers:
+                if container_remove(container_id, force=force):
+                    resolution["resolved"].append(f"port_conflict_container:{container_id}")
+                else:
+                    resolution["errors"].append(f"Failed to remove container {container_id} for port conflict")
+        except Exception as e:
+            resolution["errors"].append(str(e))
+   
     # Resolve network conflicts (only non-external)
     for conflict in conflicts.get("network_conflicts", []):
         network_name = conflict["network"]
         is_external = conflict.get("external", False)
-        
+       
         if is_external:
             resolution["skipped_external"].append(f"network:{network_name}")
             continue
-            
+           
         try:
             if remove_conflicting_networks:
-                # You'll need a function to remove networks
                 if network_remove(network_name):
                     resolution["resolved"].append(f"network:{network_name}")
                 else:
                     resolution["errors"].append(f"Failed to remove network {network_name}")
         except Exception as e:
             resolution["errors"].append(str(e))
-    
+   
     # Resolve volume conflicts (only non-external)
     for conflict in conflicts.get("volume_conflicts", []):
         volume_name = conflict["volume"]
         is_external = conflict.get("external", False)
-        
+       
         if is_external:
             resolution["skipped_external"].append(f"volume:{volume_name}")
             continue
-            
+           
         try:
             if remove_conflicting_volumes:
-                # You'll need a function to remove volumes
                 if volume_remove(volume_name):
                     resolution["resolved"].append(f"volume:{volume_name}")
                 else:
                     resolution["errors"].append(f"Failed to remove volume {volume_name}")
         except Exception as e:
             resolution["errors"].append(str(e))
-    
+   
     return resolution
 
 # ==================== COMPOSE ENHANCEMENTS ====================

{utils_devops-0.1.136.dist-info → utils_devops-0.1.138.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utils_devops
-Version: 0.1.136
+Version: 0.1.138
 Summary: Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools
 License: MIT
 Keywords: devops,automation,nginx,cli,jinja2,yaml,config,diff,templating,logging,docker,compose,file-ops

{utils_devops-0.1.136.dist-info → utils_devops-0.1.138.dist-info}/RECORD

@@ -9,7 +9,7 @@ utils_devops/core/strings.py,sha256=8s0GSjcyTKwLjJjsJ_XfOJxPtyb549icDlU9SUxSvHI,
 utils_devops/core/systems.py,sha256=wNbEFUAvbMPdqWN-iXvTzvj5iE9xaWfjZYYvD0EZAH0,47577
 utils_devops/extras/__init__.py,sha256=ZXHeVLHO3_qiW9AY-UQ_YA9cQzmkLGv54a2UbyvtlM0,3571
 utils_devops/extras/aws_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-utils_devops/extras/docker_ops.py,sha256=7941chrSL1OnbvQCOM9Uz7TRtalKDPs4yNFkPre3YUA,175029
+utils_devops/extras/docker_ops.py,sha256=kfu8o_7S7KzAJRTgf-IlD4JjMFcAdUFfNFklvd5EJmY,177429
 utils_devops/extras/git_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils_devops/extras/interaction_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils_devops/extras/metrics_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,7 +19,7 @@ utils_devops/extras/notification_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 utils_devops/extras/performance_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utils_devops/extras/ssh_ops.py,sha256=8I_AF0q76CJOK2qp68w1oro2SVOZ_v7b8OvgDYcE4tg,73741
 utils_devops/extras/vault_ops.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-utils_devops-0.1.136.dist-info/METADATA,sha256=BVHNdxH50ZdVlV5w2uN21e_klGqdvwg168g7fWVnh90,1903
-utils_devops-0.1.136.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-utils_devops-0.1.136.dist-info/entry_points.txt,sha256=ei3B6ZL5yu6dOq-U1r8wsBdkXeg63RAyV7m8_ADaE6k,53
-utils_devops-0.1.136.dist-info/RECORD,,
+utils_devops-0.1.138.dist-info/METADATA,sha256=slzjWVVCU_ZM9LWcLfAIY7bdLCNtjYtGFRkTEzIzwWs,1903
+utils_devops-0.1.138.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+utils_devops-0.1.138.dist-info/entry_points.txt,sha256=ei3B6ZL5yu6dOq-U1r8wsBdkXeg63RAyV7m8_ADaE6k,53
+utils_devops-0.1.138.dist-info/RECORD,,