jsonpatch 1.35__tar.gz → 1.36__tar.gz

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

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

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

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

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

@@ -54,7 +54,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.35'
+__version__ = '1.36'
 __website__ = 'https://github.com/stefankoegl/python-json-patch'
 __license__ = 'BSD-3-Clause'
 
@@ -597,6 +597,10 @@ class JsonPatch(object):
         :param dst: Data target document object.
         :type dst: dict
 
+        :param optimization: Generate move operations for matching values.
+                             Set to False to use only add, remove and replace.
+        :type optimization: bool
+
         :param dumps: A function of one argument that produces a serialized
                       JSON string.
         :type dumps: Callable
@@ -614,7 +618,8 @@ class JsonPatch(object):
         True
         """
         json_dumper = dumps or cls.json_dumper
-        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls)
+        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls,
+                              optimization=optimization)
         builder._compare_values((), None, src, dst)
         ops = list(builder.execute())
         return cls(ops, pointer_cls=pointer_cls)
@@ -670,9 +675,11 @@ class JsonPatch(object):
 
 class DiffBuilder(object):
 
-    def __init__(self, src_doc, dst_doc, dumps=json.dumps, pointer_cls=JsonPointer):
+    def __init__(self, src_doc, dst_doc, dumps=json.dumps, pointer_cls=JsonPointer,
+                 optimization=True):
         self.dumps = dumps
         self.pointer_cls = pointer_cls
+        self.optimization = optimization
         self.index_storage = [{}, {}]
         self.__root = root = []
         self.src_doc = src_doc
@@ -693,10 +700,14 @@ class DiffBuilder(object):
             return id(value)
 
     def store_index(self, value, index, st):
+        if not self.optimization:
+            return
         storage = self.index_storage[st]
         storage.setdefault(self._move_key(value), []).append(index)
 
     def take_index(self, value, st):
+        if not self.optimization:
+            return None
         stored = self.index_storage[st].get(self._move_key(value))
         if stored:
             return stored.pop()

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

@@ -126,12 +126,11 @@ def patch_files():
                 if args.backup:
                     os.link(args.ORIGINAL.name, args.ORIGINAL.name + '.orig')
                 os.chmod(pathname, os.stat(args.ORIGINAL.name).st_mode)
-                os.rename(pathname, args.ORIGINAL.name)
+                os.replace(pathname, args.ORIGINAL.name)
 
             except OSError:
-                # In the event we could not actually do the atomic
-                # replace, unlink the original to move it out of the
-                # way and finally move the temporary file into place.
-                
-                os.unlink(args.ORIGINAL.name)
-                os.rename(pathname, args.ORIGINAL.name)
+                # Preserve the original if backup, permissions, or replacement
+                # fails. replace() can overwrite an existing file on Windows
+                # without unlinking it first.
+                os.unlink(pathname)
+                raise

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

@@ -290,6 +290,15 @@ class MakePatchProperties(unittest.TestCase):
     def test_roundtrip(self, docs):
         self.check_roundtrip(*docs)
 
+    @given(doc_pairs)
+    def test_roundtrip_without_move_optimization(self, docs):
+        src, dst = docs
+        patch = jsonpatch.JsonPatch.from_diff(src, dst, optimization=False)
+        note(patch.patch)
+        self.assertTrue(all(op['op'] in ('add', 'remove', 'replace')
+                            for op in patch))
+        assert_json_equal(patch.apply(src), dst)
+
     @given(safe_doc_pairs)
     # the diff considered e.g. 1 and true equal, #180
     @example(docs=([0], [False]))

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

@@ -21,6 +21,25 @@ from unittest import mock
 
 class ApplyPatchTestCase(unittest.TestCase):
 
+    def test_diff_without_optimization_uses_basic_operations(self):
+        documents = [
+            ({'old': {'value': 1}}, {'new': {'value': 1}}),
+            ([1, 2, 3], [3, 1, 2]),
+            ([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}]),
+            ({'a/b': [1, 2]}, {'~key': [1, 2]}),
+        ]
+        for src, dst in documents:
+            with self.subTest(src=src, dst=dst):
+                original = copy.deepcopy(src)
+                patch = jsonpatch.JsonPatch.from_diff(
+                    src, dst, optimization=False)
+                self.assertTrue(all(operation['op'] in
+                                    ('add', 'remove', 'replace')
+                                    for operation in patch))
+                self.assertEqual(patch.apply(src), dst)
+                self.assertEqual(src, original)
+
+
     def test_js_file(self):
         with open('./tests.js', 'r') as f:
             tests = json.load(f)
@@ -1902,21 +1921,21 @@ class CommandLineTests(unittest.TestCase):
         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_rename(self):
+    def test_jsonpatch_in_place_closes_original_before_replace(self):
         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])
         self.addCleanup(args.ORIGINAL.close)
         self.addCleanup(args.PATCH.close)
-        rename = os.rename
+        replace = os.replace
 
-        def rename_closed_original(source, target):
+        def replace_closed_original(source, target):
             self.assertTrue(args.ORIGINAL.closed)
-            return rename(source, target)
+            return replace(source, target)
 
         with mock.patch.object(parser, 'parse_args', return_value=args), \
-                mock.patch('os.rename', side_effect=rename_closed_original):
+                mock.patch('os.replace', side_effect=replace_closed_original):
             jsonpatch_cli.patch_files()
         self.assertEqual(self.read(doc), {'a': 2})
 
@@ -1937,6 +1956,52 @@ class CommandLineTests(unittest.TestCase):
         self.assertEqual(self.read(doc), {'a': 2})
         self.assertEqual(self.read(doc + '.orig'), {'a': 1})
 
+    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}])
+        parser = jsonpatch_cli.jsonpatch_parser
+        args = parser.parse_args(['-i', doc, patch])
+        self.addCleanup(args.ORIGINAL.close)
+        self.addCleanup(args.PATCH.close)
+
+        with mock.patch.object(parser, 'parse_args', return_value=args), \
+                mock.patch('os.rename', side_effect=PermissionError('cannot replace')), \
+                mock.patch('os.replace', side_effect=PermissionError('cannot replace')):
+            with self.assertRaises(PermissionError):
+                jsonpatch_cli.patch_files()
+
+        self.assertTrue(os.path.exists(doc))
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_preserves_original_on_chmod_error(self):
+        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])
+        self.addCleanup(args.ORIGINAL.close)
+        self.addCleanup(args.PATCH.close)
+
+        with mock.patch.object(parser, 'parse_args', return_value=args), \
+                mock.patch('os.chmod', side_effect=PermissionError('cannot chmod')):
+            with self.assertRaises(PermissionError):
+                jsonpatch_cli.patch_files()
+
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(sorted(os.listdir(self.dir)), ['doc.json', 'patch.json'])
+
+    def test_jsonpatch_in_place_existing_backup(self):
+        doc = self.write('doc.json', {'a': 1})
+        patch = self.write('patch.json', [{'op': 'replace', 'path': '/a', 'value': 2}])
+        backup = self.write('doc.json.orig', {'previous': True})
+        res = self.run_script('jsonpatch', '-i', '-b', doc, patch)
+
+        self.assertNotEqual(res.returncode, 0)
+        self.assertEqual(self.read(doc), {'a': 1})
+        self.assertEqual(self.read(backup), {'previous': True})
+        self.assertEqual(sorted(os.listdir(self.dir)),
+                         ['doc.json', 'doc.json.orig', 'patch.json'])
+
     def test_jsonpatch_in_place_failing_patch(self):
         # the patch is applied before the file is replaced, so it is kept
         doc = self.write('doc.json', {'a': 1})