jsonpatch 1.37__tar.gz → 1.38__tar.gz

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

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

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

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

{jsonpatch-1.37 → 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.37'
+__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]
@@ -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,13 +520,12 @@ 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:
-            patch_iter = iter(patch)
+            self.patch = patch if isinstance(patch, Sequence) else list(patch)
         except TypeError:
             raise InvalidJsonPatch("Document is expected to be sequence of operations")
 
@@ -529,7 +533,7 @@ class JsonPatch(object):
         # is correct by retrieving each patch element.
         # Much of the validation is done in the initializer
         # though some is delayed until the patch is applied.
-        for op in patch_iter:
+        for op in self.patch:
             # We're only checking for strings in the following check
             # for two reasons:
             #
@@ -598,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.
@@ -643,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.37 → jsonpatch-1.38}/jsonpatch_cli.py

@@ -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
@@ -90,6 +91,17 @@ def patch_files():
             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.

{jsonpatch-1.37 → 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}}),
@@ -2114,6 +2159,45 @@ class CommandLineTests(unittest.TestCase):
                 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}])