DeepDiff 9.0.0 Is Released

I’m happy to announce that DeepDiff 9.0.0 is released.

Major releases are always a little tricky. On one hand, they are exciting because you get to clean up behavior, fix long-standing issues, and move the project forward. On the other hand, even small backward incompatible changes can surprise people.

This release has a few of those changes, especially around cases where ignore_order=True is enabled. The results can be slightly different than before, and in this case that is a good thing because the new behavior is more correct.

If you are upgrading, please take a quick look at the mini migration notes in the changelog at /deepdiff/current/changelog.html.

The main migration note

The biggest migration item in 9.0.0 is around to_dict() and to_json().

These methods now accept a verbose_level parameter and always return a usable text-view dict. When the original view is 'tree', they now default to verbose_level=2 so you get the full details. The old view_override parameter is removed.

In plain English, if you were relying on the previous output from to_dict() or to_json() while using tree view, you may need to explicitly pass the verbose_level you want in order to get the same kind of output as before.

It is a small change, but it is exactly the kind of thing that is worth calling out in a major release.

What is new in 9.0.0

There are a few headline changes in this release.

First, DeepDiff is dropping support for Python 3.9 and adding support for Python 3.14.

Second, DeepDiff now supports a callable group_by, which gives you more flexibility when grouping records before comparing them.

Third, to_flat_dicts now has a FlatDeltaDict TypedDict return type, which should make typing support cleaner for people working with static analysis and editors that understand type hints.

And then there are a bunch of bug fixes and correctness fixes that I am very happy to get in.

The short English version

If I had to summarize DeepDiff 9.0.0, I would put it like this:

• DeepDiff is more correct now, especially when ignore_order=True
• the serialization output is more consistent
• type hints are a bit better
• edge cases around objects, big integers, and flattened output got cleaned up
• and the project is moving forward with newer Python versions

That is really what this release is about.

A closer look at the changes

One important fix is that DeepDiff no longer misses some int-versus-float type changes when ignore_order=True is enabled. That kind of thing can lead to very confusing results because the whole point of a diff tool is to be precise when it matters.

Another nice improvement is that reporting now always uses the t1 path. That makes the output more consistent and easier to reason about.

There was also a fix for the colored view when all list items are removed. That was one of those bugs that only shows up in a specific situation, but once you hit it, it is annoying.

There was a fix for hasattr() swallowing AttributeError in __slots__ handling for objects that also define __getattr__. This is exactly the sort of Python edge case that is easy to miss and painful to debug.

DeepDiff also now handles Fraction as a numeric type, which is a nice improvement for users who work with more precise numeric representations.

Some serialization-related bugs got fixed too:

• _convert_oversized_ints failing on NamedTuple
• an orjson TypeError when integers exceed the 64-bit range
• and a bug in to_flat_dicts where include_action_in_path and report_type_changes were not being passed through correctly

There were also fixes for ignore_keys in detailed__dict__ and a type hint issue around logarithmic similarity.

So overall, this is not a flashy release. It is a solid release. It makes DeepDiff more correct, more consistent, and less surprising in edge cases.

Thank you to the contributors

I also want to thank the people who contributed to this release.

Thank you to echan5 for adding support for callable group_by.

Thank you to Yann Rouillard for fixing the colored view display when all list items are removed.

Thank you to Tomas Pereira de Vasconcelos for fixing the hasattr() and __slots__ handling issue for objects with __getattr__.

Thank you to devin13cox for making reporting always use the t1 path.

Thank you to vitalis89 for fixing the ignore_keys issue in detailed__dict__.

Thank you to ljames8 for fixing the logarithmic similarity type hint.

And thank you to akshat62 for adding Fraction numeric support.

Open source gets better one contribution at a time, and I really appreciate everybody who took the time to help improve DeepDiff.

Another milestone

Another important milestone is that DeepDiff has now reached 74 million monthly downloads on PyPI.

That number is honestly a bit surreal to me.

When you maintain a project for a long time, most of the work does not feel glamorous. It is bug reports, edge cases, documentation, testing, release work, and trying very hard not to break people’s systems. So it is exciting to see DeepDiff being used at this scale.

DeepDiff is also used by major companies from Netflix to Google, Uber, and many others. On GitHub alone, around 20,000 open source repositories depend on it.

That is both exciting and humbling.

It is exciting because it is satisfying to know that something I built is useful to so many people.

It is humbling because once a project reaches this kind of usage, every change matters more.

Moving DeepDiff under Qluster

I have also decided to move DeepDiff under my Qluster brand.

The users of Qluster and the users of DeepDiff are not exactly the same, so this is not about trying to make them into the same thing.

It is really about brand recognition and trust.

I want Qluster to stand for software that is practical, battle-tested, and built with care. DeepDiff has earned trust over the years, and I think bringing it under the Qluster brand helps strengthen that story.

In other words, if I am going to keep building tools, I want people to be able to recognize the name behind them.

Final thoughts

It is exciting to be a maintainer of something that is used by so many people.

It is also a responsibility that I do not take lightly.

DeepDiff ends up in test suites, data pipelines, internal tools, debugging workflows, and production systems that I will never personally see. That is part of what makes maintaining it meaningful to me.

DeepDiff 9.0.0 is a major release, but it is a very DeepDiff kind of major release. It is about correctness, consistency, and moving the project forward carefully.

I hope you enjoy it.

Have fun!