Fix codestyle issues

Author: aviruthen

src/sagemaker/remote_function/job.py

@@ -1298,32 +1298,32 @@ def _generate_input_data_config(job_settings: _JobSettings, s3_base_uri: str):
 
 def _decrement_version(version_str: str) -> str:
     """Decrement a version string by one minor or patch version.
-    
+
     Rules:
     - If patch version is 0 (e.g., 2.256.0), decrement minor: 2.256.0 -> 2.255.0
     - If patch version is not 0 (e.g., 2.254.2), decrement patch: 2.254.2 -> 2.254.1
-    
+
     Args:
         version_str: Version string (e.g., "2.256.0")
-        
+
     Returns:
         Decremented version string
     """
     from packaging import version as pkg_version
-    
+
     try:
         parsed = pkg_version.parse(version_str)
         major = parsed.major
         minor = parsed.minor
         patch = parsed.micro
-        
+
         if patch == 0:
             # Decrement minor version
             minor = max(0, minor - 1)
         else:
             # Decrement patch version
             patch = max(0, patch - 1)
-        
+
         return f"{major}.{minor}.{patch}"
     except Exception:
         return version_str
@@ -1335,55 +1335,60 @@ def _resolve_version_from_specifier(specifier_str: str) -> str:
     Upper bounds take priority. If upper bound is <3.0.0, it's safe (V2 only).
     If no upper bound exists, it's safe (unbounded).
     If the decremented upper bound is less than a lower bound, use the lower bound.
-    
+
     Args:
         specifier_str: Version specifier string (e.g., ">=2.256.0", "<2.256.0", "==2.255.0")
-        
+
     Returns:
         The resolved version string to check, or None if safe
     """
     import re
     from packaging import version as pkg_version
-    
+
     # Handle exact version pinning (==)
-    match = re.search(r'==\s*([\d.]+)', specifier_str)
+    match = re.search(r"==\s*([\d.]+)", specifier_str)
     if match:
         return match.group(1)
-    
+
     # Extract lower bounds for comparison
     lower_bounds = []
-    for match in re.finditer(r'>=\s*([\d.]+)', specifier_str):
+    for match in re.finditer(r">=\s*([\d.]+)", specifier_str):
         lower_bounds.append(match.group(1))
-    
+
     # Handle upper bounds - find the most restrictive one
     upper_bounds = []
-    
+
     # Find all <= bounds
-    for match in re.finditer(r'<=\s*([\d.]+)', specifier_str):
-        upper_bounds.append(('<=', match.group(1)))
-    
+    for match in re.finditer(r"<=\s*([\d.]+)", specifier_str):
+        upper_bounds.append(("<=", match.group(1)))
+
     # Find all < bounds
-    for match in re.finditer(r'<\s*([\d.]+)', specifier_str):
-        upper_bounds.append(('<', match.group(1)))
-    
+    for match in re.finditer(r"<\s*([\d.]+)", specifier_str):
+        upper_bounds.append(("<", match.group(1)))
+
     if upper_bounds:
         # Sort by version to find the most restrictive (lowest) upper bound
         upper_bounds.sort(key=lambda x: pkg_version.parse(x[1]))
         operator, version = upper_bounds[0]
-        
+
         # Special case: if upper bound is <3.0.0, it's safe (V2 only)
         try:
             parsed_upper = pkg_version.parse(version)
-            if operator == '<' and parsed_upper.major == 3 and parsed_upper.minor == 0 and parsed_upper.micro == 0:
+            if (
+                operator == "<" 
+                and parsed_upper.major == 3 
+                and parsed_upper.minor == 0 
+                and parsed_upper.micro == 0
+            ):
                 # <3.0.0 means V2 only, which is safe
                 return None
         except Exception:
             pass
-        
+
         resolved_version = version
-        if operator == '<':
+        if operator == "<":
             resolved_version = _decrement_version(version)
-        
+
         # If we have a lower bound and the resolved version is less than it, use the lower bound
         if lower_bounds:
             try:
@@ -1394,9 +1399,9 @@ def _resolve_version_from_specifier(specifier_str: str) -> str:
                         resolved_version = lower_bound_str
             except Exception:
                 pass
-        
+
         return resolved_version
-    
+
     # For lower bounds only (>=, >), we don't check
     return None
 
@@ -1415,35 +1420,35 @@ def _check_sagemaker_version_compatibility(sagemaker_requirement: str) -> None:
     """
     import re
     from packaging import version as pkg_version
