fix: forward __delattr__ on the lazy JumpStart session proxy

_LazyJumpStartSagemakerSession declares __slots__ = () and forwards
__getattr__/__setattr__ but not __delattr__. mock.patch reads the
original via target.__dict__[name], which the proxy forwards to the real
session's instance __dict__; for a class-level attribute such as
Session.read_s3_file that raises KeyError, so mock records
is_local=False and restores the attribute by calling delattr on teardown.

Without __delattr__ that teardown raises
  AttributeError: '_LazyJumpStartSagemakerSession' object has no attribute ...
and leaves the mock installed on the process-wide session, so unrelated
tests in the same xdist worker then see the mock instead of the real
attribute. That is what made test_notebook_utils, test_model,
test_sagemaker_config and test_js_builder fail on py39-py312.

Forwarding __delattr__ removes the shadowing instance attribute created
by patch's setattr, which makes the class-level attribute visible again.
__slots__ is kept: dropping it does not fix this, because target.__dict__
would then resolve to the proxy's own empty dict and mock would still take
the delattr branch.

Adds two regression tests covering the class-level path (the defect) and
the instance-level path (is_local=True, restored via setattr).

Author: Mohamed Zeidan

src/sagemaker/jumpstart/constants.py

@@ -236,6 +236,16 @@ def __getattr__(self, name):
     def __setattr__(self, name, value):
         setattr(type(self)._resolve(), name, value)
 
+    def __delattr__(self, name):
+        # Forwarded so that ``unittest.mock.patch`` tears down cleanly. For a
+        # class-level attribute mock records ``is_local=False``, sets the mock
+        # via ``__setattr__`` (creating an instance attribute on the real
+        # session) and restores by calling ``delattr``. Without this method the
+        # teardown raises ``AttributeError`` and leaves the mock installed on
+        # the process-wide session.
+        delattr(type(self)._resolve(), name)
+
+
     def __copy__(self):
         return copy.copy(type(self)._resolve())
 

tests/unit/sagemaker/jumpstart/test_constants.py

@@ -84,3 +84,49 @@ def test_failed_build_degrades_to_none_contract():
         assert _LazyJumpStartSagemakerSession._resolve() is None
         with pytest.raises(AttributeError):
             _ = constants.DEFAULT_JUMPSTART_SAGEMAKER_SESSION.boto_region_name
+
+
+def test_mock_patch_of_class_level_attribute_tears_down_cleanly():
+    """``mock.patch`` on a class-level session method must restore the original and
+    leave nothing behind on the process-wide session.
+
+    mock records ``is_local=False`` for a class-level attribute (it is absent from
+    the instance ``__dict__``) and restores it by calling ``delattr``, so the proxy
+    must forward ``__delattr__``. Without that forwarding the teardown raises
+    ``AttributeError`` and the mock leaks into every later test in the same worker.
+    """
+
+    class FakeSession:
+        """Stands in for ``Session``: ``read_s3_file`` is a class-level attribute."""
+
+        def read_s3_file(self):
+            return "real"
+
+    fake = FakeSession()
+    with patch.object(constants, "Session", return_value=fake):
+        proxy = constants.DEFAULT_JUMPSTART_SAGEMAKER_SESSION
+        assert proxy.read_s3_file() == "real"
+
+        with patch.object(proxy, "read_s3_file", return_value="mocked"):
+            assert proxy.read_s3_file() == "mocked"
+
+        # Teardown must restore the class method and leave no shadowing instance
+        # attribute behind on the shared session.
+        assert proxy.read_s3_file() == "real"
+        assert "read_s3_file" not in fake.__dict__
+
+
+def test_mock_patch_of_instance_level_attribute_tears_down_cleanly():
+    """The instance-attribute path (``is_local=True``, restored via ``setattr``)
+    must keep working -- guards against a regression in ``__setattr__`` forwarding."""
+
+    class FakeSession:
+        def __init__(self):
+            self.sagemaker_client = "real-client"
+
+    fake = FakeSession()
+    with patch.object(constants, "Session", return_value=fake):
+        proxy = constants.DEFAULT_JUMPSTART_SAGEMAKER_SESSION
+        with patch.object(proxy, "sagemaker_client", "mock-client"):
+            assert proxy.sagemaker_client == "mock-client"
+        assert proxy.sagemaker_client == "real-client"