Fix inconsistent Dag hashes when template fields contain unordered dicts#59091
Merged
potiuk merged 1 commit intoapache:mainfrom Dec 7, 2025
Merged
Fix inconsistent Dag hashes when template fields contain unordered dicts#59091potiuk merged 1 commit intoapache:mainfrom
potiuk merged 1 commit intoapache:mainfrom
Conversation
Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields.
Member
|
I guess that one should go to 3.1.4rc2 if we have it |
github-actions bot
pushed a commit
that referenced
this pull request
Dec 7, 2025
…unordered dicts (#59091) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields. (cherry picked from commit d46a9d1) Co-authored-by: Ephraim Anierobi <splendidzigy24@gmail.com>
Backport successfully created: v3-1-test
|
potiuk
pushed a commit
that referenced
this pull request
Dec 7, 2025
…unordered dicts (#59091) (#59175) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields. (cherry picked from commit d46a9d1) Co-authored-by: Ephraim Anierobi <splendidzigy24@gmail.com>
amoghrajesh
pushed a commit
to astronomer/airflow
that referenced
this pull request
Dec 8, 2025
…cts (apache#59091) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields.
ephraimbuddy
added a commit
that referenced
this pull request
Dec 8, 2025
…unordered dicts (#59091) (#59175) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields. (cherry picked from commit d46a9d1) Co-authored-by: Ephraim Anierobi <splendidzigy24@gmail.com>
ephraimbuddy
added a commit
that referenced
this pull request
Dec 8, 2025
…unordered dicts (#59091) (#59175) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields. (cherry picked from commit d46a9d1) Co-authored-by: Ephraim Anierobi <splendidzigy24@gmail.com>
2 tasks
jhgoebbert
pushed a commit
to jhgoebbert/airflow_Owen-CH-Leung
that referenced
this pull request
Feb 8, 2026
…cts (apache#59091) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields.
Subham-KRLX
pushed a commit
to Subham-KRLX/airflow
that referenced
this pull request
Mar 4, 2026
…cts (apache#59091) Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing. Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Dags using operators with dictionary values in template_fields (such as env_vars) were getting different hashes on each parse, even when the actual dictionary content was unchanged. This happened because serialize_template_field converts dictionaries to string using str(), which preserves insertion order. When dictionary ordering varies between parses (e.g., when env_vars comes from os.environ.copy()), the string representation differs, causing inconsistent hashing.
Prevents unnecessary Dag updates and reprocessing when only dictionary ordering differs in template fields.
Related: #56471