jsonpatch 1.36__tar.gz → 1.38__tar.gz

{jsonpatch-1.36/jsonpatch.egg-info → jsonpatch-1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpatch
-Version: 1.36
+Version: 1.38
 Summary:  Apply JSON-Patches (RFC 6902) 
 Home-page: https://github.com/stefankoegl/python-json-patch
 Author: Stefan Kögl

{jsonpatch-1.36 → jsonpatch-1.38/jsonpatch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpatch
-Version: 1.36
+Version: 1.38
 Summary:  Apply JSON-Patches (RFC 6902) 
 Home-page: https://github.com/stefankoegl/python-json-patch
 Author: Stefan Kögl

{jsonpatch-1.36 → jsonpatch-1.38}/jsonpatch.py

@@ -37,7 +37,8 @@ import collections
 import copy
 import functools
 import json
-from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
+from collections.abc import (Mapping, MutableMapping, MutableSequence,
+                             Sequence)
 from difflib import SequenceMatcher
 from types import MappingProxyType
 
@@ -54,7 +55,7 @@ _EXACT_MATCH_LIMIT = 500 ** 2
 
 # Will be parsed by setup.py to determine package metadata
 __author__ = 'Stefan Kögl <stefan@skoegl.net>'
-__version__ = '1.36'
+__version__ = '1.38'
 __website__ = 'https://github.com/stefankoegl/python-json-patch'
 __license__ = 'BSD-3-Clause'
 
@@ -100,13 +101,13 @@ _jsonloads = functools.partial(json.loads, object_pairs_hook=multidict)
 
 
 def apply_patch(doc, patch, in_place=False, pointer_cls=JsonPointer):
-    """Apply list of patches to specified json document.
+    """Apply patch operations to the specified JSON document.
 
-    :param doc: Document object.
-    :type doc: dict
+    :param doc: JSON document, including arrays and scalar values.
+    :type doc: object
 
-    :param patch: JSON patch as list of dicts or raw JSON-encoded string.
-    :type patch: list or str
+    :param patch: Iterable of operation dicts or a raw JSON-encoded string.
+    :type patch: iterable or str
 
     :param in_place: While ``True`` patch will modify target document.
                      By default patch will be applied to document copy.
@@ -115,8 +116,8 @@ def apply_patch(doc, patch, in_place=False, pointer_cls=JsonPointer):
     :param pointer_cls: JSON pointer class to use.
     :type pointer_cls: Type[JsonPointer]
 
-    :return: Patched document object.
-    :rtype: dict
+    :return: Resulting document, which may have a different type from ``doc``.
+    :rtype: object
 
     >>> doc = {'foo': 'bar'}
     >>> patch = [{'op': 'add', 'path': '/baz', 'value': 'qux'}]
@@ -145,11 +146,11 @@ def make_patch(src, dst, pointer_cls=JsonPointer):
     transforms `src` into `dst`, so it has to be applied to `src` (or to a
     document equal to it).
 
-    :param src: Data source document object.
-    :type src: dict
+    :param src: Source JSON document, including arrays and scalar values.
+    :type src: object
 
-    :param dst: Data target document object.
-    :type dst: dict
+    :param dst: Target JSON document, including arrays and scalar values.
+    :type dst: object
 
     :param pointer_cls: JSON pointer class to use.
     :type pointer_cls: Type[JsonPointer]
@@ -384,7 +385,7 @@ class MoveOperation(PatchOperation):
 
     @property
     def from_path(self):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         return '/'.join(from_ptr.parts[:-1])
 
     @property
@@ -396,14 +397,14 @@ class MoveOperation(PatchOperation):
         self.set_from_part(-1, value)
 
     def get_from_part(self, index):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         try:
             return int(from_ptr.parts[index])
         except ValueError:
             return from_ptr.parts[index]
 
     def set_from_part(self, index, value):
-        from_ptr = self.pointer_cls(self.operation['from'])
+        from_ptr = self._from_pointer()
         from_ptr.parts[index] = str(value)
         self.operation['from'] = from_ptr.path
 
@@ -457,7 +458,11 @@ class CopyOperation(PatchOperation):
 
 
 class JsonPatch(object):
-    """A JSON Patch is a list of Patch Operations.
+    """A JSON Patch is an iterable of Patch Operations.
+
+    Accepts sequences, iterators, generators, and other iterables of operation
+    dictionaries. Non-sequence inputs are materialized before validation so
+    the resulting patch can be applied repeatedly.
 
     >>> patch = JsonPatch([
     ...     {'op': 'add', 'path': '/foo', 'value': 'bar'},
@@ -515,9 +520,15 @@ class JsonPatch(object):
     })
 
     def __init__(self, patch, pointer_cls=JsonPointer):
-        self.patch = patch
         self.pointer_cls = pointer_cls
 
+        if isinstance(patch, (str, bytes, Mapping)):
+            raise InvalidJsonPatch("Document is expected to be sequence of operations")
+        try:
+            self.patch = patch if isinstance(patch, Sequence) else list(patch)
+        except TypeError:
+            raise InvalidJsonPatch("Document is expected to be sequence of operations")
+
         # Verify that the structure of the patch document
         # is correct by retrieving each patch element.
         # Much of the validation is done in the initializer
@@ -591,11 +602,11 @@ class JsonPatch(object):
         one. The resulting patch transforms `src` into `dst`, so it has to be
         applied to `src` (or to a document equal to it).
 
-        :param src: Data source document object.
-        :type src: dict
+        :param src: Source JSON document, including arrays and scalar values.
+        :type src: object
 
-        :param dst: Data target document object.
-        :type dst: dict
+        :param dst: Target JSON document, including arrays and scalar values.
+        :type dst: object
 
         :param optimization: Generate move operations for matching values.
                              Set to False to use only add, remove and replace.
@@ -636,14 +647,16 @@ class JsonPatch(object):
     def apply(self, obj, in_place=False):
         """Applies the patch to a given object.
 
-        :param obj: Document object.
-        :type obj: dict
+        :param obj: JSON document, including arrays and scalar values.
+        :type obj: object
 
         :param in_place: Tweaks the way how patch would be applied - directly to
                          specified `obj` or to its copy.
         :type in_place: bool
 
-        :return: Modified `obj`.
+        :return: Resulting document. Use this return value even with
+                 ``in_place=True``, because a root replacement returns a new
+                 value rather than modifying the original container.
         """
 
         if not in_place:

{jsonpatch-1.36 → jsonpatch-1.38}/jsonpatch_cli.py

@@ -12,8 +12,8 @@ import argparse
 
 jsondiff_parser = argparse.ArgumentParser(
     prog='jsondiff', description='Diff two JSON files')
-jsondiff_parser.add_argument('FILE1', type=argparse.FileType('r'))
-jsondiff_parser.add_argument('FILE2', type=argparse.FileType('r'))
+jsondiff_parser.add_argument('FILE1', type=argparse.FileType('r', encoding='utf-8'))
+jsondiff_parser.add_argument('FILE2', type=argparse.FileType('r', encoding='utf-8'))
 jsondiff_parser.add_argument('--indent', type=int, default=None,
                              help='Indent output by n spaces')
 jsondiff_parser.add_argument('-u', '--preserve-unicode', action='store_true',
@@ -43,9 +43,9 @@ def diff_files():
 jsonpatch_parser = argparse.ArgumentParser(
     prog='jsonpatch',
     description='Apply a JSON patch on a JSON file')
-jsonpatch_parser.add_argument('ORIGINAL', type=argparse.FileType('r'),
+jsonpatch_parser.add_argument('ORIGINAL', type=argparse.FileType('r', encoding='utf-8'),
                               help='Original file')
-jsonpatch_parser.add_argument('PATCH', type=argparse.FileType('r'),
+jsonpatch_parser.add_argument('PATCH', type=argparse.FileType('r', encoding='utf-8'),
                               nargs='?', default=sys.stdin,
                               help='Patch file (read from stdin if omitted)')
 jsonpatch_parser.add_argument('--indent', type=int, default=None,
@@ -78,6 +78,7 @@ def patch_files():
         args.ORIGINAL.close()
         dirname = os.path.abspath(os.path.dirname(args.ORIGINAL.name))
 
+        fd = None
         try:
             # Attempt to replace the file atomically.  We do this by
             # creating a temporary file in the same directory as the
@@ -86,17 +87,28 @@ def patch_files():
 	    # because atomic renames do not work across mount points.)
 
             fd, pathname = tempfile.mkstemp(dir=dirname)
-            fp = os.fdopen(fd, 'w')
+            fp = os.fdopen(fd, 'w', encoding='utf-8')
             atomic = True
 
         except OSError:
+            # mkstemp may have succeeded before fdopen failed. Neither the
+            # descriptor nor the temporary file belongs to the fallback.
+            if fd is not None:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+                try:
+                    os.unlink(pathname)
+                except OSError:
+                    pass
             # We failed to create the temporary file for an atomic
             # replace, so fall back to non-atomic mode by backing up
             # the original (if desired) and writing a new file.
 
             if args.backup:
                 os.rename(args.ORIGINAL.name, args.ORIGINAL.name + '.orig')
-            fp = open(args.ORIGINAL.name, 'w')
+            fp = open(args.ORIGINAL.name, 'w', encoding='utf-8')
             atomic = False
 
     else:
@@ -108,15 +120,26 @@ def patch_files():
     # By this point we have some sort of file object we can write the 
     # modified JSON to.
     
-    json.dump(result, fp, indent=args.indent, ensure_ascii=not(args.preserve_unicode))
-    fp.write('\n')
+    try:
+        json.dump(result, fp, indent=args.indent, ensure_ascii=not(args.preserve_unicode))
+        fp.write('\n')
+        if args.in_place:
+            fp.close()
+    except BaseException:
+        if args.in_place:
+            # Cleanup must not replace the original output error.
+            try:
+                fp.close()
+            except OSError:
+                pass
+            if atomic:
+                try:
+                    os.unlink(pathname)
+                except OSError:
+                    pass
+        raise
 
     if args.in_place:
-        # Close the new file.  If we aren't replacing atomically, this
-        # is our last step, since everything else is already in place.
-
-        fp.close()
-
         if atomic:
             try:
                 # Complete the atomic replace by linking the original

{jsonpatch-1.36 → jsonpatch-1.38}/property_tests.py

@@ -324,6 +324,15 @@ class MakePatchProperties(unittest.TestCase):
 
 class ApplyPatchProperties(unittest.TestCase):
 
+    @given(st.one_of(json_scalars, st.dictionaries(json_keys, json_docs)))
+    @example(patch={})
+    @example(patch='')
+    def test_non_array_patch_documents_are_rejected(self, patch):
+        with self.assertRaises(jsonpatch.InvalidJsonPatch):
+            jsonpatch.JsonPatch(patch)
+        with self.assertRaises(jsonpatch.InvalidJsonPatch):
+            jsonpatch.JsonPatch.from_string(json.dumps(patch))
+
     @given(docs_with_patches())
     def test_does_not_modify_document(self, case):
         doc, patch = case

{jsonpatch-1.36 → jsonpatch-1.38}/tests.py

@@ -21,6 +21,51 @@ from unittest import mock
 
 class ApplyPatchTestCase(unittest.TestCase):
 
+    def test_operation_iterators_remain_reusable_after_validation(self):
+        operations = [
+            {'op': 'add', 'path': '/a', 'value': 1},
+            {'op': 'replace', 'path': '/a', 'value': 2},
+        ]
+        class OneShotIterable:
+            def __init__(self, ops):
+                self.iterator = iter(ops)
+
+            def __iter__(self):
+                return self.iterator
+
+        for name, factory in (
+            ('iterator', iter),
+            ('generator', lambda ops: (op for op in ops)),
+            ('one-shot iterable', OneShotIterable),
+        ):
+            with self.subTest(name=name):
+                patch = jsonpatch.JsonPatch(factory(operations))
+                self.assertEqual(list(patch), operations)
+                self.assertEqual(json.loads(patch.to_string()), operations)
+                self.assertEqual(patch.apply({}), {'a': 2})
+                self.assertEqual(patch.apply({}), {'a': 2})
+
+    def test_empty_operation_iterator_is_false(self):
+        patch = jsonpatch.JsonPatch(iter([]))
+        self.assertFalse(patch)
+        self.assertEqual(patch.to_string(), '[]')
+
+    def test_invalid_operation_iterator_is_rejected(self):
+        operations = iter([
+            {'op': 'add', 'path': '/a', 'value': 1},
+            {'op': 'not-an-operation', 'path': '/a'},
+        ])
+        with self.assertRaises(jsonpatch.InvalidJsonPatch):
+            jsonpatch.JsonPatch(operations)
+
+    def test_sequence_operations_preserve_contents(self):
+        operations = [{'op': 'add', 'path': '/a', 'value': 1}]
+        for sequence in (operations, tuple(operations)):
+            with self.subTest(sequence=type(sequence).__name__):
+                patch = jsonpatch.JsonPatch(sequence)
+                self.assertEqual(list(patch), operations)
+                self.assertEqual(patch.apply({}), {'a': 1})
+
     def test_diff_without_optimization_uses_basic_operations(self):
         documents = [
             ({'old': {'value': 1}}, {'new': {'value': 1}}),
@@ -1533,6 +1578,35 @@ class JsonPointerTests(unittest.TestCase):
 
 class JsonPatchCreationTest(unittest.TestCase):
 
+    def test_creation_rejects_non_sequence_documents(self):
+        for patch in ({}, {'op': 'add', 'path': '/a', 'value': 1},
+                      MappingProxyType({}), '', b'', None, True, False,
+                      0, 1, 1.5):
+            with self.subTest(patch=patch):
+                with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                    jsonpatch.JsonPatch(patch)
+
+    def test_serialized_patch_rejects_non_array_documents(self):
+        for patch in ({}, {'op': 'add', 'path': '/a', 'value': 1},
+                      '', 'text', None, True, False, 0, 1, 1.5):
+            for serialized in (json.dumps(patch), json.dumps(patch).encode()):
+                with self.subTest(patch=serialized):
+                    with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                        jsonpatch.JsonPatch.from_string(serialized)
+                    doc = {'a': 'unchanged'}
+                    with self.assertRaises(jsonpatch.InvalidJsonPatch):
+                        jsonpatch.apply_patch(doc, serialized, in_place=True)
+                    self.assertEqual(doc, {'a': 'unchanged'})
+
+    def test_creation_preserves_operation_sequences(self):
+        for operations in ([], (),
+                           [{'op': 'add', 'path': '/a', 'value': 1}],
+                           ({'op': 'add', 'path': '/a', 'value': 1},)):
+            with self.subTest(operations=operations):
+                patch = jsonpatch.JsonPatch(operations)
+                self.assertIs(patch.patch, operations)
+                self.assertEqual(patch.apply({}), {'a': 1} if operations else {})
+
     def test_creation_fails_with_invalid_patch(self):
         invalid_patches = [
             {             'path': '/foo', 'value': 'bar'},
@@ -1676,6 +1750,34 @@ class OperationLocationTests(unittest.TestCase):
         self.assertEqual(operation, {'op': 'move', 'from': '/c~1d/0', 'path': '/b'})
         self.assertEqual(op.apply({'c/d': ['x']}), {'c/d': [], 'b': 'x'})
 
+    def test_from_path_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                op = jsonpatch.MoveOperation(
+                    {'op': 'move', 'from': pointer_cls('/a/1/b'), 'path': '/c'},
+                    pointer_cls=pointer_cls)
+                self.assertEqual(op.from_path, 'a/1')
+
+    def test_from_parts_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                op = jsonpatch.MoveOperation(
+                    {'op': 'move', 'from': pointer_cls('/a/1/b'), 'path': '/c'},
+                    pointer_cls=pointer_cls)
+                self.assertEqual(op.from_key, 'b')
+                self.assertEqual(op.get_from_part(1), 1)
+
+    def test_set_from_key_with_pointer_object(self):
+        for pointer_cls in (jsonpointer.JsonPointer, CustomJsonPointer):
+            with self.subTest(pointer_cls=pointer_cls):
+                operation = {'op': 'move', 'from': pointer_cls('/a/1'),
+                             'path': '/b'}
+                op = jsonpatch.MoveOperation(operation, pointer_cls=pointer_cls)
+                op.from_key = 0
+                self.assertEqual(operation['from'], '/a/0')
+                self.assertEqual(op.apply({'a': ['x', 'y']}),
+                                 {'a': ['y'], 'b': 'x'})
+
 
 class CustomJsonPointer(jsonpointer.JsonPointer):
     pass
@@ -1836,28 +1938,35 @@ class CommandLineTests(unittest.TestCase):
         self.addCleanup(tmp.cleanup)
         self.dir = tmp.name
 
-    def write(self, name, value):
+    def write(self, name, value, ensure_ascii=True):
         path = os.path.join(self.dir, name)
         with open(path, 'w', encoding='utf-8') as f:
-            json.dump(value, f)
+            json.dump(value, f, ensure_ascii=ensure_ascii)
         return path
 
     def read(self, path):
         with open(path, encoding='utf-8') as f:
             return json.load(f)
 
-    def run_script(self, script, *args, stdin=''):
+    def run_python(self, code, *args, stdin='', utf8=True):
         here = os.path.dirname(os.path.abspath(__file__))
         # the scripts have to import this jsonpatch, not an installed one
         pythonpath = [here] + [p for p in [os.environ.get('PYTHONPATH')] if p]
         env = dict(os.environ, PYTHONPATH=os.pathsep.join(pythonpath),
                    PYTHONUTF8='1')
+        if not utf8:
+            # Exercise locale-dependent file I/O while keeping pipes in UTF-8.
+            env.update(PYTHONUTF8='0', PYTHONIOENCODING='utf-8',
+                       LC_ALL='C', PYTHONCOERCECLOCALE='0')
         return subprocess.run(
-            [sys.executable, '-c',
-             'import jsonpatch_cli; jsonpatch_cli.{0}_main()'.format(script)]
-            + list(args),
+            [sys.executable, '-c', code] + list(args),
             input=stdin, capture_output=True, encoding='utf-8', env=env)
 
+    def run_script(self, script, *args, stdin='', utf8=True):
+        return self.run_python(
+            'import jsonpatch_cli; jsonpatch_cli.{0}_main()'.format(script),
+            *args, stdin=stdin, utf8=utf8)
+
     def test_jsondiff(self):
         src = self.write('a.json', {'a': [1, 2], 'b': 0})
         dst = self.write('b.json', {'a': [1, 2, 3], 'c': 100})
@@ -1887,6 +1996,18 @@ class CommandLineTests(unittest.TestCase):
         self.assertIn('"\\u00e4"', self.run_script('jsondiff', src, dst).stdout)
         self.assertIn('"ä"', self.run_script('jsondiff', '-u', src, dst).stdout)
 
+    def test_jsondiff_utf8_files_without_utf8_mode(self):
+        src = self.write('a.json', {'a': 'old', 'unchanged': 'ä'},
+                         ensure_ascii=False)
+        dst = self.write('b.json', {'a': '🚀', 'unchanged': 'ä'},
+                         ensure_ascii=False)
+        res = self.run_script('jsondiff', src, dst, utf8=False)
+        self.assertEqual(res.returncode, 1, res.stderr)
+        patch = json.loads(res.stdout)
+        self.assertEqual(patch, [{'op': 'replace', 'path': '/a', 'value': '🚀'}])
+        self.assertEqual(jsonpatch.apply_patch(self.read(src), patch),
+                         self.read(dst))
+
     def test_jsonpatch(self):
         doc = self.write('doc.json', {'a': [1, 2], 'b': 0})
         patch = self.write('patch.json', [{'op': 'add', 'path': '/a/-', 'value': 3},
@@ -1903,6 +2024,17 @@ class CommandLineTests(unittest.TestCase):
         self.assertEqual(res.returncode, 0, res.stderr)
         self.assertEqual(json.loads(res.stdout), {'a': 2})
 
+    def test_jsonpatch_utf8_files_without_utf8_mode(self):
+        doc = self.write('doc.json', {'a': 'ä'}, ensure_ascii=False)
+        patch = self.write('patch.json', [
+            {'op': 'test', 'path': '/a', 'value': 'ä'},
+            {'op': 'replace', 'path': '/a', 'value': '🚀'},
+        ], ensure_ascii=False)
+        res = self.run_script('jsonpatch', doc, patch, utf8=False)
+        self.assertEqual(res.returncode, 0, res.stderr)
+        self.assertEqual(json.loads(res.stdout), {'a': '🚀'})
+        self.assertEqual(self.read(doc), {'a': 'ä'})
+
     def test_jsonpatch_indent_preserve_unicode(self):
         doc = self.write('doc.json', {'a': 'x'})
         patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 'ä'}])
@@ -1920,6 +2052,28 @@ class CommandLineTests(unittest.TestCase):
         # the temporary file has been moved over the original
         self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
 
+    def test_jsonpatch_in_place_utf8_without_utf8_mode(self):
+        for atomic in (True, False):
+            with self.subTest(atomic=atomic):
+                doc = self.write('doc.json', {'a': 'old'})
+                patch = self.write('patch.json', [
+                    {'op': 'replace', 'path': '/a', 'value': '🚀'},
+                ])
+                if atomic:
+                    code = 'import jsonpatch_cli; jsonpatch_cli.jsonpatch_main()'
+                else:
+                    code = (
+                        'from unittest import mock\n'
+                        'import jsonpatch_cli\n'
+                        'with mock.patch("tempfile.mkstemp", side_effect=OSError):\n'
+                        '    jsonpatch_cli.jsonpatch_main()\n'
+                    )
+                res = self.run_python(code, '-i', '-u', doc, patch, utf8=False)
+                self.assertEqual((res.returncode, res.stdout), (0, ''), res.stderr)
+                self.assertEqual(self.read(doc), {'a': '🚀'})
+                self.assertEqual(sorted(os.listdir(self.dir)),
+                                 ['doc.json', 'patch.json'])
+
     # 2026-10-11: Windows cannot replace the original while its input is open.
     def test_jsonpatch_in_place_closes_original_before_replace(self):
         doc = self.write('doc.json', {'a': 1})
@@ -1956,6 +2110,94 @@ class CommandLineTests(unittest.TestCase):
         self.assertEqual(self.read(doc), {'a': 2})
         self.assertEqual(self.read(doc + '.orig'), {'a': 1})
 
+    def test_jsonpatch_in_place_cleans_temp_on_output_error(self):
+        for phase in ('dump', 'newline', 'close', 'dump_and_close'):
+            with self.subTest(phase=phase):
+                tmp = tempfile.TemporaryDirectory()
+                self.addCleanup(tmp.cleanup)
+                self.dir = tmp.name
+                doc = self.write('doc.json', {'a': 1})
+                patch = self.write('patch.json', [])
+                args = jsonpatch_cli.jsonpatch_parser.parse_args(['-i', doc, patch])
+                self.addCleanup(args.ORIGINAL.close)
+                self.addCleanup(args.PATCH.close)
+                failure = OSError('output failed')
+                opened = []
+                fdopen = os.fdopen
+
+                def open_output(fd, mode, **kwargs):
+                    stream = fdopen(fd, mode, **kwargs)
+                    self.addCleanup(stream.close)
+                    opened.append(stream)
+                    proxy = mock.Mock(wraps=stream)
+                    if phase == 'newline':
+                        proxy.write.side_effect = lambda value: (
+                            stream.write(value) if value != '\n' else fail())
+                    if phase in ('close', 'dump_and_close'):
+                        def close():
+                            stream.close()
+                            raise failure if phase == 'close' else OSError('close failed')
+                        proxy.close.side_effect = close
+                    return proxy
+
+                def fail():
+                    raise failure
+
+                def dump(value, stream, **kwargs):
+                    stream.write('{')
+                    if phase in ('dump', 'dump_and_close'):
+                        raise failure
+
+                with mock.patch.object(jsonpatch_cli.jsonpatch_parser, 'parse_args',
+                                       return_value=args), \
+                        mock.patch('os.fdopen', side_effect=open_output), \
+                        mock.patch('json.dump', side_effect=dump):
+                    with self.assertRaises(OSError) as caught:
+                        jsonpatch_cli.patch_files()
+                self.assertIs(caught.exception, failure)
+                self.assertTrue(opened[0].closed)
+                self.assertEqual(self.read(doc), {'a': 1})
+                self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_cleans_temp_on_fdopen_error(self):
+        for backup in (False, True):
+            with self.subTest(backup=backup):
+                tmp = tempfile.TemporaryDirectory()
+                self.addCleanup(tmp.cleanup)
+                self.dir = tmp.name
+                doc = self.write('doc.json', {'a': 1})
+                patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
+                parser = jsonpatch_cli.jsonpatch_parser
+                args = parser.parse_args(['-i', doc, patch] + (['-b'] if backup else []))
+                self.addCleanup(args.ORIGINAL.close)
+                self.addCleanup(args.PATCH.close)
+                descriptors = []
+
+                def close_if_open(fd):
+                    try:
+                        os.close(fd)
+                    except OSError:
+                        pass
+
+                def fail_fdopen(fd, *args, **kwargs):
+                    descriptors.append(fd)
+                    self.addCleanup(close_if_open, fd)
+                    raise OSError('cannot wrap temporary descriptor')
+
+                with mock.patch.object(parser, 'parse_args', return_value=args), \
+                        mock.patch('os.fdopen', side_effect=fail_fdopen):
+                    jsonpatch_cli.patch_files()
+
+                self.assertEqual(self.read(doc), {'a': 2})
+                if backup:
+                    self.assertEqual(self.read(doc + '.orig'), {'a': 1})
+                with self.assertRaises(OSError):
+                    os.fstat(descriptors[0])
+                expected = ['doc.json', 'patch.json']
+                if backup:
+                    expected.append('doc.json.orig')
+                self.assertEqual(sorted(os.listdir(self.dir)), sorted(expected))
+
     def test_jsonpatch_in_place_preserves_original_on_replace_error(self):
         doc = self.write('doc.json', {'a': 1})
         patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])