Python JSON Patch

https://python-json-patch.readthedocs.io/en/latest/
Admin
Python JSON Patch is a Python library for applying JSON patches (RFC 6902), supporting Python 2.7...
Tokens:11,378
Snippets:107
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install jsonpatch with pip

Source: https://python-json-patch.readthedocs.io/en/latest/index.html

Install the library using pip.

```bash
$ pip install jsonpatch
```

--------------------------------

### make_patch example: generating a patch from two documents

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Shows how to use make_patch to generate a patch that transforms src into dst, then apply it to src to get dst.

```python
>>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
>>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
>>> patch = make_patch(src, dst)
>>> new = patch.apply(src)
>>> new == dst
True
```

--------------------------------

### jsonpatch example

Source: https://python-json-patch.readthedocs.io/en/latest/commandline.html

Demonstrates how to use `jsonpatch` to apply a patch to a JSON file, including indentation and piping output to a new file.

```shell
# create a patch
$ jsondiff a.json b.json > patch.json

# show the result after applying a patch
$ jsonpatch a.json patch.json
{"a": [1, 2, 3], "c": 100}

$ jsonpatch a.json patch.json --indent=2
{
  "a": [
    1,
    2,
    3
  ],
  "c": 100
}

# pipe result into new file
$ jsonpatch a.json patch.json --indent=2 > c.json

# c.json now equals b.json
$ jsondiff b.json c.json
[]

```

--------------------------------

### jsondiff example

Source: https://python-json-patch.readthedocs.io/en/latest/commandline.html

Demonstrates how to use `jsondiff` to compare two JSON files and produce a patch, with and without indentation.

```shell
# inspect JSON files
$ cat a.json
{ "a": [1, 2], "b": 0 }

$ cat b.json
{ "a": [1, 2, 3], "c": 100 }

# show patch in "dense" representation
$ jsondiff a.json b.json
[{"path": "/a/2", "value": 3, "op": "add"}, {"path": "/b", "op": "remove"}, {"path": "/c", "value": 100, "op": "add"}]

# show patch with some indentation
$ jsondiff a.json b.json --indent=2
[
  {
    "path": "/a/2",
    "value": 3,
    "op": "add"
  },
  {
    "path": "/b",
    "op": "remove"
  },
  {
    "path": "/c",
    "value": 100,
    "op": "add"
  }
]

```

--------------------------------

### Create and apply a JsonPatch

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Shows how to create a JsonPatch instance from a list of operations and apply it to a document. The example demonstrates add, remove, test, and replace operations, and verifies the result.

```python
>>> patch = JsonPatch([
...     {'op': 'add', 'path': '/foo', 'value': 'bar'},
...     {'op': 'add', 'path': '/baz', 'value': [1, 2, 3]},
...     {'op': 'remove', 'path': '/baz/1'},
...     {'op': 'test', 'path': '/baz', 'value': [1, 3]},
...     {'op': 'replace', 'path': '/baz/0', 'value': 42},
...     {'op': 'remove', 'path': '/baz/1'},
... ])
>>> doc = {}
>>> result = patch.apply(doc)
>>> expected = {'foo': 'bar', 'baz': [42]}
>>> result == expected
True
```

--------------------------------

### apply_patch example: applying a patch to a document

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Shows how to use apply_patch to apply a patch to a document. Demonstrates that by default the patch is applied to a copy (doc is not other), and with in_place=True the original document is modified.

```python
>>> doc = {'foo': 'bar'}
>>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
>>> other = apply_patch(doc, patch)
>>> doc is not other
True
>>> other == {'foo': 'bar', 'baz': 'qux'}
True
>>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
>>> apply_patch(doc, patch, in_place=True) == {'foo': 'bar', 'baz': 'qux'}
True
>>> doc == other
True
```

--------------------------------

### Create JsonPatch from list of operations

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Explicitly create a JsonPatch object from a list of operations. The equivalent from_string() method accepts a JSON string. The example shows operations: add, remove, test, replace.

