7303488374

Committed 22 Dec 2023 08:08PM UTC coverage: 88.467% (+0.8%) from 87.652%

Build # 7303488374

Build Type

push

github

Committed by

FlorianWilhelm

Commit Message

Setting icon and cover for pages works

Run Details

570 of 759 branches covered (0.0%)

Branch coverage included in aggregate %.

77 of 86 new or added lines in 6 files covered. (89.53%)

1 existing line in 1 file now uncovered.

3580 of 3932 relevant lines covered (91.05%)

4.53 hits per line

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

79.05

/src/ultimate_notion/objects.py

"""Functionality for general Notion objects like texts, files, options, etc."""

from __future__ import annotations

from typing import cast

from ultimate_notion.obj_api import objects as objs
from ultimate_notion.obj_api.enums import Color
from ultimate_notion.text import chunky, html_img
from ultimate_notion.utils import Wrapper, get_repr


class Option(Wrapper[objs.SelectOption], wraps=objs.SelectOption):
    """Option for select & multi-select property."""

    def __init__(self, name: str, *, color: Color = Color.DEFAULT):
        super().__init__(name, color=color)

    @property
    def id(self) -> str:  # noqa: A003
        """ID of the option."""
        return self.obj_ref.id

    @property
    def name(self) -> str:
        """Name of the option."""
        return self.obj_ref.name

    def description(self) -> str:
        """Description of the option."""
        if desc := self.obj_ref.description:
            return desc
        else:
            return ''

    def __repr__(self) -> str:
        return get_repr(self)

    def __str__(self) -> str:
        return self.name


class OptionGroup(Wrapper[objs.SelectGroup], wraps=objs.SelectGroup):
    """Group of options for status property."""

    _options: dict[str, Option]  # holds all possible options

    @classmethod
    def wrap_obj_ref(cls, obj_ref, /, *, options: list[Option] | None = None) -> OptionGroup:
        """Convienence constructor for the group of options."""
        obj = super().wrap_obj_ref(obj_ref)
        options = [] if options is None else options
        obj._options = {option.id: option for option in options}
        return obj

    @property
    def name(self) -> str:
        """Name of the option group."""
        return self.obj_ref.name

    @property
    def options(self) -> list[Option]:
        """Options within this option group."""
        return [self._options[opt_id] for opt_id in self.obj_ref.option_ids]

    def __repr__(self) -> str:
        return get_repr(self)

    def __str__(self) -> str:
        return self.name


class File(Wrapper[objs.FileObject], wraps=objs.FileObject):
    """A web resource e.g. for the files property."""

    obj_ref: objs.FileObject

    @classmethod
    def wrap_obj_ref(cls, obj_ref: objs.FileObject) -> File:
        self = cast(File, cls.__new__(cls))
        self.obj_ref = obj_ref
        return self

    def __init__(self, *, url: str, name: str | None = None) -> None:
        self.obj_ref = objs.ExternalFile.build(url=url, name=name)

    def __eq__(self, other: object) -> bool:
        if isinstance(other, str):
            return str(self) == other
        elif isinstance(other, File):
            return str(self) == str(other)
        else:
            return NotImplemented

    def __hash__(self):
        return hash(str(self))

    def __repr__(self) -> str:
        return get_repr(self)

    def __str__(self) -> str:
        return self.url

    def _repr_html_(self) -> str:  # noqa: PLW3201
        """Called by Jupyter Lab automatically to display this file."""
        return html_img(self.url, size=2)

    @property
    def name(self) -> str | None:
        return self.obj_ref.name

    @property
    def url(self) -> str:
        if isinstance(self.obj_ref, objs.HostedFile):
            return self.obj_ref.file.url
        elif isinstance(self.obj_ref, objs.ExternalFile):
            return self.obj_ref.external.url
        else:
            msg = f'Unknown file type {type(self.obj_ref)}'
            raise RuntimeError(msg)


class Emoji(Wrapper[objs.EmojiObject], str, wraps=objs.EmojiObject):
    """Emoji object which behaves like str."""

    def __init__(self, emoji: str) -> None:
        self.obj_ref = objs.EmojiObject.build(emoji)

    def __repr__(self) -> str:
        return get_repr(self)

    def __str__(self) -> str:
        return self.obj_ref.emoji

    def __eq__(self, other: object) -> bool:
        if isinstance(other, str):
            return str(self) == other
        elif isinstance(other, Emoji):
            return str(self) == str(other)
        else:
            return NotImplemented

    def __hash__(self):
        return hash(str(self))

    def _repr_html_(self) -> str:  # noqa: PLW3201
        """Called by Jupyter Lab automatically to display this file."""
        return str(self)

    def to_code(self) -> str:
        """Represent the emoji as :shortcode:, e.g. :smile:"""
        raise NotImplementedError

    @classmethod
    def from_code(cls, shortcode: str) -> Emoji:
        """Create an Emoji object from a :shortcode:, e.g. :smile:"""
        raise NotImplementedError