-    
-    match = re.search(r'sagemaker\s*(.+)$', sagemaker_requirement.strip(), re.IGNORECASE)
+
+    match = re.search(r"sagemaker\s*(.+)$", sagemaker_requirement.strip(), re.IGNORECASE)
     if not match:
         return
 
     specifier_str = match.group(1).strip()
-    
+
     # Resolve the version that would be installed
     resolved_version_str = _resolve_version_from_specifier(specifier_str)
     if not resolved_version_str:
         # No upper bound or exact version, so we can't determine if it's bad
         return
-    
+
     try:
         resolved_version = pkg_version.parse(resolved_version_str)
     except Exception:
         return
-    
+
     # Define HMAC thresholds for each major version
     v2_hmac_threshold = pkg_version.parse("2.256.0")
     v3_hmac_threshold = pkg_version.parse("3.2.0")
-    
+
     # Check if the resolved version uses HMAC hashing
     uses_hmac = False
     if resolved_version.major == 2 and resolved_version < v2_hmac_threshold:
         uses_hmac = True
     elif resolved_version.major == 3 and resolved_version < v3_hmac_threshold:
         uses_hmac = True
-    
+
     if uses_hmac:
         raise ValueError(
             f"The sagemaker version specified in requirements.txt ({sagemaker_requirement}) "
@@ -1453,7 +1458,6 @@ def _check_sagemaker_version_compatibility(sagemaker_requirement: str) -> None:
         )
 
 
-
 def _ensure_sagemaker_dependency(local_dependencies_path: str) -> str:
     """Ensure sagemaker>=2.256.0 is in the dependencies.
 
@@ -1481,13 +1485,14 @@ def _ensure_sagemaker_dependency(local_dependencies_path: str) -> str:
 
     if local_dependencies_path is None:
         # Create a temporary requirements.txt in the system temp directory
-        # This avoids overwriting any user files in their working directory
         fd, req_file = tempfile.mkstemp(suffix=".txt", prefix="sagemaker_requirements_")
-        os.close(fd)  # Close the file descriptor, we'll write to it ourselves
+        os.close(fd)
 
         with open(req_file, "w") as f:
             f.write(f"{SAGEMAKER_MIN_VERSION}\n")
-        logger.info("Created temporary requirements.txt at %s with %s", req_file, SAGEMAKER_MIN_VERSION)
+        logger.info(
+            "Created temporary requirements.txt at %s with %s", req_file, SAGEMAKER_MIN_VERSION
+        )
         return req_file
 
     # If dependencies provided, ensure sagemaker is included
@@ -1498,8 +1503,8 @@ def _ensure_sagemaker_dependency(local_dependencies_path: str) -> str:
         # Check if sagemaker is already specified
         if "sagemaker" in content.lower():
             # Extract the sagemaker requirement line for compatibility check
-            for line in content.split('\n'):
-                if 'sagemaker' in line.lower():
+            for line in content.split("\n"):
+                if "sagemaker" in line.lower():
                     _check_sagemaker_version_compatibility(line.strip())
                     break
         else:

tests/integ/sagemaker/remote_function/test_sagemaker_dependency_injection.py

@@ -11,12 +11,11 @@
 
 # Skip decorator for AWS configuration
 skip_if_no_aws_region = pytest.mark.skipif(
-    not os.environ.get('AWS_DEFAULT_REGION'),
-    reason="AWS credentials not configured"
+    not os.environ.get('AWS_DEFAULT_REGION'), reason="AWS credentials not configured"
 )
 
 # Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../../../src'))
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../../../../src"))
 
 from sagemaker.remote_function import remote
 
@@ -28,22 +27,23 @@ class TestRemoteFunctionDependencyInjection:
     @skip_if_no_aws_region
     def test_remote_function_without_dependencies(self):
         """Test remote function execution without explicit dependencies.