```python
>>> import jsonpatch
>>> patch = jsonpatch.JsonPatch([
    {'op': 'add', 'path': '/foo', 'value': 'bar'},
    {'op': 'add', 'path': '/baz', 'value': [1, 2, 3]},
    {'op': 'remove', 'path': '/baz/1'},
    {'op': 'test', 'path': '/baz', 'value': [1, 3]},
    {'op': 'replace', 'path': '/baz/0', 'value': 42},
    {'op': 'remove', 'path': '/baz/1'},
])

# or equivalently
>>> patch = jsonpatch.JsonPatch.from_string('[{"op": "add", ....}]')
```

--------------------------------

### Apply patch to object

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Apply a patch to an object with the apply() method. The result is a new object; use in_place=True to modify in place. The example shows that applying the diff patch to src yields dst.

```python
>>> result = patch.apply(src)
>>> result == dst
True
```

--------------------------------

### Apply patch to incompatible object raises JsonPatchConflict

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Applying a patch to an object that does not have the expected locations raises a JsonPatchConflict. The example shows the error message for a non-existent object.

```python
>>> patch.apply(dst)
Traceback (most recent call last):
  ...
jsonpatch.JsonPatchConflict: can't remove a non-existent object 'foo'
```

--------------------------------

### Create custom JsonPatch subclass with Decimal support using simplejson

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Defines DecimalJsonPatch overriding json_dumper and json_loader to use simplejson with use_decimal=True. The example creates a patch from a diff and applies it to a document, preserving Decimal values.

```python
>>> import decimal
>>> import simplejson

>>> class DecimalJsonPatch(jsonpatch.JsonPatch):
        @staticmethod
        def json_dumper(obj):
            return simplejson.dumps(obj)

        @staticmethod
        def json_loader(obj):
            return simplejson.loads(obj, use_decimal=True,
                                    object_pairs_hook=jsonpatch.multidict)

>>> src = {}
>>> dst = {'bar': decimal.Decimal('1.10')}
>>> patch = DecimalJsonPatch.from_diff(src, dst)
>>> doc = {'foo': 1}
>>> result = patch.apply(doc)
{'foo': 1, 'bar': Decimal('1.10')}

```

--------------------------------

### Iterate over JsonPatch operations

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

JsonPatch objects are iterable, allowing access to each patch statement in a loop. The example converts the patch to a list and compares the first element to the expected operation.

```python
>>> lpatch = list(patch)
>>> expected = {'op': 'add', 'path': '/foo', 'value': 'bar'}
>>> lpatch[0] == expected
True
>>> lpatch == patch.patch
True
```

--------------------------------

### jsondiff usage and options

Source: https://python-json-patch.readthedocs.io/en/latest/_sources/commandline.rst.txt

Shows the command-line usage and options for the jsondiff utility. It accepts two JSON files and supports --indent, -u/--preserve-unicode, and -v/--version flags.

```text
usage: jsondiff [-h] [--indent INDENT] [-u] [-v] FILE1 FILE2

Diff two JSON files

positional arguments:
  FILE1
  FILE2

optional arguments:
  -h, --help             show this help message and exit
  --indent INDENT        Indent output by n spaces
  -u, --preserve-unicode Output Unicode character as-is without using Code Point
  -v, --version          show program's version number and exit
```

--------------------------------

### jsondiff usage

Source: https://python-json-patch.readthedocs.io/en/latest/commandline.html

Displays the command-line usage and options for the `jsondiff` utility, which compares two JSON files and outputs a JSON patch.

```text
usage: jsondiff [-h] [--indent INDENT] [-u] [-v] FILE1 FILE2

Diff two JSON files

positional arguments:
  FILE1
  FILE2

optional arguments:
  -h, --help             show this help message and exit
  --indent INDENT        Indent output by n spaces
  -u, --preserve-unicode Output Unicode character as-is without using Code Point
  -v, --version          show program's version number and exit

```

