Fix: test_token_counter_lazy_imports

tests/test_litellm/test_lazy_imports.py

@@ -42,34 +42,45 @@ from litellm._lazy_imports import (
 
 def _clear_names_from_globals(names: tuple):
     """Clear all names from litellm globals."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
     for name in names:
-        if name in litellm.__dict__:
-            del litellm.__dict__[name]
+        if name in litellm_globals:
+            del litellm_globals[name]
 
 
 def _clear_names_from_utils_globals(names: tuple):
     """Clear all names from litellm.utils globals."""
+    # Get the actual globals dict, not a copy
+    utils_globals = sys.modules["litellm.utils"].__dict__
     for name in names:
-        if name in litellm.utils.__dict__:
-            del litellm.utils.__dict__[name]
+        if name in utils_globals:
+            del utils_globals[name]
 
 
 def _verify_only_requested_name_imported(name: str, all_names: tuple):
     """Verify that only the requested name is in globals, not the others."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
     for other_name in all_names:
         if other_name != name:
-            assert other_name not in litellm.__dict__, f"{other_name} should not be imported when importing {name}"
+            assert other_name not in litellm_globals, f"{other_name} should not be imported when importing {name}"
 
 
 def _verify_only_requested_name_imported_in_utils(name: str, all_names: tuple):
     """Verify that only the requested name is in utils globals, not the others."""
+    # Get the actual globals dict, not a copy
+    utils_globals = sys.modules["litellm.utils"].__dict__
     for other_name in all_names:
         if other_name != name:
-            assert other_name not in litellm.utils.__dict__, f"{other_name} should not be imported when importing {name}"
+            assert other_name not in utils_globals, f"{other_name} should not be imported when importing {name}"
 
 
 def test_cost_calculator_lazy_imports():
     """Test that all cost calculator functions can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     # Test each name individually - only that name should be imported
     for name in COST_CALCULATOR_NAMES:
         # Clear all names before importing just one
@@ -78,7 +89,7 @@ def test_cost_calculator_lazy_imports():
         func = _lazy_import_cost_calculator(name)
         assert func is not None
         assert callable(func)
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         
         # Verify only the requested name is in globals, not the others
         _verify_only_requested_name_imported(name, COST_CALCULATOR_NAMES)
@@ -86,6 +97,9 @@ def test_cost_calculator_lazy_imports():
 
 def test_litellm_logging_lazy_imports():
     """Test that all litellm_logging items can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     # Test each name individually - only that name should be imported
     for name in LITELLM_LOGGING_NAMES:
         # Clear all names before importing just one
@@ -93,7 +107,7 @@ def test_litellm_logging_lazy_imports():
         
         item = _lazy_import_litellm_logging(name)
         assert item is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         
         # Verify only the requested name is in globals, not the others
         _verify_only_requested_name_imported(name, LITELLM_LOGGING_NAMES)
@@ -101,6 +115,9 @@ def test_litellm_logging_lazy_imports():
 
 def test_utils_lazy_imports():
     """Test that all utils functions can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     # Test each name individually - only that name should be imported
     for name in UTILS_NAMES:
         # Clear all names before importing just one
@@ -108,7 +125,7 @@ def test_utils_lazy_imports():
         
         attr = _lazy_import_utils(name)
         assert attr is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         
         # Verify only the requested name is in globals, not the others
         _verify_only_requested_name_imported(name, UTILS_NAMES)
@@ -116,6 +133,9 @@ def test_utils_lazy_imports():
 
 def test_caching_lazy_imports():
     """Test that all caching classes can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     # Test each name individually - only that name should be imported
     for name in CACHING_NAMES:
         # Clear all names before importing just one
@@ -123,7 +143,7 @@ def test_caching_lazy_imports():
         
         cls = _lazy_import_caching(name)
         assert cls is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         
         # Verify only the requested name is in globals, not the others
         _verify_only_requested_name_imported(name, CACHING_NAMES)
@@ -131,71 +151,89 @@ def test_caching_lazy_imports():
 
 def test_token_counter_lazy_imports():
     """Test that token counter utilities can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in TOKEN_COUNTER_NAMES:
         _clear_names_from_globals(TOKEN_COUNTER_NAMES)
 
         func = _lazy_import_token_counter(name)
         assert func is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, TOKEN_COUNTER_NAMES)
 
 
 def test_bedrock_types_lazy_imports():
     """Test that Bedrock type aliases can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in BEDROCK_TYPES_NAMES:
         _clear_names_from_globals(BEDROCK_TYPES_NAMES)
 
         alias = _lazy_import_bedrock_types(name)
         assert alias is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, BEDROCK_TYPES_NAMES)
 
 
 def test_types_utils_lazy_imports():
     """Test that common types.utils symbols can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in TYPES_UTILS_NAMES:
         _clear_names_from_globals(TYPES_UTILS_NAMES)
 
         obj = _lazy_import_types_utils(name)
         assert obj is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, TYPES_UTILS_NAMES)
 
 
 def test_llm_client_cache_lazy_imports():
     """Test that LLM client cache class and singleton can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in LLM_CLIENT_CACHE_NAMES:
         _clear_names_from_globals(LLM_CLIENT_CACHE_NAMES)
 
         obj = _lazy_import_llm_client_cache(name)
         assert obj is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, LLM_CLIENT_CACHE_NAMES)
 
 
 def test_http_handler_lazy_imports():
     """Test that HTTP handler singletons can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in HTTP_HANDLER_NAMES:
         _clear_names_from_globals(HTTP_HANDLER_NAMES)
 
         handler = _lazy_import_http_handlers(name)
         assert handler is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, HTTP_HANDLER_NAMES)
 
 
 def test_dotprompt_lazy_imports():
     """Test that dotprompt globals can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in DOTPROMPT_NAMES:
         _clear_names_from_globals(DOTPROMPT_NAMES)
 
         obj = _lazy_import_dotprompt(name)
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         # Only the setter must be callable; others may be None by default
         if name == "set_global_prompt_directory":