class RichTextBase(Wrapper[objs.RichTextObject], wraps=objs.RichTextObject):
    """Super class for text, equation and mentions of various kinds."""


class Text(RichTextBase, wraps=objs.TextObject):
    """A Text object."""


class Equation(RichTextBase, wraps=objs.EquationObject):
    """An Equation object."""


class Mention(RichTextBase, wraps=objs.MentionObject):
    """A Mention object."""


class RichText(str):
    """User-facing class holding several RichTexts."""

    rich_texts: list[RichTextBase]

    def __init__(self, plain_text: str):
        super().__init__()

        rich_texts: list[RichTextBase] = []
        for part in chunky(plain_text):
            rich_texts.append(Text(part))
        self.rich_texts = rich_texts

    @classmethod
    def wrap_obj_ref(cls, obj_refs: list[objs.RichTextObject]) -> RichText:
        rich_texts = [cast(RichTextBase, RichTextBase.wrap_obj_ref(obj_ref)) for obj_ref in obj_refs]
        plain_text = ''.join(text.obj_ref.plain_text for text in rich_texts if text)
        obj = cls(plain_text)
        obj.rich_texts = rich_texts
        return obj

    @property
    def obj_ref(self) -> list[objs.RichTextObject]:
        return [elem.obj_ref for elem in self.rich_texts]

    @classmethod
    def from_markdown(cls, text: str) -> RichText:
        """Create RichTextList by parsing the markdown."""
        # ToDo: Implement
        # ToDo: Handle Equations and Mentions here accordingly
        raise NotImplementedError

    def to_markdown(self) -> str | None:
        """Convert the list of RichText objects to markdown."""
        # ToDo: Implement
        raise NotImplementedError

    @classmethod
    def from_plain_text(cls, text: str) -> RichText:
        """Create RichTextList from plain text.

        This method is a more explicit alias for the default constructor
        """
        return cls(text)

    def to_plain_text(self) -> str:
        """Return rich text as plaintext

        This method is a more explicit variant then just using the object.
        """
        return str(self)

    def _repr_html_(self) -> str:  # noqa: PLW3201
        """Called by Jupyter Lab automatically to display this text."""
        # ToDo: Later use Markdown output.
        return self.to_plain_text()

    def __eq__(self, other: object) -> bool:
        if isinstance(other, str):
            return str(self) == other
        elif isinstance(other, RichText):
            return str(self) == str(other)
        else:
            return NotImplemented

    def __hash__(self):
        return hash(str(self))


class User(Wrapper[objs.User], wraps=objs.User):
    @classmethod
    def wrap_obj_ref(cls, obj_ref: objs.User) -> User:
        self = cast(User, cls.__new__(cls))
        self.obj_ref = obj_ref
        return self

    def __str__(self):
        return self.name

    def __repr__(self) -> str:
        return get_repr(self)

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, User):
            return NotImplemented
        return self.id == other.id

    def __hash__(self) -> int:
        return hash(self.id)

    @property
    def id(self):  # noqa: A003
        return self.obj_ref.id

    @property
    def name(self):
        return self.obj_ref.name

    @property
    def is_person(self) -> bool:
        return isinstance(self.obj_ref, objs.Person)

    @property
    def is_bot(self) -> bool:
        return isinstance(self.obj_ref, objs.Bot)

    @property
    def avatar_url(self):
        return self.obj_ref.avatar_url

    @property
    def email(self) -> str | None:
        if isinstance(self.obj_ref, objs.Person):
            return self.obj_ref.person.email
        else:  # it's a bot without an e-mail
            return None