--------------------------------

### jsonpatch usage

Source: https://python-json-patch.readthedocs.io/en/latest/commandline.html

Displays the command-line usage and options for the `jsonpatch` utility, which applies a JSON patch to a JSON file.

```text
usage: jsonpatch [-h] [--indent INDENT] [-v] ORIGINAL PATCH

Apply a JSON patch on a JSON files

positional arguments:
  ORIGINAL         Original file
  PATCH            Patch file

optional arguments:
 -h, --help             show this help message and exit
 --indent INDENT        Indent output by n spaces
 -b, --backup           Back up ORIGINAL if modifying in-place
 -i, --in-place         Modify ORIGINAL in-place instead of to stdout
 -v, --version          show program's version number and exit
 -u, --preserve-unicode Output Unicode character as-is without using Code Point

```

--------------------------------

### Use make_patch with boolean conversion

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Shows how to use make_patch() to generate a patch and then check if it is non-empty before applying it. The comment indicates the document has changed.

```python
>>> old = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
>>> new = {'baz': 'qux', 'numbers': [1, 4, 7]}
>>> patch = make_patch(old, new)
>>> if patch:
...     # document have changed, do something useful
...     patch.apply(old)
{...}
```

--------------------------------

### Create patch from diff using from_diff

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Demonstrates creating a JsonPatch instance from a diff between two documents using the from_diff classmethod. The resulting patch transforms src into dst.

```python
>>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
>>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
>>> patch = JsonPatch.from_diff(src, dst)
>>> new = patch.apply(src)
>>> new == dst
True
```

--------------------------------

### Using simplejson with jsonpatch for Decimal support

Source: https://python-json-patch.readthedocs.io/en/latest/_sources/tutorial.rst.txt

Shows how to use simplejson with jsonpatch: pass dumps to from_diff and to_string, and a partial loads to from_string to preserve Decimal values when applying the patch.

```python
>>> patch = jsonpatch.JsonPatch.from_diff(src, dst, dumps=simplejson.dumps)
```

```python
>>> serialized_patch = patch.to_string(dumps=simplejson.dumps)
'[{"op": "add", "path": "/bar", "value": 1.10}]'
```

```python
>>> import functools
>>> loads = functools.partial(simplejson.loads, use_decimal=True,
                              object_pairs_hook=jsonpatch.multidict)
>>> patch.from_string(serialized_patch, loads=loads)
>>> doc = {'foo': 1}
>>> result = patch.apply(doc)
{'foo': 1, 'bar': Decimal('1.10')}
```

--------------------------------

### Pass loads function to from_string for custom deserialization

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Uses functools.partial to create a loads function with use_decimal=True and object_pairs_hook, then passes it to from_string to deserialize the patch and apply it, preserving Decimal values.

```python
>>> import functools
>>> loads = functools.partial(simplejson.loads, use_decimal=True,
                              object_pairs_hook=jsonpatch.multidict)
>>> patch.from_string(serialized_patch, loads=loads)
>>> doc = {'foo': 1}
>>> result = patch.apply(doc)
{'foo': 1, 'bar': Decimal('1.10')}

```

--------------------------------

### Create patch by diffing two objects

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Generate a patch that transforms src into dst using JsonPatch.from_diff() or the equivalent make_patch(). The patch must be applied to src or an equal object.

```python
>>> src = {'foo': 'bar', 'numbers': [1, 3, 4, 8]}
>>> dst = {'baz': 'qux', 'numbers': [1, 4, 7]}
>>> patch = jsonpatch.JsonPatch.from_diff(src, dst)

# or equivalently
>>> patch = jsonpatch.make_patch(src, dst)
```

--------------------------------

### CopyOperation.apply

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Applies the copy operation to an object.

```APIDOC
## CopyOperation.apply(obj)

### Description
Copies an object property or an array element to a new location. Applies the patch operation to the specified object.

### Method
apply

### Parameters
- **obj** - Required - The object to apply the operation to.

### Returns
Modified object.
```

