python-json-pointer

python-json-pointer is a Python library designed for resolving JSON pointers according to the RFC 6901 specification. It is suitable for applications that need to navigate or manipulate JSON documents using pointer strings.

Requirements:

• Python 3.10 or newer
• PyPy is also supported

The jsonpointer CLI utility allows you to resolve JSON pointer expressions against one or more JSON files. You can provide the JSON pointer via a file containing the pointer expression, and then specify the target JSON files to be processed.

# Example: resolving a pointer from ptr.json against a.json and b.json
$ jsonpointer ptr.json a.json b.json

To resolve a pointer, create a file containing the pointer string (e.g., "/a") and pass it as the first argument, followed by the JSON files you wish to inspect.

Example workflow:

1. Create a.json: { "a": [1, 2, 3] }
2. Create ptr.json: "/a"
3. Run: jsonpointer ptr.json a.json
4. Result: [1, 2, 3]

# inspect JSON files
$ cat a.json
{ "a": [1, 2, 3] }

$ cat b.json
{ "a": {"b": [1, 3, 4]}, "b": 1 }

# inspect JSON pointer
$ cat ptr.json
"/a"

# resolve JSON pointer
$ jsonpointer ptr.json a.json b.json
[1, 2, 3]
{"b": [1, 3, 4]}

The set_pointer method allows you to modify a portion of a Python object using JSON pointer notation.

By default, set_pointer performs an in-place modification of the original object. If you want to preserve the original object and receive a modified copy instead, pass inplace=False to the function.

from jsonpointer import set_pointer
obj = {"foo": {"anArray": [ {"prop": 44}], "another prop": {"baz": "A string" }}}

# In-place modification (default)
set_pointer(obj, '/foo/anArray/0/prop', 55)

# Non-destructive modification (returns a copy)
new_obj = set_pointer(obj, '/foo/anArray/0/prop', 55, inplace=False)

The JsonPointer class allows you to wrap a JSON pointer string into an object. This is useful when you want to apply the same path to multiple different objects. You can use the .resolve(obj) method on the instance to retrieve the value at that path from a given object.

import jsonpointer

pointer = jsonpointer.JsonPointer('/foo/1')

obj1 = {'foo': ['a', 'b', 'c']}
print(pointer.resolve(obj1))  # Output: 'b'

obj2 = {'foo': {'0': 1, '1': 10, '2': 100}}
print(pointer.resolve(obj2))  # Output: 10

Use the resolve_pointer method to perform a deep retrieval from a Python object using an RFC 6901 compliant JSON pointer string. It acts similarly to a deep get operation. If the pointer path does not exist, you can pass None as the third argument to return None instead of raising an error.

from jsonpointer import resolve_pointer
obj = {"foo": {"anArray": [ {"prop": 44}], "another prop": {"baz": "A string" }}}

# Resolve to the root object
resolve_pointer(obj, '') == obj

# Resolve to a nested key
resolve_pointer(obj, '/foo/another prop/baz') == obj['foo']['another prop']['baz']

# Resolve to an array index
resolve_pointer(obj, '/foo/anArray/0') == obj['foo']['anArray'][0]

# Return None for non-existent paths if specified
resolve_pointer(obj, '/some/path', None) == None