-        
+
         This test verifies that when no dependencies are provided, the remote
         function still executes successfully because sagemaker>=2.256.0 is
         automatically injected.
         """
+
         @remote(
             instance_type="ml.m5.large",
             # No dependencies specified - sagemaker should be injected automatically
         )
         def simple_add(x, y):
             """Simple function that adds two numbers."""
             return x + y
-        
+
         # Execute the function
         result = simple_add(5, 3)
-        
+
         # Verify result
         assert result == 8, f"Expected 8, got {result}"
         print("✓ Remote function without dependencies executed successfully")
@@ -52,15 +52,15 @@ def simple_add(x, y):
     @skip_if_no_aws_region
     def test_remote_function_with_user_dependencies_no_sagemaker(self):
         """Test remote function with user dependencies but no sagemaker.
-        
+
         This test verifies that when user provides dependencies without sagemaker,
         sagemaker>=2.256.0 is automatically appended.
         """
         # Create a temporary requirements.txt without sagemaker
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
             f.write("numpy>=1.20.0\npandas>=1.3.0\n")
             req_file = f.name
-        
+
         try:
             @remote(
                 instance_type="ml.m5.large",
@@ -69,11 +69,12 @@ def test_remote_function_with_user_dependencies_no_sagemaker(self):
             def compute_with_numpy(x):
                 """Function that uses numpy."""
                 import numpy as np
+
                 return np.array([x, x*2, x*3]).sum()
-            
+
             # Execute the function
             result = compute_with_numpy(5)
-            
+
             # Verify result (5 + 10 + 15 = 30)
             assert result == 30, f"Expected 30, got {result}"
             print("✓ Remote function with user dependencies executed successfully")
@@ -88,22 +89,23 @@ class TestRemoteFunctionVersionCompatibility:
     @skip_if_no_aws_region
     def test_deserialization_with_injected_sagemaker(self):
         """Test that deserialization works with injected sagemaker dependency.
-        
+
         This test verifies that the remote environment can properly deserialize
         functions when sagemaker>=2.256.0 is available.
         """
+
         @remote(
             instance_type="ml.m5.large",
         )
         def complex_computation(data):
             """Function that performs complex computation."""
             result = sum(data) * len(data)
             return result
-        
+
         # Execute with various data types
         test_data = [1, 2, 3, 4, 5]
         result = complex_computation(test_data)
-        
+
         # Verify result (sum=15, len=5, 15*5=75)
         assert result == 75, f"Expected 75, got {result}"
         print("✓ Deserialization with injected sagemaker works correctly")
@@ -112,22 +114,23 @@ def complex_computation(data):
     @skip_if_no_aws_region
     def test_multiple_remote_functions_with_dependencies(self):
         """Test multiple remote functions with different dependency configurations.
-        
+
         This test verifies that the dependency injection works correctly
         when multiple remote functions are defined and executed.
         """
+
         @remote(instance_type="ml.m5.large")
         def func1(x):
             return x + 1
-        
+
         @remote(instance_type="ml.m5.large")
         def func2(x):
             return x * 2
-        
+
         # Execute both functions
         result1 = func1(5)
         result2 = func2(5)
-        
+
         assert result1 == 6, f"func1: Expected 6, got {result1}"
         assert result2 == 10, f"func2: Expected 10, got {result2}"
         print("✓ Multiple remote functions with dependencies executed successfully")