--------------------------------

### Build escaped JSON Pointer from unescaped keys with JsonPointer.from_parts

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Uses the jsonpointer package to construct a pointer from a list of unescaped keys, automatically escaping '/' and '~'.

```python
>>> from jsonpointer import JsonPointer
>>> JsonPointer.from_parts(['/fields/test', 'a~b']).path
'/~1fields~1test/a~0b'

```

--------------------------------

### AddOperation.apply

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Applies the add operation to an object.

```APIDOC
## AddOperation.apply(obj)

### Description
Adds an object property or an array element. Applies the patch operation to the specified object.

### Method
apply

### Parameters
- **obj** - Required - The object to apply the operation to.

### Returns
Modified object.
```

--------------------------------

### JsonPatch.from_diff

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Creates a JsonPatch instance from the difference between two documents.

```APIDOC
## JsonPatch.from_diff(src, dst, optimization=True, dumps=None, pointer_cls=JsonPointer)

### Description
Creates a JsonPatch instance based on comparison of two document objects. The resulting patch transforms src into dst.

### Method
from_diff

### Parameters
- **src** (dict) - Required - Data source document object.
- **dst** (dict) - Required - Data target document object.
- **optimization** (bool) - Optional - Optimization flag.
- **dumps** (Callable) - Optional - A function of one argument that produces a serialized JSON string.
- **pointer_cls** (Type[JsonPointer]) - Optional - JSON pointer class to use.

### Returns
JsonPatch instance.
```

--------------------------------

### jsonpatch.CopyOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a 'copy' operation in a JSON Patch. Users can instantiate this class to create a copy operation.

```APIDOC
## Class: jsonpatch.CopyOperation

### Description
Represents a 'copy' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### jsonpatch.MoveOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a 'move' operation in a JSON Patch. Users can instantiate this class to create a move operation.

```APIDOC
## Class: jsonpatch.MoveOperation

### Description
Represents a 'move' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### JsonPatch.from_string

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Creates a JsonPatch instance from a string representation.

```APIDOC
## JsonPatch.from_string(patch_str, loads=None, pointer_cls=JsonPointer)

### Description
Creates a JsonPatch instance from a string source.

### Method
from_string

### Parameters
- **patch_str** (str) - Required - JSON patch as raw string.
- **loads** (Callable) - Optional - A function of one argument that loads a serialized JSON string.
- **pointer_cls** (Type[JsonPointer]) - Optional - JSON pointer class to use.

### Returns
JsonPatch instance.
```

--------------------------------

### jsonpatch.to_string

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Returns the patch set as a JSON string.

```APIDOC
## jsonpatch.to_string

### Description
Returns the patch set as a JSON string. This method is used to serialize a patch object to its JSON representation.

### Method
Function

### Signature
`to_string(dumps=None)`

### Parameters
- **dumps** (callable) - Optional - A custom JSON dumps function to use. If not provided, the default json.dumps is used.

### Returns
- **str** - The JSON string representation of the patch set.
```

--------------------------------

### jsonpatch.TestOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a 'test' operation in a JSON Patch. Users can instantiate this class to create a test operation.

```APIDOC
## Class: jsonpatch.TestOperation

### Description
Represents a 'test' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### jsonpatch.MoveOperation.apply

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Applies a move operation to an object.

```APIDOC
## jsonpatch.MoveOperation.apply

### Description
Applies the move operation to the specified object. Moves an object property or an array element to a new location.

### Method
Function

### Signature
`apply(obj)`

### Parameters
- **obj** (object) - Required - The object to which the patch operation is applied.

### Returns
- **object** - The modified object after applying the operation.
```

--------------------------------

### jsonpatch.multidict()

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Function that converts a multidict to a regular dict.

```APIDOC
## Function: jsonpatch.multidict()

### Description
Converts a multidict to a regular dict.

```

--------------------------------

### jsonpatch.AddOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing an 'add' operation in a JSON Patch. Users can instantiate this class to create an add operation.

```APIDOC
## Class: jsonpatch.AddOperation

### Description
Represents an 'add' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### jsonpatch.make_patch()

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Function that creates a JSON Patch from the difference between two documents.

```APIDOC
## Function: jsonpatch.make_patch()

### Description
Creates a JSON Patch from the difference between two documents.

```

--------------------------------

### jsonpatch.ReplaceOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a 'replace' operation in a JSON Patch. Users can instantiate this class to create a replace operation.

```APIDOC
## Class: jsonpatch.ReplaceOperation

### Description
Represents a 'replace' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### Pass dumps function to from_diff for custom serialization

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Instead of subclassing, pass a dumps function directly to from_diff to use simplejson for serialization.

```python
>>> patch = jsonpatch.JsonPatch.from_diff(src, dst, dumps=simplejson.dumps)

```

--------------------------------

### Pass dumps function to to_string for custom serialization

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Pass a dumps function to to_string to serialize the patch with simplejson, producing a JSON string with Decimal values as numbers.

```python
>>> serialized_patch = patch.to_string(dumps=simplejson.dumps)
'[{"op": "add", "path": "/bar", "value": 1.10}]'

```

--------------------------------

### jsonpatch.json_dumper

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Serializes a Python object to a JSON formatted string with configurable options.

```APIDOC
## jsonpatch.json_dumper

### Description
Serializes a Python object to a JSON formatted string. This function provides a convenient way to dump JSON with various options for formatting and handling of special values.

### Method
Function

### Signature
`json_dumper(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)`

### Parameters
- **obj** (object) - Required - The Python object to serialize.
- **skipkeys** (bool) - Optional - If true, dict keys that are not basic types (str, int, float, bool, None) will be skipped instead of raising a TypeError.
- **ensure_ascii** (bool) - Optional - If false, the return value can contain non-ASCII characters; otherwise, all such characters are escaped.
- **check_circular** (bool) - Optional - If false, the circular reference check for container types will be skipped.
- **allow_nan** (bool) - Optional - If false, it will be a ValueError to serialize out-of-range float values (nan, inf, -inf).
- **indent** (int) - Optional - If a non-negative integer, JSON array elements and object members will be pretty-printed with that indent level. None is the most compact representation.
- **separators** (tuple) - Optional - An (item_separator, key_separator) tuple. Default is (', ', ': ') if indent is None and (',', ': ') otherwise.
- **default** (callable) - Optional - A function that should return a serializable version of obj or raise TypeError.
- **sort_keys** (bool) - Optional - If true, the output of dictionaries will be sorted by key.
- **cls** (class) - Optional - A custom JSONEncoder subclass to use.

### Returns
- **str** - The JSON formatted string representation of the object.
```

--------------------------------

### jsonpatch.PatchOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Base class for all patch operations. Provides the common interface for applying operations.

```APIDOC
## Class: jsonpatch.PatchOperation

### Description
Base class for all patch operations.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### jsonpatch.json_loader

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Deserializes a JSON document to a Python object with support for custom decoding hooks.

```APIDOC
## jsonpatch.json_loader

### Description
Deserializes a JSON document (str, bytes, or bytearray) to a Python object. This function provides a flexible way to load JSON with custom decoding hooks.

### Method
Function

### Signature
`json_loader(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=<function multidict>, **kw)`

### Parameters
- **s** (str, bytes, or bytearray) - Required - The JSON document to deserialize.
- **cls** (class) - Optional - A custom JSONDecoder subclass to use.
- **object_hook** (callable) - Optional - Called with the result of any object literal decode (a dict). The return value is used instead of the dict.
- **object_pairs_hook** (callable) - Optional - Called with the result of any object literal decoded with an ordered list of pairs. The return value is used instead of the dict. If object_hook is also defined, object_pairs_hook takes priority.
- **parse_float** (callable) - Optional - Called with the string of every JSON float to be decoded. Default is float(num_str).
- **parse_int** (callable) - Optional - Called with the string of every JSON int to be decoded. Default is int(num_str).
- **parse_constant** (callable) - Optional - Called with one of the strings: -Infinity, Infinity, NaN. Can be used to raise an exception if invalid JSON numbers are encountered.

### Returns
- **object** - The deserialized Python object.
```

