improve mypy warnings and update package ranges

Author: tylerhutcherson

langgraph/checkpoint/redis/__init__.py

@@ -280,7 +280,7 @@ def put(
         # store at top-level for filters in list()
         if all(key in metadata for key in ["source", "step"]):
             checkpoint_data["source"] = metadata["source"]
-            checkpoint_data["step"] = metadata["step"]  # type: ignore
+            checkpoint_data["step"] = metadata["step"]
 
         # Create the checkpoint key
         checkpoint_key = BaseRedisSaver._make_redis_checkpoint_key(

langgraph/checkpoint/redis/aio.py

@@ -568,7 +568,7 @@ async def aput(
             # store at top-level for filters in list()
             if all(key in metadata for key in ["source", "step"]):
                 checkpoint_data["source"] = metadata["source"]
-                checkpoint_data["step"] = metadata["step"]  # type: ignore
+                checkpoint_data["step"] = metadata["step"]
 
             # Prepare checkpoint key
             checkpoint_key = BaseRedisSaver._make_redis_checkpoint_key(

langgraph/checkpoint/redis/base.py

@@ -383,7 +383,7 @@ def _dump_metadata(self, metadata: CheckpointMetadata) -> str:
         # NOTE: we're using JSON serializer (not msgpack), so we need to remove null characters before writing
         return serialized_metadata.decode().replace("\\u0000", "")
 
-    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
+    def get_next_version(self, current: Optional[str], channel: None = None) -> str:
         """Generate next version number."""
         if current is None:
             current_v = 0

langgraph/store/redis/__init__.py

@@ -578,16 +578,14 @@ def _batch_search_ops(
                         if self.cluster_mode:
                             for key in refresh_keys:
                                 ttl = self._redis.ttl(key)
-                                if ttl > 0:  # type: ignore
+                                if ttl > 0:
                                     self._redis.expire(key, ttl_seconds)
                         else:
                             pipeline = self._redis.pipeline(transaction=True)
                             for key in refresh_keys:
                                 # Only refresh TTL if the key exists and has a TTL
                                 ttl = self._redis.ttl(key)
-                                if (
-                                    ttl > 0
-                                ):  # Only refresh if key exists and has TTL  # type: ignore
+                                if ttl > 0:  # Only refresh if key exists and has TTL
                                     pipeline.expire(key, ttl_seconds)
                             if pipeline.command_stack:
                                 pipeline.execute()
@@ -645,16 +643,14 @@ def _batch_search_ops(
                         if self.cluster_mode:
                             for key in refresh_keys:
                                 ttl = self._redis.ttl(key)
-                                if ttl > 0:  # type: ignore
+                                if ttl > 0:
                                     self._redis.expire(key, ttl_seconds)
                         else:
                             pipeline = self._redis.pipeline(transaction=True)
                             for key in refresh_keys:
                                 # Only refresh TTL if the key exists and has a TTL
                                 ttl = self._redis.ttl(key)
-                                if (
-                                    ttl > 0
-                                ):  # Only refresh if key exists and has TTL  # type: ignore
+                                if ttl > 0:  # Only refresh if key exists and has TTL
                                     pipeline.expire(key, ttl_seconds)
                             if pipeline.command_stack:
                                 pipeline.execute()

langgraph/store/redis/aio.py

@@ -87,7 +87,7 @@ def __init__(
 
         # Set up store configuration
         self.index_config = index
-        self.ttl_config = ttl  # type: ignore
+        self.ttl_config = ttl
 
         if self.index_config:
             self.index_config = self.index_config.copy()

poetry.lock

@@ -19,7 +19,7 @@ packages = [{ include = "langgraph" }]
 
 [tool.poetry.dependencies]
 python = ">=3.9,<3.14"
-langgraph-checkpoint = "^2.0.26"
+langgraph-checkpoint = ">=2.0.26"
 redisvl = ">=0.5.1,<1.0.0"
 
 [tool.poetry.group.dev.dependencies]
@@ -31,7 +31,7 @@ anyio = "^4.4.0"
 pytest-asyncio = "^0.21.1"
 pytest-xdist = {extras = ["psutil"], version = "^3.6.1"}
 pytest-mock = "^3.11.1"
-mypy = "^1.10.0"
+mypy = ">=1.11.0,<2"
 aioconsole = "^0.8.1"
 langchain-openai = "^0.3.2"
 testcontainers = "^4.9.1"

pyproject.toml

@@ -22,24 +22,24 @@ async def saver(redis_url: str) -> AsyncGenerator[AsyncRedisSaver, None]:
 @pytest.mark.asyncio
 async def test_aget_tuple_returns_correct_checkpoint_id(saver: AsyncRedisSaver):
     """Test that aget_tuple returns the correct checkpoint_id when not specified in config.
-    
+
     This test reproduces the issue described in GitHub issue #64 where AsyncRedisSaver
     aget_tuple was returning None for checkpoint_id while the sync version worked correctly.
     """
     # Create a unique thread ID
     thread_id = str(uuid.uuid4())
-    
+
     # Config with only thread_id and checkpoint_ns (no checkpoint_id)
     runnable_config: RunnableConfig = {
         "configurable": {"thread_id": thread_id, "checkpoint_ns": ""}
     }
-    
+
     # Put several checkpoints
     checkpoint_ids = []
     for run in range(3):
         checkpoint_id = str(run)
         checkpoint_ids.append(checkpoint_id)
-        
+
         await saver.aput(
             {
                 "configurable": {
@@ -56,38 +56,40 @@ async def test_aget_tuple_returns_correct_checkpoint_id(saver: AsyncRedisSaver):
             },
             {},
         )
-        
+
         # Get the tuple using the config without checkpoint_id
         # This should return the latest checkpoint
         get_tuple = await saver.aget_tuple(runnable_config)
-        
+
         # Verify the checkpoint_id is not None and matches the expected value
-        assert get_tuple is not None, f"Expected checkpoint tuple, got None for run {run}"
-        
+        assert (
+            get_tuple is not None
+        ), f"Expected checkpoint tuple, got None for run {run}"
+
         returned_checkpoint_id = get_tuple.config["configurable"]["checkpoint_id"]
         assert returned_checkpoint_id is not None, (
             f"Expected checkpoint_id to be set, got None for run {run}. "
             f"This indicates the bug where aget_tuple returns None for checkpoint_id."
         )
-        
+
         # Since we're getting the latest checkpoint each time, it should be the current checkpoint_id
-        assert returned_checkpoint_id == checkpoint_id, (
-            f"Expected checkpoint_id {checkpoint_id}, got {returned_checkpoint_id} for run {run}"
-        )
+        assert (
+            returned_checkpoint_id == checkpoint_id
+        ), f"Expected checkpoint_id {checkpoint_id}, got {returned_checkpoint_id} for run {run}"
 
 
 @pytest.mark.asyncio
 async def test_aget_tuple_with_explicit_checkpoint_id(saver: AsyncRedisSaver):
     """Test that aget_tuple works correctly when checkpoint_id is explicitly provided."""
     # Create a unique thread ID
     thread_id = str(uuid.uuid4())
-    
+
     # Put several checkpoints
     checkpoint_ids = []
     for run in range(3):
         checkpoint_id = str(run)
         checkpoint_ids.append(checkpoint_id)
-        
+
         await saver.aput(
             {
                 "configurable": {
@@ -104,36 +106,38 @@ async def test_aget_tuple_with_explicit_checkpoint_id(saver: AsyncRedisSaver):
             },
             {},
         )
-    
+
     # Test retrieving each checkpoint by explicit checkpoint_id
     for checkpoint_id in checkpoint_ids:
         config_with_id: RunnableConfig = {
             "configurable": {
                 "thread_id": thread_id,
                 "checkpoint_id": checkpoint_id,
-                "checkpoint_ns": ""
+                "checkpoint_ns": "",
             }
         }
-        
+
         get_tuple = await saver.aget_tuple(config_with_id)
-        
-        assert get_tuple is not None, f"Expected checkpoint tuple, got None for checkpoint_id {checkpoint_id}"
-        
+
+        assert (
+            get_tuple is not None
+        ), f"Expected checkpoint tuple, got None for checkpoint_id {checkpoint_id}"
+
         returned_checkpoint_id = get_tuple.config["configurable"]["checkpoint_id"]
-        assert returned_checkpoint_id == checkpoint_id, (
-            f"Expected checkpoint_id {checkpoint_id}, got {returned_checkpoint_id}"
-        )
+        assert (
+            returned_checkpoint_id == checkpoint_id
+        ), f"Expected checkpoint_id {checkpoint_id}, got {returned_checkpoint_id}"
 
 
 @pytest.mark.asyncio
 async def test_aget_tuple_no_checkpoint_returns_none(saver: AsyncRedisSaver):
     """Test that aget_tuple returns None when no checkpoint exists for the thread."""
     # Use a thread ID that doesn't exist
     thread_id = str(uuid.uuid4())
-    
+
     runnable_config: RunnableConfig = {
         "configurable": {"thread_id": thread_id, "checkpoint_ns": ""}
     }
-    
+
     get_tuple = await saver.aget_tuple(runnable_config)
-    assert get_tuple is None, "Expected None when no checkpoint exists for thread"
+    assert get_tuple is None, "Expected None when no checkpoint exists for thread"