Migrate to pyproject.toml

Author: cunla

.github/workflows/test.yaml

@@ -43,16 +43,13 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+      - name: "Setup Python, Poetry and Dependencies"
+        uses: dsoftwareinc/setup-python-poetry-action@v1
         with:
           python-version: ${{ matrix.python-version }}
-          allow-prereleases: true
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements-dev.txt
+          poetry-version: 1.8.3
 
       - name: Test
         run: |
-          make coverage
+          poetry run coverage run -m unittest
+          coverage report -m

AUTHORS

@@ -31,318 +31,28 @@
 #
 
 """ Identify specific nodes in a JSON document (RFC 6901) """
+from .jsonpointer import JsonPointerException, JsonPointer, resolve_pointer, set_pointer, EndOfList
 
-# Will be parsed by setup.py to determine package metadata
-__author__ = 'Stefan Kögl <stefan@skoegl.net>'
-__version__ = '3.0.0'
-__website__ = 'https://github.com/stefankoegl/python-json-pointer'
-__license__ = 'Modified BSD License'
-
-import copy
-import re
-from collections.abc import Mapping, Sequence
-from itertools import tee, chain
-
-_nothing = object()
-
-
-def set_pointer(doc, pointer, value, inplace=True):
-    """Resolves a pointer against doc and sets the value of the target within doc.
-
-    With inplace set to true, doc is modified as long as pointer is not the
-    root.
-
-    >>> obj = {'foo': {'anArray': [ {'prop': 44}], 'another prop': {'baz': 'A string' }}}
-
-    >>> set_pointer(obj, '/foo/anArray/0/prop', 55) == \
-    {'foo': {'another prop': {'baz': 'A string'}, 'anArray': [{'prop': 55}]}}
-    True
-
-    >>> set_pointer(obj, '/foo/yet another prop', 'added prop') == \
-    {'foo': {'another prop': {'baz': 'A string'}, 'yet another prop': 'added prop', 'anArray': [{'prop': 55}]}}
-    True
-
-    >>> obj = {'foo': {}}
-    >>> set_pointer(obj, '/foo/a%20b', 'x') == \
-    {'foo': {'a%20b': 'x' }}
-    True
-    """
-
-    pointer = JsonPointer(pointer)
-    return pointer.set(doc, value, inplace)
-
-
-def resolve_pointer(doc, pointer, default=_nothing):
-    """ Resolves pointer against doc and returns the referenced object
-
-    >>> obj = {'foo': {'anArray': [ {'prop': 44}], 'another prop': {'baz': 'A string' }}, 'a%20b': 1, 'c d': 2}
-
-    >>> resolve_pointer(obj, '') == obj
-    True
-
-    >>> resolve_pointer(obj, '/foo') == obj['foo']
-    True
-
-    >>> resolve_pointer(obj, '/foo/another prop') == obj['foo']['another prop']
-    True
-
-    >>> resolve_pointer(obj, '/foo/another prop/baz') == obj['foo']['another prop']['baz']
-    True
-
-    >>> resolve_pointer(obj, '/foo/anArray/0') == obj['foo']['anArray'][0]
-    True
-
-    >>> resolve_pointer(obj, '/some/path', None) == None
-    True
-
-    >>> resolve_pointer(obj, '/a b', None) == None
-    True
-
-    >>> resolve_pointer(obj, '/a%20b') == 1
-    True
-
-    >>> resolve_pointer(obj, '/c d') == 2
-    True
-
-    >>> resolve_pointer(obj, '/c%20d', None) == None
-    True
-    """
-
-    pointer = JsonPointer(pointer)
-    return pointer.resolve(doc, default)
-
-
-def pairwise(iterable):
-    """ Transforms a list to a list of tuples of adjacent items
-
-    s -> (s0,s1), (s1,s2), (s2, s3), ...
-
-    >>> list(pairwise([]))
-    []
-
-    >>> list(pairwise([1]))
-    []
-
-    >>> list(pairwise([1, 2, 3, 4]))
-    [(1, 2), (2, 3), (3, 4)]
-    """
-    a, b = tee(iterable)
-    for _ in b:
-        break
-    return zip(a, b)
-
-
-class JsonPointerException(Exception):
-    pass
-
-
-class EndOfList(object):
-    """Result of accessing element "-" of a list"""
-
-    def __init__(self, list_):
-        self.list_ = list_
-
-    def __repr__(self):
-        return '{cls}({lst})'.format(cls=self.__class__.__name__,
-                                     lst=repr(self.list_))
-
-
-class JsonPointer(object):
-    """A JSON Pointer that can reference parts of a JSON document"""
-
-    # Array indices must not contain:
-    # leading zeros, signs, spaces, decimals, etc
-    _RE_ARRAY_INDEX = re.compile('0|[1-9][0-9]*$')
-    _RE_INVALID_ESCAPE = re.compile('(~[^01]|~$)')
-
-    def __init__(self, pointer):
-
-        # validate escapes
-        invalid_escape = self._RE_INVALID_ESCAPE.search(pointer)
-        if invalid_escape:
-            raise JsonPointerException('Found invalid escape {}'.format(
-                invalid_escape.group()))
-
-        parts = pointer.split('/')
-        if parts.pop(0) != '':
-            raise JsonPointerException('Location must start with /')
-
-        parts = [unescape(part) for part in parts]
-        self.parts = parts
-
-    def to_last(self, doc):
-        """Resolves ptr until the last step, returns (sub-doc, last-step)"""
-
-        if not self.parts:
-            return doc, None
-
-        for part in self.parts[:-1]:
-            doc = self.walk(doc, part)
-
-        return doc, JsonPointer.get_part(doc, self.parts[-1])
+try:
+    from importlib import metadata
+except ImportError:  # for Python < 3.8
+    import importlib_metadata as metadata  # type: ignore
 