--------------------------------

### jsonpatch.apply_patch()

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Function that applies a JSON Patch to a document.

```APIDOC
## Function: jsonpatch.apply_patch()

### Description
Applies a JSON Patch to a document.

```

--------------------------------

### jsonpatch.JsonPatch

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a JSON Patch document. Provides methods to apply, serialize, and create patches.

```APIDOC
## Class: jsonpatch.JsonPatch

### Description
Represents a JSON Patch document.

### Methods
- **apply()** - Applies the patch to a given document.
- **to_string()** - Serializes the patch to a JSON string.

### Class Methods
- **from_diff()** - Creates a JsonPatch from the difference between two documents.
- **from_string()** - Creates a JsonPatch from a JSON string.

### Static Methods
- **json_dumper()** - Dumps a JSON object to a string.
- **json_loader()** - Loads a JSON object from a string.

```

--------------------------------

### jsonpatch.PatchOperation.apply

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Applies a patch operation to an object.

```APIDOC
## jsonpatch.PatchOperation.apply

### Description
Applies a patch operation to the specified object. This is an abstract method that is overridden by specific operation classes.

### Method
Function

### Signature
`apply(obj)`

### Parameters
- **obj** (object) - Required - The object to which the patch operation is applied.

### Returns
- **object** - The modified object after applying the operation.
```

--------------------------------

### Convert JsonPatch to bool

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

JsonPatch can be converted directly to a boolean indicating whether it contains any operation statements. An empty patch converts to False.

```python
>>> bool(patch)
True
>>> bool(JsonPatch([]))
False
```

--------------------------------

### Apply patch without explicit patch object

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Use jsonpatch.apply_patch() directly with a patch string or a list of operations. The object is modified in place by default.

```python
>>> obj = {'foo': 'bar'}

# from a patch string
>>> patch = '[{"op": "add", "path": "/baz", "value": "qux"}]'
>>> res = jsonpatch.apply_patch(obj, patch)

# or from a list
>>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
>>> res = jsonpatch.apply_patch(obj, patch)
```

--------------------------------

### jsonpatch.RemoveOperation

Source: https://python-json-patch.readthedocs.io/en/latest/genindex.html

Class representing a 'remove' operation in a JSON Patch. Users can instantiate this class to create a remove operation.

```APIDOC
## Class: jsonpatch.RemoveOperation

### Description
Represents a 'remove' operation in a JSON Patch.

### Methods
- **apply()** - Applies the operation to a given document.

```

--------------------------------

### Escape special characters in JSON Pointer paths with make_patch

Source: https://python-json-patch.readthedocs.io/en/latest/tutorial.html

Shows that make_patch escapes keys containing '/' or '~' in generated paths. The unescaped path '/fields/test' would select a nested key and fail on an empty object.

```python
>>> patch = jsonpatch.make_patch({}, {'/fields/test': '123456'})
>>> patch.patch
[{'op': 'add', 'path': '/~1fields~1test', 'value': '123456'}]
>>> patch.apply({})
{'/fields/test': '123456'}

```

--------------------------------

### jsonpatch.RemoveOperation.apply

Source: https://python-json-patch.readthedocs.io/en/latest/mod-jsonpatch.html

Applies a remove operation to an object.

```APIDOC
## jsonpatch.RemoveOperation.apply

### Description
Applies the remove operation to the specified object. Removes an object property or an array element.

### Method
Function

### Signature
`apply(obj)`

### Parameters
- **obj** (object) - Required - The object to which the patch operation is applied.

### Returns
- **object** - The modified object after applying the operation.
```
Tokens:
Raw