How can I resolve mypy's type error when updating a dictionary key from str to datetime in Python?

Below is one recommended approach: keep separate representations for raw data (with all strings) and parsed data (with proper types). In other words, don’t mix types for a single field in a dictionary that’s expected to only contain strings; instead, define a new structure that holds the parsed types.

For example, you might define a dataclass that represents your token:

PYTHONCopied
from dataclasses import dataclass
from datetime import datetime

@dataclass
class Token:
    expiryTime: datetime

    @classmethod
    def from_dict(cls, data: dict[str, str]) -> "Token":
        return cls(
            expiryTime=datetime.strptime(data["expiryTime"], "%Y-%m-%dT%H:%M:%S")
        )

    def to_dict(self) -> dict[str, str]:
        return {
            "expiryTime": self.expiryTime.isoformat()
        }

# Given the raw token dictionary (e.g., read from JSON)
raw_token_dict: dict[str, str] = {"expiryTime": "2025-01-23T12:34:56"}

# Convert raw token to a proper Token instance with a datetime field
token = Token.from_dict(raw_token_dict)

# Proceed with token.expiryTime as a datetime object...
print(token.expiryTime)

# When you need to serialize again (e.g., for mocking),
# convert the Token back to a dictionary with the ISO string representation
serialized = token.to_dict()
print(serialized)

Explanation

1. Separation of Concerns:
   The raw dictionary is only used for data exchange (i.e. JSON) and always contains strings. The Token dataclass has the proper field types for use in your code.

2. Type Safety:
   The Token class guarantees that expiryTime is a datetime without mixing string and datetime types in the same data structure. This ensures that mypy sees type-consistent assignments.

3. Serialization/Deserialization:
   The helper methods from_dict and to_dict handle converting between the raw string formats (for JSON) and your desired types.

Alternative Approach

If you must store both representations in one dictionary, you could use a union type (Union[str, datetime]), but that forces you to perform type checks every time you access the data:

PYTHONCopied
from datetime import datetime
from typing import Union

# Dictionary can now store either a str or a datetime
token_dict: dict[str, Union[str, datetime]] = {"expiryTime": "2025-01-23T12:34:56"}

# When you need to parse it, be explicit:
expiry_str = token_dict["expiryTime"]
if isinstance(expiry_str, str):
    token_dict["expiryTime"] = datetime.strptime(expiry_str, "%Y-%m-%dT%H:%M:%S")

While this works, it adds complexity because every access to "expiryTime" requires a check (or a cast) to determine if it is a string or a datetime. This mingling of types is why it’s better to separate serialization (strings in dictionaries) from your processing logic (using structured data).

Conclusion

Using a separate, typed representation (like with a dataclass) is the cleanest, most maintainable, and type-safe approach. It avoids the pitfalls of mixing types in a single dictionary and keeps your code base both clear and mypy-friendly.