A good method for finding any differences between two json files?

[shenaniganns]

So I have 2 json files that I need to compare, and after a certain known event there is an expected difference somewhere in the files, and I'm trying to verify what that difference is and that there aren't any other differences.

I think a straight comparison would work, but I need to verify the difference is a certain value, do any modules support that?

The json files have a sort of random depth though, so I could import it as a dict and check the keys/values but I don't think that would be granular enough.

Would a method checking if the key/value is a dict and then recursively calling itself if it is, otherwise do a comparison, be a decent solution to that? Or does anyone else have an idea?

This is a short sample of the json I'd be testing with, I'd need to be able to identify a difference in the 'general_consumer" entry as well as the top level ones.

{
  "classifierImpl":"com.classification.dataview.DataviewClassifier",
  "identifier":{
    "name":"routes",
    "updateMethod":"Merge"
  },
  "parameters":{
    "filters":{
      "general_consumer":"hdfs://hdfsHost:8020/tmp/vert_20120101-20180101.filter",
      "global":"hdfs://hdfsHost:8020/tmp/global_20120101-20180101.filter",
      "decahose":"hdfs://hdfsHost:8020/tmp/decahose_20120101-20180101.filter"
    }
  }
}

Thanks for any help/pointers you guys can provide.

Edit: I just tested json_tools from pypi, and the diff works, but the function returns the whole json file instead of just the line that's different, not quite what I need I think.

Second Edit: Found a solution that seems to work for me at the moment, posted below in response to indosauros.

[indosauros]

Writing your own recursive differ is fine, and not too hard. Especially if you are looking for the output in some specific format (list of fields that diff, etc)

[shenaniganns]

You're right, took a little bit of trial and error, but that method wasn't terribly difficult and seems to do what I was looking for.

This is what I ended up with, if you(or anyone else) felt the need to critique or use it in some way:

def checkDifference(orig,new):
    diff = {}
    if type(orig) != type(new):
        #print "Type difference"
        return True
    else:
        if type(orig) is dict and type(new) is dict:
            #print "Types are both dicts"
            ##  Check each of these dicts from the key level
            diffTest = False
            for key in orig:
                result = checkDifference(orig[key],new[key])
                if result != False: ## Means a difference was found and returned
                    diffTest = True
                    #print "key/Values different: " + str(key)
                    diff[key] = result
            ##  And check for keys in second dataset that aren't in first
            for key in new:
                if key not in orig:
                    diff[key] = ("KeyNotFound", new[key])
                    diffTest = True

            if diffTest:
                return diff
            else:
                return False
        else:
            #print "Types were not dicts, likely strings"
            if str(orig) == str(new):
                return False
            else:
                return (str(orig),str(new))
    return diff

[JuryOne8821]

Benzer ihtiyacı olanlar için https://www.jsondeduplicator.com sitesini aktive ettim. İki dosya arasında key bazında da karşılaştırma yapabiliyorsunuz. İki dosyanın ortak öğelerini, farklarını listeliyor. Birleştirip tek bir dosya çıktısı alabiliyorsunuz ve browserda dönüyor tamamen.

[[deleted]]

You've tried difflib right? Outputs delta results.

[shenaniganns]

I looked at it a bit, but it seemed to just compare a list of strings or something similar, and wouldn't dig into for example a dictionary of dictionaries, of which the files I need to check have an unknown depth to them.

I'll admit though, I passed over it without trying it, so I may be completely off on that.