@@ -245,12 +283,15 @@ def test_unknown_attribute_raises_error():
 
 def test_llm_config_lazy_imports():
     """Test that LLM config classes can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in LLM_CONFIG_NAMES:
         _clear_names_from_globals(LLM_CONFIG_NAMES)
 
         obj = _lazy_import_llm_configs(name)
         assert obj is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         # Config classes should be classes/types
         assert isinstance(obj, type), f"{name} should be a class"
 
@@ -259,12 +300,15 @@ def test_llm_config_lazy_imports():
 
 def test_types_lazy_imports():
     """Test that type classes can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in TYPES_NAMES:
         _clear_names_from_globals(TYPES_NAMES)
 
         obj = _lazy_import_types(name)
         assert obj is not None
-        assert name in litellm.__dict__
+        assert name in litellm_globals
         # Type classes should be classes/types
         assert isinstance(obj, type), f"{name} should be a class"
 
@@ -273,25 +317,31 @@ def test_types_lazy_imports():
 
 def test_llm_provider_logic_lazy_imports():
     """Test that LLM provider logic functions can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    litellm_globals = sys.modules["litellm"].__dict__
+    
     for name in LLM_PROVIDER_LOGIC_NAMES:
         _clear_names_from_globals(LLM_PROVIDER_LOGIC_NAMES)
 
         func = _lazy_import_llm_provider_logic(name)
         assert func is not None
         assert callable(func)
-        assert name in litellm.__dict__
+        assert name in litellm_globals
 
         _verify_only_requested_name_imported(name, LLM_PROVIDER_LOGIC_NAMES)
 
 
 def test_utils_module_lazy_imports():
     """Test that utils module attributes can be lazy imported."""
+    # Get the actual globals dict, not a copy
+    utils_globals = sys.modules["litellm.utils"].__dict__
+    
     for name in UTILS_MODULE_NAMES:
         _clear_names_from_utils_globals(UTILS_MODULE_NAMES)
 
         obj = _lazy_import_utils_module(name)
         assert obj is not None
-        assert name in litellm.utils.__dict__
+        assert name in utils_globals
 
         _verify_only_requested_name_imported_in_utils(name, UTILS_MODULE_NAMES)