-    def resolve(self, doc, default=_nothing):
-        """Resolves the pointer against doc and returns the referenced object"""
-
-        for part in self.parts:
-
-            try:
-                doc = self.walk(doc, part)
-            except JsonPointerException:
-                if default is _nothing:
-                    raise
-                else:
-                    return default
-
-        return doc
-
-    get = resolve
-
-    def set(self, doc, value, inplace=True):
-        """Resolve the pointer against the doc and replace the target with value."""
-
-        if len(self.parts) == 0:
-            if inplace:
-                raise JsonPointerException('Cannot set root in place')
-            return value
-
-        if not inplace:
-            doc = copy.deepcopy(doc)
-
-        (parent, part) = self.to_last(doc)
-
-        if isinstance(parent, Sequence) and part == '-':
-            parent.append(value)
-        else:
-            parent[part] = value
-
-        return doc
-
-    @classmethod
-    def get_part(cls, doc, part):
-        """Returns the next step in the correct type"""
-
-        if isinstance(doc, Mapping):
-            return part
-
-        elif isinstance(doc, Sequence):
-
-            if part == '-':
-                return part
-
-            if not JsonPointer._RE_ARRAY_INDEX.match(str(part)):
-                raise JsonPointerException("'%s' is not a valid sequence index" % part)
-
-            return int(part)
-
-        elif hasattr(doc, '__getitem__'):
-            # Allow indexing via ducktyping
-            # if the target has defined __getitem__
-            return part
-
-        else:
-            raise JsonPointerException("Document '%s' does not support indexing, "
-                                       "must be mapping/sequence or support __getitem__" % type(doc))
-
-    def get_parts(self):
-        """Returns the list of the parts. For example, JsonPointer('/a/b').get_parts() == ['a', 'b']"""
-
-        return self.parts
-
-    def walk(self, doc, part):
-        """ Walks one step in doc and returns the referenced part """
-
-        part = JsonPointer.get_part(doc, part)
-
-        assert hasattr(doc, '__getitem__'), "invalid document type %s" % (type(doc),)
-
-        if isinstance(doc, Sequence):
-            if part == '-':
-                return EndOfList(doc)
-
-            try:
-                return doc[part]
-
-            except IndexError:
-                raise JsonPointerException("index '%s' is out of bounds" % (part,))
-
-        # Else the object is a mapping or supports __getitem__(so assume custom indexing)
-        try:
-            return doc[part]
-
-        except KeyError:
-            raise JsonPointerException("member '%s' not found in %s" % (part, doc))
-
-    def contains(self, ptr):
-        """ Returns True if self contains the given ptr """
-        return self.parts[:len(ptr.parts)] == ptr.parts
-
-    def __contains__(self, item):
-        """ Returns True if self contains the given ptr """
-        return self.contains(item)
-
-    def join(self, suffix):
-        """ Returns a new JsonPointer with the given suffix append to this ptr """
-        if isinstance(suffix, JsonPointer):
-            suffix_parts = suffix.parts
-        elif isinstance(suffix, str):
-            suffix_parts = JsonPointer(suffix).parts
-        else:
-            suffix_parts = suffix
-        try:
-            return JsonPointer.from_parts(chain(self.parts, suffix_parts))
-        except:  # noqa E722
-            raise JsonPointerException("Invalid suffix")
-
-    def __truediv__(self, suffix):  # Python 3
-        return self.join(suffix)
-
-    @property
-    def path(self):
-        """Returns the string representation of the pointer
-
-        >>> ptr = JsonPointer('/~0/0/~1').path == '/~0/0/~1'
-        """
-        parts = [escape(part) for part in self.parts]
-        return ''.join('/' + part for part in parts)
-
-    def __eq__(self, other):
-        """Compares a pointer to another object
-
-        Pointers can be compared by comparing their strings (or splitted
-        strings), because no two different parts can point to the same
-        structure in an object (eg no different number representations)
-        """
-
-        if not isinstance(other, JsonPointer):
-            return False
-
-        return self.parts == other.parts
-
-    def __hash__(self):
-        return hash(tuple(self.parts))
-
-    def __str__(self):
-        return self.path
-
-    def __repr__(self):
-        return type(self).__name__ + "(" + repr(self.path) + ")"
-
-    @classmethod
-    def from_parts(cls, parts):
-        """Constructs a JsonPointer from a list of (unescaped) paths
-
-        >>> JsonPointer.from_parts(['a', '~', '/', 0]).path == '/a/~0/~1/0'
-        True
-        """
-        parts = [escape(str(part)) for part in parts]
-        ptr = cls(''.join('/' + part for part in parts))
-        return ptr
-
-
-def escape(s):
-    return s.replace('~', '~0').replace('/', '~1')
-
-
-def unescape(s):
-    return s.replace('~1', '/').replace('~0', '~')
+# Will be parsed by setup.py to determine package metadata
+jsonpointer_metadata = metadata.metadata("jsonpointer")
+__author__ = jsonpointer_metadata["Author"]
+__version__ = metadata.version("jsonpointer")
+__website__ = jsonpointer_metadata["Home-page"]
+__license__ = jsonpointer_metadata["License"]
+
+__all__ = [
+    "resolve_pointer",
+    "set_pointer",
+    "JsonPointerException",
+    "JsonPointer",
+    "EndOfList",
+    "__author__",
+    "__version__",
+    "__website__",
+    "__license__",
+]