3798344209

Build Type

push

github

Committed by Tristan Sweeney

Commit Message

Clean up a bit

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

285 of 294 relevant lines covered (96.94%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/fast_json_pointer/pointer.py

from __future__ import annotations

from dataclasses import dataclass
from typing import *

from . import rel_parser, rfc6901_parser


class _ReprStrMixin:
    def __repr__(self) -> str:
        # inner single quotes is consistent w/ how str.__repr__ works
        return f"{type(self).__name__}('{str(self)}')"


@dataclass(repr=False)
class JsonPointer(_ReprStrMixin):
    """Primitive dataclass for RFC 6901 json pointers.

    >>> JsonPointer(['~home', 'foo.txt', 'mime/type'])
    JsonPointer('/~0home/foo.txt/mime~1type')
    >>> JsonPointer.parse('/~0home/foo.txt/mime~1type')
    JsonPointer('/~0home/foo.txt/mime~1type')
    """

    parts: list[str]
    """Unescaped list of path parts.
    
    >>> JsonPointer.parse("/data/items/0/id").parts
    ['data', 'items', '0', 'id']
    """

    def __str__(self) -> str:
        """Serialize to RFC 6901 json pointer."""
        return rfc6901_parser.unparse(self.parts)

    @classmethod
    def parse(cls, s: str) -> Self:
        """Parse a serialized RFC 6901 json pointer."""
        return cls(parts=rfc6901_parser.parse(s))

    # I dediced against this, as it's nagged at me since I first wrote it that you should't
    # resolve JSON pointers w/o having a Doccument you're resolving them across.
    #
    # def join(self, other: JsonPointer | RelativeJsonPointer | str) -> Self:
    #    match other:
    #        case JsonPointer(parts):
    #            return type(self)(parts=[*self.parts, *parts])
    #
    #        case str():
    #            return type(self)(parts=[*self.parts, other])
    #
    #        case RelativeJsonPointer(offset, pointer):
    #            remaining = len(self.parts) - offset
    #            if remaining < 0:
    #                raise PathJoiningException(
    #                    "Tried to ascend past root of json doc when appending relative pointer"
    #                )
    #            our_parts = self.parts[:remaining]
    #            their_parts = [] if pointer is None else pointer.parts
    #
    #            return type(self)(parts=[*our_parts, *their_parts])


@dataclass(repr=False)
class RelativeJsonPointer((_ReprStrMixin)):
    """Primitive data class for 2020-12 draft json pointers.

    >>> RelativeJsonPointer(0, JsonPointer(['data', 'items']))
    RelativeJsonPointer('0/data/items')

    >>> RelativeJsonPointer(0, None)
    RelativeJsonPointer('0#')
    """

    # https://json-schema.org/draft/2019-09/relative-json-pointer.html
    offset: int
    pointer: JsonPointer | None

    @property
    def parts(self) -> list[str] | None:
        """Unescaped list of path parts, if this isn't an index reference.

        >>> RelativeJsonPointer.parse("0/data/items/0/id").parts
        ['data', 'items', '0', 'id']
        >>> RelativeJsonPointer.parse("0#").parts is None
        True
        """
        return None if self.pointer is None else self.pointer.parts

    @property
    def is_index_ref(self) -> bool:
        """
        >>> RelativeJsonPointer.parse("0").is_index_ref
        False
        >>> RelativeJsonPointer.parse("0/").is_index_ref
        False
        >>> RelativeJsonPointer.parse("0#").is_index_ref
        True
        """
        return self.pointer is None

    def __str__(self) -> str:
        """Serialize to 2020-12 draft relative json pointer."""
        return rel_parser.unparse(self.offset, self.parts)

    @classmethod
    def parse(cls, s: str) -> Self:
        """Parse a serialized 2020-12 draft relative json pointer."""
        offset, parts = rel_parser.parse(s)
        return cls(
            offset=offset, pointer=None if parts is None else JsonPointer(parts=parts)
        )

1	from __future__ import annotations	1✔
2
3	from dataclasses import dataclass	1✔
4	from typing import *	1✔
5
6	from . import rel_parser, rfc6901_parser	1✔
7
8
9	class _ReprStrMixin:	1✔
10	def __repr__(self) -> str:	1✔
11	# inner single quotes is consistent w/ how str.__repr__ works
12	return f"{type(self).__name__}('{str(self)}')"	1✔
13
14
15	@dataclass(repr=False)	1✔
16	class JsonPointer(_ReprStrMixin):	1✔
17	"""Primitive dataclass for RFC 6901 json pointers.	1✔
18
19	>>> JsonPointer(['~home', 'foo.txt', 'mime/type'])
20	JsonPointer('/~0home/foo.txt/mime~1type')
21	>>> JsonPointer.parse('/~0home/foo.txt/mime~1type')
22	JsonPointer('/~0home/foo.txt/mime~1type')
23	"""
24
25	parts: list[str]	1✔
26	"""Unescaped list of path parts.	1✔
27
28	>>> JsonPointer.parse("/data/items/0/id").parts
29	['data', 'items', '0', 'id']
30	"""
31
32	def __str__(self) -> str:	1✔
33	"""Serialize to RFC 6901 json pointer."""
34	return rfc6901_parser.unparse(self.parts)	1✔
35
36	@classmethod	1✔
37	def parse(cls, s: str) -> Self:	1✔
38	"""Parse a serialized RFC 6901 json pointer."""
39	return cls(parts=rfc6901_parser.parse(s))	1✔
40
41	# I dediced against this, as it's nagged at me since I first wrote it that you should't
42	# resolve JSON pointers w/o having a Doccument you're resolving them across.
43	#
44	# def join(self, other: JsonPointer \| RelativeJsonPointer \| str) -> Self:
45	# match other:
46	# case JsonPointer(parts):
47	# return type(self)(parts=[self.parts, parts])
48	#
49	# case str():
50	# return type(self)(parts=[*self.parts, other])
51	#
52	# case RelativeJsonPointer(offset, pointer):
53	# remaining = len(self.parts) - offset
54	# if remaining < 0:
55	# raise PathJoiningException(
56	# "Tried to ascend past root of json doc when appending relative pointer"
57	# )
58	# our_parts = self.parts[:remaining]
59	# their_parts = [] if pointer is None else pointer.parts
60	#
61	# return type(self)(parts=[our_parts, their_parts])
62
63
64	@dataclass(repr=False)	1✔
65	class RelativeJsonPointer((_ReprStrMixin)):	1✔
66	"""Primitive data class for 2020-12 draft json pointers.	1✔
67
68	>>> RelativeJsonPointer(0, JsonPointer(['data', 'items']))
69	RelativeJsonPointer('0/data/items')
70
71	>>> RelativeJsonPointer(0, None)
72	RelativeJsonPointer('0#')
73	"""
74
75	# https://json-schema.org/draft/2019-09/relative-json-pointer.html
76	offset: int	1✔
77	pointer: JsonPointer \| None	1✔
78
79	@property	1✔
80	def parts(self) -> list[str] \| None:	1✔
81	"""Unescaped list of path parts, if this isn't an index reference.
82
83	>>> RelativeJsonPointer.parse("0/data/items/0/id").parts
84	['data', 'items', '0', 'id']
85	>>> RelativeJsonPointer.parse("0#").parts is None
86	True
87	"""
88	return None if self.pointer is None else self.pointer.parts	1✔
89
90	@property	1✔
91	def is_index_ref(self) -> bool:	1✔
92	"""
93	>>> RelativeJsonPointer.parse("0").is_index_ref
94	False
95	>>> RelativeJsonPointer.parse("0/").is_index_ref
96	False
97	>>> RelativeJsonPointer.parse("0#").is_index_ref
98	True
99	"""
100	return self.pointer is None	1✔
101
102	def __str__(self) -> str:	1✔
103	"""Serialize to 2020-12 draft relative json pointer."""
104	return rel_parser.unparse(self.offset, self.parts)	1✔
105
106	@classmethod	1✔
107	def parse(cls, s: str) -> Self:	1✔
108	"""Parse a serialized 2020-12 draft relative json pointer."""
109	offset, parts = rel_parser.parse(s)	1✔
110	return cls(	1✔
111	offset=offset, pointer=None if parts is None else JsonPointer(parts=parts)
112	)

SlowAPI / fast-json-pointer / 3798344209

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous