jsonpointer 3.1.1__tar.gz → 3.2.0__tar.gz

{jsonpointer-3.1.1/jsonpointer.egg-info → jsonpointer-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpointer
-Version: 3.1.1
+Version: 3.2.0
 Summary:  Identify specific nodes in a JSON document (RFC 6901) 
 Home-page: https://github.com/stefankoegl/python-json-pointer
 Author: Stefan Kögl

jsonpointer-3.2.0/bin/jsonpointer

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+
+import argparse
+import json
+import sys
+
+import jsonpointer
+
+parser = argparse.ArgumentParser(
+    description='Resolve a JSON pointer on JSON files')
+
+# Accept pointer as option, as file or as first positional argument
+ptr_group = parser.add_mutually_exclusive_group()
+
+ptr_group.add_argument('-f', '--pointer-file', type=argparse.FileType('r'),
+                       help='File containing a JSON pointer expression')
+
+ptr_group.add_argument('-p', '--pointer', type=str,
+                       help='A JSON pointer expression')
+
+parser.add_argument('POINTER', type=str, nargs='?',
+                    help='A JSON pointer expression (if neither -f nor -p '
+                         'is given)')
+
+parser.add_argument('FILE', type=str, nargs='+',
+                    help='Files for which the pointer should be resolved')
+parser.add_argument('--indent', type=int, default=None,
+                    help='Indent output by n spaces')
+parser.add_argument('-v', '--version', action='version',
+                    version='%(prog)s ' + jsonpointer.__version__)
+
+
+def main():
+    try:
+        ok = resolve_files()
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+    if not ok:
+        sys.exit(1)
+
+
+def parse_pointer(args):
+    """ Return the pointer and the list of files to resolve it on
+
+    If the pointer is given via -f or -p, a POINTER positional argument is
+    actually the first file. """
+    files = args.FILE
+
+    if args.pointer is not None or args.pointer_file is not None:
+        if args.POINTER is not None:
+            files = [args.POINTER] + files
+
+        if args.pointer is not None:
+            ptr = args.pointer
+        else:
+            ptr = args.pointer_file.read().strip()
+
+    elif args.POINTER is not None:
+        ptr = args.POINTER
+
+    else:
+        parser.error('a JSON pointer is required (POINTER, -p or -f)')
+
+    # Catches e.g. `jsonpointer a.json b.json`, where the pointer was omitted
+    # and the first file would otherwise be used as the pointer
+    try:
+        jsonpointer.JsonPointer(ptr)
+    except jsonpointer.JsonPointerException as e:
+        parser.error('invalid JSON pointer %r: %s' % (ptr, e))
+
+    return ptr, files
+
+
+def resolve_files():
+    """ Resolve a JSON pointer on JSON files
+
+    Returns False if the pointer could not be resolved on at least one
+    file. """
+    args = parser.parse_args()
+
+    ptr, files = parse_pointer(args)
+    ok = True
+
+    for name in files:
+        try:
+            f = argparse.FileType('r')(name)
+        except argparse.ArgumentTypeError as e:
+            parser.error(str(e))
+
+        doc = json.load(f)
+        try:
+            result = jsonpointer.resolve_pointer(doc, ptr)
+            print(json.dumps(result, indent=args.indent))
+        except jsonpointer.JsonPointerException as e:
+            print('Could not resolve pointer: %s' % str(e), file=sys.stderr)
+            ok = False
+
+    return ok
+
+
+if __name__ == "__main__":
+    main()

{jsonpointer-3.1.1 → jsonpointer-3.2.0/jsonpointer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jsonpointer
-Version: 3.1.1
+Version: 3.2.0
 Summary:  Identify specific nodes in a JSON document (RFC 6901) 
 Home-page: https://github.com/stefankoegl/python-json-pointer
 Author: Stefan Kögl

{jsonpointer-3.1.1 → jsonpointer-3.2.0}/jsonpointer.py

@@ -32,7 +32,7 @@
 
 # Will be parsed by setup.py to determine package metadata
 __author__ = 'Stefan Kögl <stefan@skoegl.net>'
-__version__ = '3.1.1'
+__version__ = '3.2.0'
 __website__ = 'https://github.com/stefankoegl/python-json-pointer'
 __license__ = 'Modified BSD License'
 
@@ -43,6 +43,10 @@ from itertools import tee, chain
 
 _nothing = object()
 
+# If True, exceptions include the doc content in the error message.
+# Set to False to suppress potentially large document content from exceptions.
+VERBOSE_EXCEPTIONS = True
+
 
 def set_pointer(doc, pointer, value, inplace=True):
     """Resolves a pointer against doc and sets the value of the target within doc.
@@ -209,10 +213,15 @@ class JsonPointer:
 
         (parent, part) = self.to_last(doc)
 
-        if isinstance(parent, Sequence) and part == '-':
+        if isinstance(parent, str):
+            raise JsonPointerException("Cannot set value in a string")
+        elif isinstance(parent, Sequence) and part == '-':
             parent.append(value)
         else:
-            parent[part] = value
+            try:
+                parent[part] = value
+            except (TypeError, IndexError) as e:
+                raise JsonPointerException("Invalid assignment target: %s" % (e,))
 
         return doc
 
@@ -223,6 +232,9 @@ class JsonPointer:
         if isinstance(doc, Mapping):
             return part
 
+        elif isinstance(doc, str):
+            raise JsonPointerException("Cannot apply token '%s' to non-container type %s" % (part, type(doc)))
+
         elif isinstance(doc, Sequence):
 
             if part == '-':
@@ -231,7 +243,10 @@ class JsonPointer:
             if not JsonPointer._RE_ARRAY_INDEX.fullmatch(str(part)):
                 raise JsonPointerException("'%s' is not a valid sequence index" % part)
 
-            return int(part)
+            try:
+                return int(part)
+            except ValueError as e:
+                raise JsonPointerException("Invalid sequence index: %s" % (e,))
 
         elif hasattr(doc, '__getitem__'):
             # Allow indexing via ducktyping
@@ -269,7 +284,10 @@ class JsonPointer:
             return doc[part]
 
         except KeyError:
-            raise JsonPointerException("member '%s' not found in %s" % (part, doc))
+            if VERBOSE_EXCEPTIONS:
+                raise JsonPointerException("member '%s' not found in %s" % (part, doc))
+            else:
+                raise JsonPointerException("member '%s' not found" % (part,))
 
     def contains(self, ptr):
         """ Returns True if self contains the given ptr """
@@ -288,7 +306,7 @@ class JsonPointer:
         else:
             suffix_parts = suffix
         try:
-            return JsonPointer.from_parts(chain(self.parts, suffix_parts))
+            return self.__class__.from_parts(chain(self.parts, suffix_parts))
         except:  # noqa E722
             raise JsonPointerException("Invalid suffix")
 

{jsonpointer-3.1.1 → jsonpointer-3.2.0}/tests.py

@@ -2,6 +2,10 @@
 
 import copy
 import doctest
+import os
+import subprocess
+import sys
+import tempfile
 import unittest
 
 import jsonpointer
@@ -192,6 +196,31 @@ class ComparisonTests(unittest.TestCase):
         ptr12e = self.ptr1 / ["a", "b"]
         self.assertEqual(ptr12e.path, "/a/b/c/a/b")
 
+    def test_join_subclass(self):
+        class Pointer(JsonPointer):
+            pass
+
+        class OtherPointer(JsonPointer):
+            pass
+
+        ptr = Pointer("/a~1b")
+        suffixes = [JsonPointer("/m~0n"), Pointer("/m~0n"),
+                    OtherPointer("/m~0n"), "/m~0n", ["m~n"]]
+        for suffix in suffixes:
+            with self.subTest(suffix=suffix):
+                joined = ptr.join(suffix)
+                self.assertIs(type(joined), Pointer)
+                self.assertEqual(joined.path, "/a~1b/m~0n")
+        self.assertEqual(ptr.path, "/a~1b")
+
+    def test_join_magic_subclass(self):
+        class Pointer(JsonPointer):
+            pass
+
+        ptr = Pointer("/a") / JsonPointer("/b") / ["c"]
+        self.assertIs(type(ptr), Pointer)
+        self.assertEqual(ptr.path, "/a/b/c")
+
 
 class WrongInputTests(unittest.TestCase):
 
@@ -219,6 +248,54 @@ class WrongInputTests(unittest.TestCase):
         doc = [0, 1, 2]
         self.assertRaises(JsonPointerException, resolve_pointer, doc, '/01')
 
+    def test_string_not_indexable(self):
+        doc = {"foo": "should-not-be-indexable"}
+        self.assertRaises(JsonPointerException, resolve_pointer, doc, "/foo/0")
+
+        ptr = JsonPointer("/foo/0")
+        self.assertRaises(JsonPointerException, ptr.resolve, doc)
+
+
+@unittest.skipUnless(hasattr(sys, 'get_int_max_str_digits'),
+                     'Integer string conversion limits are not available')
+class LargeIndexTests(unittest.TestCase):
+
+    def setUp(self):
+        limit = sys.get_int_max_str_digits()
+        if not limit:
+            self.skipTest('Integer string conversion limit is disabled')
+        self.token = '1' * (limit + 1)
+        self.pointer = '/' + self.token
+
+    def test_resolve_large_index(self):
+        self.assertRaises(JsonPointerException, resolve_pointer,
+                          [0], self.pointer)
+
+    def test_resolve_large_index_default(self):
+        default = object()
+        self.assertIs(resolve_pointer([0], self.pointer, default), default)
+        self.assertIs(resolve_pointer({'items': [0]},
+                                      '/items' + self.pointer, default),
+                      default)
+
+    def test_to_last_large_index(self):
+        self.assertRaises(JsonPointerException,
+                          JsonPointer(self.pointer).to_last, [0])
+
+    def test_set_large_index(self):
+        for inplace in (True, False):
+            with self.subTest(inplace=inplace):
+                doc = [0]
+                self.assertRaises(JsonPointerException, set_pointer,
+                                  doc, self.pointer, 1, inplace=inplace)
+                self.assertEqual(doc, [0])
+
+    def test_large_numeric_object_member(self):
+        doc = {self.token: 'old'}
+        self.assertEqual(resolve_pointer(doc, self.pointer), 'old')
+        set_pointer(doc, self.pointer, 'new')
+        self.assertEqual(doc, {self.token: 'new'})
+
 
 class ToLastTests(unittest.TestCase):
 
@@ -394,6 +471,135 @@ class AltTypesTests(unittest.TestCase):
         self.assertRaises(JsonPointerException, resolve_pointer, doc, '/root/1/2/3/4')
 
 
+class CommandLineTests(unittest.TestCase):
+    """ Tests the jsonpointer command line utility """
+
+    ROOT = os.path.dirname(os.path.abspath(__file__))
+    SCRIPT = os.path.join(ROOT, 'bin', 'jsonpointer')
+
+    A_OUT = '[1, 2, 3]\n'
+    B_OUT = '{"b": [1, 3, 4]}\n'
+
+    def setUp(self):
+        tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(tmpdir.cleanup)
+        self.dir = tmpdir.name
+
+        self._write('a.json', '{ "a": [1, 2, 3] }')
+        self._write('b.json', '{ "a": {"b": [1, 3, 4]}, "b": 1 }')
+        self._write('ptr.txt', '/a\n')
+
+    def _write(self, name, content):
+        with open(os.path.join(self.dir, name), 'w') as f:
+            f.write(content)
+
+    def _run(self, *args):
+        env = dict(os.environ, PYTHONPATH=self.ROOT)
+        return subprocess.run([sys.executable, self.SCRIPT] + list(args),
+                              cwd=self.dir, env=env, capture_output=True,
+                              text=True)
+
+    def test_positional_pointer(self):
+        proc = self._run('/a', 'a.json', 'b.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, self.A_OUT + self.B_OUT)
+
+    def test_positional_pointer_single_file(self):
+        proc = self._run('/a', 'a.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, self.A_OUT)
+
+    def test_pointer_file(self):
+        proc = self._run('-f', 'ptr.txt', 'a.json', 'b.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, self.A_OUT + self.B_OUT)
+
+    def test_pointer_file_single_file(self):
+        proc = self._run('-f', 'ptr.txt', 'a.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, self.A_OUT)
+
+    def test_pointer_option(self):
+        proc = self._run('-p', '/a', 'a.json', 'b.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, self.A_OUT + self.B_OUT)
+
+    def test_no_pointer(self):
+        proc = self._run('a.json')
+        self.assertEqual(proc.returncode, 2)
+        self.assertIn('a JSON pointer is required', proc.stderr)
+
+    def test_missing_pointer_multiple_files(self):
+        proc = self._run('a.json', 'b.json')
+        self.assertEqual(proc.returncode, 2)
+        self.assertIn("invalid JSON pointer 'a.json'", proc.stderr)
+        self.assertEqual(proc.stdout, '')
+
+    def test_invalid_pointer_file(self):
+        self._write('bad.txt', 'a\n')
+        proc = self._run('-f', 'bad.txt', 'a.json')
+        self.assertEqual(proc.returncode, 2)
+        self.assertIn("invalid JSON pointer 'a'", proc.stderr)
+
+    def test_empty_pointer(self):
+        proc = self._run('', 'a.json')
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        self.assertEqual(proc.stdout, '{"a": [1, 2, 3]}\n')
+
+    def test_unresolvable_pointer(self):
+        proc = self._run('/x', 'a.json')
+        self.assertEqual(proc.returncode, 1)
+        self.assertIn('Could not resolve pointer', proc.stderr)
+        self.assertEqual(proc.stdout, '')
+
+    def test_unresolvable_pointer_in_one_file(self):
+        # /b resolves in b.json only; a.json is still reported but b.json
+        # is processed
+        proc = self._run('/b', 'a.json', 'b.json')
+        self.assertEqual(proc.returncode, 1)
+        self.assertIn('Could not resolve pointer', proc.stderr)
+        self.assertEqual(proc.stdout, '1\n')
+
+    def test_pointer_file_requires_value(self):
+        proc = self._run('-f', '-p', '/a', 'a.json')
+        self.assertEqual(proc.returncode, 2)
+        self.assertIn('expected one argument', proc.stderr)
+
+    def test_pointer_and_pointer_file_exclusive(self):
+        proc = self._run('-p', '/a', '-f', 'ptr.txt', 'a.json')
+        self.assertEqual(proc.returncode, 2)
+        self.assertIn('not allowed with', proc.stderr)
+
+
+class VerboseExceptionsTests(unittest.TestCase):
+
+    def setUp(self):
+        # Save original value and ensure verbose mode is on for each test
+        self._original = jsonpointer.VERBOSE_EXCEPTIONS
+        jsonpointer.VERBOSE_EXCEPTIONS = True
+
+    def tearDown(self):
+        jsonpointer.VERBOSE_EXCEPTIONS = self._original
+
+    def test_verbose_exception_includes_doc(self):
+        doc = {'foo': 1}
+        try:
+            resolve_pointer(doc, '/bar')
+            self.fail('Expected JsonPointerException')
+        except JsonPointerException as e:
+            self.assertIn(repr(doc), str(e))
+
+    def test_non_verbose_exception_excludes_doc(self):
+        doc = {'foo': 1}
+        jsonpointer.VERBOSE_EXCEPTIONS = False
+        try:
+            resolve_pointer(doc, '/bar')
+            self.fail('Expected JsonPointerException')
+        except JsonPointerException as e:
+            self.assertNotIn(repr(doc), str(e))
+            self.assertIn('bar', str(e))
+
+
 def load_tests(loader, tests, ignore):
     tests.addTests(doctest.DocTestSuite(jsonpointer))
     return tests

jsonpointer-3.1.1/bin/jsonpointer

@@ -1,66 +0,0 @@
-#!/usr/bin/env python3
-
-
-import argparse
-import json
-import sys
-
-import jsonpointer
-
-parser = argparse.ArgumentParser(
-    description='Resolve a JSON pointer on JSON files')
-
-# Accept pointer as argument or as file
-ptr_group = parser.add_mutually_exclusive_group(required=True)
-
-ptr_group.add_argument('-f', '--pointer-file', type=argparse.FileType('r'),
-                       nargs='?',
-                       help='File containing a JSON pointer expression')
-
-ptr_group.add_argument('POINTER', type=str, nargs='?',
-                       help='A JSON pointer expression')
-
-parser.add_argument('FILE', type=argparse.FileType('r'), nargs='+',
-                    help='Files for which the pointer should be resolved')
-parser.add_argument('--indent', type=int, default=None,
-                    help='Indent output by n spaces')
-parser.add_argument('-v', '--version', action='version',
-                    version='%(prog)s ' + jsonpointer.__version__)
-
-
-def main():
-    try:
-        resolve_files()
-    except KeyboardInterrupt:
-        sys.exit(1)
-
-
-def parse_pointer(args):
-    if args.POINTER:
-        ptr = args.POINTER
-    elif args.pointer_file:
-        ptr = args.pointer_file.read().strip()
-    else:
-        parser.print_usage()
-        sys.exit(1)
-
-    return ptr
-
-
-def resolve_files():
-    """ Resolve a JSON pointer on JSON files """
-    args = parser.parse_args()
-
-    ptr = parse_pointer(args)
-
-    for f in args.FILE:
-        doc = json.load(f)
-        try:
-            result = jsonpointer.resolve_pointer(doc, ptr)
-            print(json.dumps(result, indent=args.indent))
-        except jsonpointer.JsonPointerException as e:
-            print('Could not resolve pointer: %s' % str(e), file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()