1	"""Functionality for general Notion objects like texts, files, options, etc."""	5✔
2
3	from __future__ import annotations	5✔
4
5	from typing import cast	5✔
6
7	from ultimate_notion.obj_api import objects as objs	5✔
8	from ultimate_notion.obj_api.enums import Color	5✔
9	from ultimate_notion.text import chunky, html_img	5✔
10	from ultimate_notion.utils import Wrapper, get_repr	5✔
11
12
13	class Option(Wrapper[objs.SelectOption], wraps=objs.SelectOption):	5✔
14	"""Option for select & multi-select property."""	5✔
15
16	def __init__(self, name: str, *, color: Color = Color.DEFAULT):	5✔
17	super().__init__(name, color=color)	5✔
18
19	@property	5✔
20	def id(self) -> str: # noqa: A003	5✔
21	"""ID of the option."""
22	return self.obj_ref.id	5✔
23
24	@property	5✔
25	def name(self) -> str:	5✔
26	"""Name of the option."""
27	return self.obj_ref.name	5✔
28
29	def description(self) -> str:	5✔
30	"""Description of the option."""
31	if desc := self.obj_ref.description:	×
32	return desc	×
33	else:
34	return ''	×
35
36	def __repr__(self) -> str:
37	return get_repr(self)
38
39	def __str__(self) -> str:	5✔
40	return self.name	4✔
41
42
43	class OptionGroup(Wrapper[objs.SelectGroup], wraps=objs.SelectGroup):	5✔
44	"""Group of options for status property."""	5✔
45
46	_options: dict[str, Option] # holds all possible options	5✔
47
48	@classmethod	5✔
49	def wrap_obj_ref(cls, obj_ref, /, *, options: list[Option] \| None = None) -> OptionGroup:	5✔
50	"""Convienence constructor for the group of options."""
51	obj = super().wrap_obj_ref(obj_ref)	5✔
52	options = [] if options is None else options	5✔
53	obj._options = {option.id: option for option in options}	5✔
54	return obj	5✔
55
56	@property	5✔
57	def name(self) -> str:	5✔
58	"""Name of the option group."""
59	return self.obj_ref.name	5✔
60
61	@property	5✔
62	def options(self) -> list[Option]:	5✔
63	"""Options within this option group."""
64	return [self._options[opt_id] for opt_id in self.obj_ref.option_ids]	5✔
65
66	def __repr__(self) -> str:
67	return get_repr(self)
68
69	def __str__(self) -> str:	5✔
70	return self.name	×
71
72
73	class File(Wrapper[objs.FileObject], wraps=objs.FileObject):	5✔
74	"""A web resource e.g. for the files property."""	5✔
75
76	obj_ref: objs.FileObject	5✔
77
78	@classmethod	5✔
79	def wrap_obj_ref(cls, obj_ref: objs.FileObject) -> File:	5✔
80	self = cast(File, cls.__new__(cls))	5✔
81	self.obj_ref = obj_ref	5✔
82	return self	5✔
83
84	def __init__(self, *, url: str, name: str \| None = None) -> None:	5✔
85	self.obj_ref = objs.ExternalFile.build(url=url, name=name)	5✔
86
87	def __eq__(self, other: object) -> bool:	5✔
88	if isinstance(other, str):	5✔
89	return str(self) == other	5✔
90	elif isinstance(other, File):	5✔
91	return str(self) == str(other)	5✔
92	else:
NEW 93	return NotImplemented	×
94
95	def __hash__(self):	5✔
NEW 96	return hash(str(self))	×
97
98	def __repr__(self) -> str:
99	return get_repr(self)
100
101	def __str__(self) -> str:	5✔
102	return self.url	5✔
103
104	def _repr_html_(self) -> str: # noqa: PLW3201	5✔
105	"""Called by Jupyter Lab automatically to display this file."""
106	return html_img(self.url, size=2)	×
107
108	@property	5✔
109	def name(self) -> str \| None:	5✔
110	return self.obj_ref.name	×
111
112	@property	5✔
113	def url(self) -> str:	5✔
114	if isinstance(self.obj_ref, objs.HostedFile):	5✔
115	return self.obj_ref.file.url	×
116	elif isinstance(self.obj_ref, objs.ExternalFile):	5✔
117	return self.obj_ref.external.url	5✔
118	else:
119	msg = f'Unknown file type {type(self.obj_ref)}'	×
120	raise RuntimeError(msg)	×
121
122
123	class Emoji(Wrapper[objs.EmojiObject], str, wraps=objs.EmojiObject):	5✔
124	"""Emoji object which behaves like str."""	5✔
125
126	def __init__(self, emoji: str) -> None:	5✔
127	self.obj_ref = objs.EmojiObject.build(emoji)	5✔
128
129	def __repr__(self) -> str:
130	return get_repr(self)
131
132	def __str__(self) -> str:	5✔
133	return self.obj_ref.emoji	5✔
134
135	def __eq__(self, other: object) -> bool:	5✔
136	if isinstance(other, str):	5✔
137	return str(self) == other	5✔
NEW 138	elif isinstance(other, Emoji):	×
NEW 139	return str(self) == str(other)	×
140	else:
NEW 141	return NotImplemented	×
142
143	def __hash__(self):	5✔
NEW 144	return hash(str(self))	×
145
146	def _repr_html_(self) -> str: # noqa: PLW3201	5✔
147	"""Called by Jupyter Lab automatically to display this file."""
148	return str(self)	×
149
150	def to_code(self) -> str:	5✔
151	"""Represent the emoji as :shortcode:, e.g. :smile:"""
152	raise NotImplementedError
153
154	@classmethod	5✔
155	def from_code(cls, shortcode: str) -> Emoji:	5✔
156	"""Create an Emoji object from a :shortcode:, e.g. :smile:"""
157	raise NotImplementedError
158
159
160	class RichTextBase(Wrapper[objs.RichTextObject], wraps=objs.RichTextObject):	5✔
161	"""Super class for text, equation and mentions of various kinds."""	5✔
162
163
164	class Text(RichTextBase, wraps=objs.TextObject):	5✔
165	"""A Text object."""	5✔
166
167
168	class Equation(RichTextBase, wraps=objs.EquationObject):	5✔
169	"""An Equation object."""	5✔
170
171
172	class Mention(RichTextBase, wraps=objs.MentionObject):	5✔
173	"""A Mention object."""	5✔
174
175
176	class RichText(str):	5✔
177	"""User-facing class holding several RichTexts."""	5✔
178
179	rich_texts: list[RichTextBase]	5✔
180
181	def __init__(self, plain_text: str):	5✔
182	super().__init__()	5✔
183
184	rich_texts: list[RichTextBase] = []	5✔
185	for part in chunky(plain_text):	5✔
186	rich_texts.append(Text(part))	5✔
187	self.rich_texts = rich_texts	5✔
188
189	@classmethod	5✔
190	def wrap_obj_ref(cls, obj_refs: list[objs.RichTextObject]) -> RichText:	5✔
191	rich_texts = [cast(RichTextBase, RichTextBase.wrap_obj_ref(obj_ref)) for obj_ref in obj_refs]	5✔
192	plain_text = ''.join(text.obj_ref.plain_text for text in rich_texts if text)	5✔
193	obj = cls(plain_text)	5✔
194	obj.rich_texts = rich_texts	5✔
195	return obj	5✔
196
197	@property	5✔
198	def obj_ref(self) -> list[objs.RichTextObject]:	5✔
199	return [elem.obj_ref for elem in self.rich_texts]	5✔
200
201	@classmethod	5✔
202	def from_markdown(cls, text: str) -> RichText:	5✔
203	"""Create RichTextList by parsing the markdown."""
204	# ToDo: Implement
205	# ToDo: Handle Equations and Mentions here accordingly
206	raise NotImplementedError
207
208	def to_markdown(self) -> str \| None:	5✔
209	"""Convert the list of RichText objects to markdown."""
210	# ToDo: Implement
211	raise NotImplementedError
212
213	@classmethod	5✔
214	def from_plain_text(cls, text: str) -> RichText:	5✔
215	"""Create RichTextList from plain text.
216
217	This method is a more explicit alias for the default constructor
218	"""
219	return cls(text)	5✔
220
221	def to_plain_text(self) -> str:	5✔
222	"""Return rich text as plaintext
223
224	This method is a more explicit variant then just using the object.
225	"""
226	return str(self)	×
227
228	def _repr_html_(self) -> str: # noqa: PLW3201	5✔
229	"""Called by Jupyter Lab automatically to display this text."""
230	# ToDo: Later use Markdown output.
231	return self.to_plain_text()	×
232
233	def __eq__(self, other: object) -> bool:	5✔
234	if isinstance(other, str):	5✔
235	return str(self) == other	5✔
236	elif isinstance(other, RichText):	×
237	return str(self) == str(other)	×
238	else:
239	return NotImplemented	×
240
241	def __hash__(self):	5✔
242	return hash(str(self))	×
243
244
245	class User(Wrapper[objs.User], wraps=objs.User):	5✔
246	@classmethod	5✔
247	def wrap_obj_ref(cls, obj_ref: objs.User) -> User:	5✔
248	self = cast(User, cls.__new__(cls))	5✔
249	self.obj_ref = obj_ref	5✔
250	return self	5✔
251
252	def __str__(self):	5✔
253	return self.name	×
254
255	def __repr__(self) -> str:
256	return get_repr(self)
257
258	def __eq__(self, other: object) -> bool:	5✔
259	if not isinstance(other, User):	5✔
260	return NotImplemented	×
261	return self.id == other.id	5✔
262
263	def __hash__(self) -> int:	5✔
264	return hash(self.id)	×
265
266	@property	5✔
267	def id(self): # noqa: A003	5✔
268	return self.obj_ref.id	5✔
269
270	@property	5✔
271	def name(self):	5✔
272	return self.obj_ref.name	5✔
273
274	@property	5✔
275	def is_person(self) -> bool:	5✔
276	return isinstance(self.obj_ref, objs.Person)	5✔
277
278	@property	5✔
279	def is_bot(self) -> bool:	5✔
280	return isinstance(self.obj_ref, objs.Bot)	×
281
282	@property	5✔
283	def avatar_url(self):	5✔
284	return self.obj_ref.avatar_url	×
285
286	@property	5✔
287	def email(self) -> str \| None:	5✔
288	if isinstance(self.obj_ref, objs.Person):	×
289	return self.obj_ref.person.email	×
290	else: # it's a bot without an e-mail
291	return None	×

ultimate-notion / ultimate-notion / 7303488374

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