glpi-python-client 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

glpi_python_client/__init__.py

@@ -131,7 +131,7 @@ from glpi_python_client.rsql import (
     date_window,
 )
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 __all__ = [
     "AsyncGlpiClient",

glpi_python_client/_async/_testing.py

@@ -127,10 +127,10 @@ class TransportRecorder:
             )
             return FakeResponse(status_code=self._delete_status, payload={})
 
-        client._get_request = _get  # type: ignore[method-assign, assignment]
-        client._post_request = _post  # type: ignore[method-assign, assignment]
-        client._update_request = _patch  # type: ignore[method-assign, assignment]
-        client._delete_request = _delete  # type: ignore[method-assign, assignment]
+        client._get_request = _get  # type: ignore[method-assign, assignment, unused-ignore]
+        client._post_request = _post  # type: ignore[method-assign, assignment, unused-ignore]
+        client._update_request = _patch  # type: ignore[method-assign, assignment, unused-ignore]
+        client._delete_request = _delete  # type: ignore[method-assign, assignment, unused-ignore]
 
 
 class FailingTransportRecorder(TransportRecorder):

glpi_python_client/_errors.py

@@ -149,8 +149,8 @@ class GlpiContentError(GlpiError):
 
     This exists so that no failure of the content layer escapes the
     package's taxonomy. The conversion runs third-party parsers
-    (``markdownify`` inbound, ``markdown`` outbound), and a parser fault
-    used to reach the caller as a bare builtin — most visibly a
+    (``markdownify`` and ``mdformat`` inbound, ``cmark-gfm`` outbound), and a
+    parser fault used to reach the caller as a bare builtin — most visibly a
     ``RecursionError``, which ``except GlpiError`` does not catch and which
     a caller reading a ticket has no reason to expect from
     ``get_ticket``. Deeply nested HTML is caught and answered with the

glpi_python_client/_sync/_testing.py

@@ -127,10 +127,10 @@ class TransportRecorder:
             )
             return FakeResponse(status_code=self._delete_status, payload={})
 
-        client._get_request = _get  # type: ignore[method-assign, assignment]
-        client._post_request = _post  # type: ignore[method-assign, assignment]
-        client._update_request = _patch  # type: ignore[method-assign, assignment]
-        client._delete_request = _delete  # type: ignore[method-assign, assignment]
+        client._get_request = _get  # type: ignore[method-assign, assignment, unused-ignore]
+        client._post_request = _post  # type: ignore[method-assign, assignment, unused-ignore]
+        client._update_request = _patch  # type: ignore[method-assign, assignment, unused-ignore]
+        client._delete_request = _delete  # type: ignore[method-assign, assignment, unused-ignore]
 
 
 class FailingTransportRecorder(TransportRecorder):

glpi_python_client/content/conversion.py

@@ -11,14 +11,27 @@ GLPI stores rich text as HTML; the package's surface is Markdown.
   renders CommonMark with GFM tables; a newline is a line break and raw
   HTML passes through.
 
-Rendering the Markdown a read gives displays what GLPI displayed, and
-reading that back gives the same Markdown. The glue below covers what the
+The aim is that rendering the Markdown a read gives displays what GLPI
+displayed, and that reading that back gives the same Markdown. Some
+synthetic shapes still lose words or the fixed point; the user guide's
+"Rich-text content" section lists them. The glue below covers what the
 three libraries leave out: plain text, line breaks a browser does not
 show, bold and italic CommonMark would not close, link targets, and an
 mdformat set up without its nesting cap and with its quadratic lookups made
-linear. A body nested too deeply for the stack is read as its text
+linear. A body nested too deeply for the stack, or on which the
+conversion raises ``ValueError`` -- markdownify does for a ``colspan`` or
+``start`` it cannot read as a number -- is read as its text
 (:func:`_text_of`); anything else that fails raises
 :class:`~glpi_python_client.GlpiContentError`.
+
+The reader is ``easyvista-python-client`` 0.4.1's, helper for helper: that
+package ported this module at commit ``917f030`` and added fifteen fixes,
+which 0.6.1 ports back with the correction to fix 11 both packages now
+carry (a ``<u>``, ``<mark>`` or ``<ins>`` round a block is dropped). The
+two modules differ only in names, messages, docstrings and that package's
+optional-dependency import guard, and should move together: the hard part
+of both is the behaviour of the same libraries, not anything either ITSM
+does.
 """
 
 from __future__ import annotations
@@ -44,6 +57,7 @@ from mdformat.renderer import (
     RenderContext,
     RenderTreeNode,
 )
+from mdformat.renderer.typing import Postprocess
 
 from glpi_python_client._errors import GlpiContentError
 
@@ -90,9 +104,19 @@ _HIDDEN = ["head", "script", "style", "template", "title"]
 #: carry the characters displayed on either side of one (:func:`_note_sides`).
 _EMPHASIS = frozenset({"b", "strong", "em", "i"})
 _BEFORE, _AFTER = "data-glpi-before", "data-glpi-after"
+_NUMBER = "data-glpi-number"  # an ordered item's number (_Converter.convert_li)
+
+#: The elements kept as raw tags (:meth:`_Converter.convert_u`), and the
+#: attribute marking one that holds a block (:func:`_note_blocks`).
+_RAW_INLINE = frozenset({"u", "mark", "ins"})
+_HOLDS_BLOCK = "data-glpi-block"
 
 #: Text split into leading line breaks and spaces, content, trailing ones.
-_EDGES = re.compile(r"((?:\\\n|\s)*)(.*?)((?:\\\n|\s)*)", re.DOTALL)
+#: The content ends on its last character that is neither, found greedily:
+#: a lazy ``.*?`` rescanned the run after it at every step, quadratic.
+_EDGES = re.compile(
+    r"((?:\\\n|\s)*)((?:.*(?:[^\\\s]|\\(?!\n)))?)((?:\\\n|\s)*)", re.DOTALL
+)
 
 #: A URL that is its own CommonMark autolink and that markdown-it leaves as it
 #: is: printable ASCII it does not percent-encode.
@@ -166,15 +190,19 @@ _TABLE_PARTS = frozenset(
     {"table", "thead", "tbody", "tfoot", "tr", "caption", "colgroup", "col"}
 )
 
+#: What Markdown writes on one line: a table inside one cannot be a table.
+_ONE_LINE = frozenset({"td", "th", "a", "h1", "h2", "h3", "h4", "h5", "h6"})
+
 
 def _flatten_nested_tables(root: Tag) -> None:
-    """Write a table that sits inside a cell as its cells' text.
+    """Write a table that sits inside a cell, a heading or a link as its cells' text.
 
     A GFM cell holds one line, so a nested table -- the usual layout of an
     e-mail signature -- written as a table split the outer row and lost
-    every word. Inside a cell, a table's parts become ``span`` and its cells
-    ``glpi-cell``, which :class:`_Converter` writes as spaced inline text.
-    Renaming in one walk keeps it linear however deeply tables nest.
+    every word; in a heading or a link its pipes became text. Inside one, a
+    table's parts become ``span`` and its cells ``glpi-cell``, which
+    :class:`_Converter` writes as spaced inline text. Renaming in one walk
+    keeps it linear however deeply tables nest.
     """
 
     cells = 0
@@ -191,8 +219,9 @@ def _flatten_nested_tables(root: Tag) -> None:
             node.name = "glpi-cell" if is_cell else "span"
             counted.append(False)
             continue
-        counted.append(is_cell)
-        cells += is_cell
+        holds = node.name in _ONE_LINE and (node.name != "a" or bool(node.get("href")))
+        counted.append(holds)
+        cells += holds
 
 
 def _walk(root: Tag) -> Iterator[tuple[PageElement, bool]]:
@@ -245,7 +274,8 @@ def _note_sides(root: Tag) -> None:
 
     One pass: ``last`` is the last character shown so far on the current
     line, and an element that has closed waits for the next one. A line edge
-    counts as a space, as it does for CommonMark.
+    counts as a space, as it does for CommonMark, and so does the edge of a
+    flattened cell, which :class:`_Converter` spaces.
     """
 
     last = " "
@@ -258,7 +288,7 @@ def _note_sides(root: Tag) -> None:
                 else:
                     waiting.append(node)
                 continue
-            if node.name not in _BLOCKS and node.name != "br":
+            if node.name not in _BLOCKS and node.name not in ("br", "glpi-cell"):
                 continue
             first = last = " "
         else:
@@ -273,6 +303,33 @@ def _note_sides(root: Tag) -> None:
         element[_AFTER] = " "
 
 
+def _note_blocks(root: Tag) -> None:
+    """Mark each ``<u>``, ``<mark>`` or ``<ins>`` that holds a block.
+
+    Markdown has no inline tag around blocks: such a tag wrapped round them
+    showed a table, a list or a heading as its Markdown source, and round a
+    ``<pre>`` left a fence open to the end of the body. One walk: a block
+    marks the open ones from the innermost out and stops at one already
+    marked, whose holders were marked with it, so each is marked once
+    however deeply they nest.
+    """
+
+    holders: list[Tag] = []
+    for node, entering in _walk(root):
+        if not isinstance(node, Tag):
+            continue
+        if node.name in _RAW_INLINE:
+            if entering:
+                holders.append(node)
+            else:
+                holders.pop()
+        elif entering and node.name in _BLOCKS:
+            for holder in reversed(holders):
+                if holder.has_attr(_HOLDS_BLOCK):
+                    break
+                holder[_HOLDS_BLOCK] = ""
+
+
 def _punctuation(char: str) -> bool:
     """Return whether CommonMark counts ``char`` as punctuation."""
 
@@ -316,6 +373,21 @@ class _Converter(MarkdownConverter):
     def _inherited(self, name: str) -> Any:
         return getattr(super(), name)
 
+    def escape(self, text: str, parent_tags: set[str]) -> str:
+        """Escape a text's last ``!`` as well: before a link it makes an image.
+
+        A ``!`` meets a ``[`` only there, markdownify escaping a ``[`` in text;
+        mdformat keeps that escape before a link and drops it anywhere else.
+        """
+
+        text = str(self._inherited("escape")(text, parent_tags))
+        return text[:-1] + "\\!" if text.endswith("!") else text
+
+    def process_tag(self, node: Any, parent_tags: Any = None) -> str:
+        if node.name == "glpi-cell":  # one line, as a cell is: its blocks are inline
+            parent_tags = {*(parent_tags or ()), "_inline"}
+        return str(self._inherited("process_tag")(node, parent_tags))
+
     def _markup(
         self, el: Tag, text: str, parent_tags: set[str], markers: str, tag: str
     ) -> str:
@@ -353,26 +425,56 @@ class _Converter(MarkdownConverter):
     convert_del = convert_s
     convert_strike = convert_s
 
+    def convert_u(self, el: Tag, text: str, parent_tags: set[str]) -> str:
+        """Underlined or highlighted text: CommonMark has neither, so raw HTML.
+
+        Round a block the tag is dropped and the blocks kept, except on the
+        one line of a cell or a heading, where the blocks are inline text.
+        """
+
+        if el.has_attr(_HOLDS_BLOCK) and "_inline" not in parent_tags:
+            return text
+        return self._markup(el, text, parent_tags, "", el.name)
+
+    convert_mark = convert_ins = convert_u
+
+    def convert_center(self, el: Tag, text: str, parent_tags: set[str]) -> str:
+        """``<center>``, obsolete, is a block, as ``<div>`` is."""
+
+        if "pre" in parent_tags:
+            return text
+        return str(self._inherited("convert_div")(el, text, parent_tags))
+
     def convert_glpi_cell(self, el: Tag, text: str, parent_tags: set[str]) -> str:
         """A cell of a table nested in a cell: its text, set apart by spaces."""
 
         return f" {text.strip()} "
 
     def convert_br(self, el: Tag, text: str, parent_tags: set[str]) -> str:
-        if "pre" in parent_tags:
-            return "\n"
+        if "_noformat" in parent_tags:
+            return "\n"  # in <pre>, or in inline code, which convert_code splits
         if "td" in parent_tags or "th" in parent_tags:
             return "<br>"  # a cell is one line of Markdown; cmark-gfm passes the tag
         return str(self._inherited("convert_br")(el, text, parent_tags))
 
     def convert_code(self, el: Tag, text: str, parent_tags: set[str]) -> str:
-        code = str(self._inherited("convert_code")(el, text, parent_tags))
-        if "td" in parent_tags or "th" in parent_tags:
+        """Inline code, a span per line: a code span cannot hold a line break."""
+
+        cell = "td" in parent_tags or "th" in parent_tags
+        lines = [text] if "_noformat" in parent_tags else text.split("\n")
+        join = "<br>" if cell else " " if "_inline" in parent_tags else "\\\n"
+        code = join.join(
+            str(self._inherited("convert_code")(el, line, parent_tags))
+            for line in lines
+        )
+        if cell:
             code = code.replace(
                 "|", "\\|"
             )  # GFM splits a row on "|" before it reads code
         return code
 
+    convert_kbd = convert_samp = convert_code
+
     def convert_list(self, el: Tag, text: str, parent_tags: set[str]) -> str:
         """A list; a nested one ends in a blank line.
 
@@ -385,6 +487,27 @@ class _Converter(MarkdownConverter):
     convert_ul = convert_list
     convert_ol = convert_list
 
+    def convert_li(self, el: Tag, text: str, parent_tags: set[str]) -> str:
+        """An item; an ordered one numbered one past the item before it.
+
+        markdownify counts every item before each one, quadratic in a long
+        list, so each item keeps its number for the next. ``isdecimal``,
+        where markdownify's ``isnumeric`` let ``int("²")`` raise.
+        """
+
+        if el.parent is None or el.parent.name != "ol":
+            return str(self._inherited("convert_li")(el, text, parent_tags))
+        before = el.find_previous_sibling("li")
+        start = str(el.parent.get("start") or "")
+        first = int(start) if start.isdecimal() else 1
+        number = int(str(before[_NUMBER])) + 1 if isinstance(before, Tag) else first
+        el[_NUMBER] = str(number)
+        if not text.strip():
+            return "\n"
+        bullet = f"{number}. "
+        body = re.sub("^(?=.)", " " * len(bullet), text.strip(), flags=re.M)
+        return bullet + body[len(bullet) :] + "\n"
+
     def convert_pre(self, el: Tag, text: str, parent_tags: set[str]) -> str:
         """A fenced block, its fence longer than any backtick run in the code."""
 
@@ -415,6 +538,8 @@ class _Converter(MarkdownConverter):
 
         alt = " ".join(str(el.get("alt") or "").split())
         alt = str(self._inherited("escape")(alt, parent_tags))
+        if alt.startswith("^") and "_noformat" not in parent_tags:
+            alt = "\\" + alt  # cmark-gfm reads "![^" as "!" and a link
         src = _destination(str(el.get("src") or ""))
         return f"![{alt}]({src}{_title(str(el.get('title') or ''))})"
 
@@ -473,6 +598,10 @@ def _list_item(node: RenderTreeNode, context: RenderContext) -> str:
 #: character no backslash escapes. ``2k - 1`` read as the same ``k`` there.
 _NEEDLESS_DOUBLING = re.compile(r"(?<!\\)((?:\\\\)+)(?=[^!-/:-@\[-`{-~\\\s])")
 
+#: The ``<`` mdformat leaves bare after one it escaped: its pattern eats the
+#: next character, so ``<<a@b.c>`` became ``\<<a@b.c>``, an autolink.
+_SECOND_LESS_THAN = re.compile(r"(?<=\\<)<(?=[^ ]|$)")
+
 
 def _text(node: RenderTreeNode, context: RenderContext) -> str:
     """Render text as mdformat does, less one backslash where it escapes nothing.
@@ -481,9 +610,14 @@ def _text(node: RenderTreeNode, context: RenderContext) -> str:
     """
 
     text = DEFAULT_RENDERERS["text"](node, context)
+    text = _SECOND_LESS_THAN.sub(r"\\<", text)
     return _NEEDLESS_DOUBLING.sub(lambda found: found.group(1)[:-1], text)
 
 
+#: A paragraph line opening with ``~~~``, which CommonMark reads as a fence.
+_TILDE_FENCE = re.compile("^~~~", re.MULTILINE)
+
+
 class _Lists:
     """An mdformat extension: linear list items, short text and rules."""
 
@@ -492,6 +626,13 @@ class _Lists:
         "text": _text,
         "hr": lambda node, context: "---",
     }
+    #: What mdformat drops: an escape or entity in an image's alt text, which
+    #: markdown-it-py 3 leaves a ``text_special`` token mdformat renders as
+    #: nothing, and the escape on a paragraph line opening with ``~~~``.
+    POSTPROCESSORS: Mapping[str, Postprocess] = {
+        "text_special": lambda text, node, context: node.markup,
+        "paragraph": lambda text, node, context: _TILDE_FENCE.sub(r"\\~~~", text),
+    }
 
 
 class _Renderer(MDRenderer):
@@ -570,15 +711,31 @@ def html_to_markdown(html: str) -> str:
     _flatten_nested_tables(soup)
     _drop_trailing_breaks(soup)
     _note_sides(soup)
+    _note_blocks(soup)
     return str(_FORMATTER.render(_CONVERTER.convert_soup(soup))).strip()
 
 
+#: A link as cmark-gfm writes one: an ``href``, an optional ``title``, nothing else.
+_RENDERED_LINK = re.compile(r'<a href="[^"]*"(?: title="[^"]*")?>')
+
+#: What GLPI's own editor writes on a link, so that it opens in a new window
+#: rather than in place of the page showing it. ``noreferrer`` too, as
+#: ``easyvista-python-client``'s twin writes, so the two render alike.
+_NEW_WINDOW = ' target="_blank" rel="noopener noreferrer"'
+
+
 def markdown_to_html(markdown: str) -> str:
-    """Render Markdown as HTML: CommonMark with GFM tables, through cmark-gfm."""
+    """Render Markdown as HTML: CommonMark with GFM tables, through cmark-gfm.
+
+    Every link opens in a new window, the way a link written in GLPI's editor
+    does: ``target="_blank" rel="noopener noreferrer"`` is added to each link
+    cmark-gfm writes. Reading ignores both attributes.
+    """
 
     html: str = cmarkgfm.markdown_to_html_with_extensions(
         markdown, options=_RENDER_OPTIONS, extensions=["table"]
     )
+    html = _RENDERED_LINK.sub(lambda link: link.group(0)[:-1] + _NEW_WINDOW + ">", html)
     return html.strip()
 
 
@@ -611,9 +768,12 @@ class GlpiContentConverter:
             read path, reads plain text as GLPI displays it -- literal
             characters, one line per line -- so ``__init__`` comes back
             escaped. ``True`` is the write models' validator: the value is
-            the caller's own Markdown and passes verbatim unless it starts
-            with a real HTML tag, so Markdown carrying an inline ``<br>`` or
-            ``<kbd>`` is still Markdown.
+            the caller's own Markdown and passes through, stripped, unless
+            it starts with ``<`` and holds a real HTML element anywhere. So
+            Markdown carrying an inline ``<br>`` or ``<kbd>`` is still
+            Markdown, but Markdown that opens with an autolink or other
+            angle-bracketed text and carries inline HTML further on is read
+            as HTML, and loses that autolink.
 
         Returns
         -------
@@ -624,8 +784,15 @@ class GlpiContentConverter:
         ------
         GlpiContentError
             The value could not be converted. A body nested too deeply for
-            the stack left is read as its text instead, so this is a
-            backstop.
+            the stack left, or on which the conversion raises
+            ``ValueError`` (a ``colspan`` or ``start`` markdownify cannot
+            read as a number, among others), is read as its text instead,
+            so this is a backstop.
+        RecursionError
+            Only when called from within a few frames of the recursion
+            limit, where no stack is left even to report the failure as
+            ``GlpiContentError`` (the user guide gives the measured
+            depths).
         """
 
         content = str(value or "").strip()
@@ -637,10 +804,15 @@ class GlpiContentConverter:
             return content
         if not _looks_like_html(content):
             content = _plain_text_html(content)
+        # No "<" after the last ">" can finish a tag; CPython's html.parser before
+        # 3.11.14/3.12.12/3.13.6 rescans to the end for each (quadratic).
+        head, end, tail = content.rpartition(">")
+        content = head + end + tail.replace("<", "&lt;")
         try:
             try:
                 return html_to_markdown(content)
-            except RecursionError:
+            except (RecursionError, ValueError):  # ValueError: markdownify's
+                # int() of a colspan or start such as "²" or 5,000 digits
                 return html_to_markdown(_plain_text_html(_text_of(content)))
             except ParserRejectedMarkup:
                 # html.parser gives up on a few malformed declarations; the

glpi_python_client/models/api_schema/_content.py

@@ -54,7 +54,8 @@ Note that the inbound converter also runs on **outbound** content: the
 ``BeforeValidator`` below fires when a caller constructs a ``Post*`` model,
 so caller-authored Markdown passes through it before the serializer renders
 it. It runs with ``plain_text_is_markdown=True``, which keeps the caller's
-Markdown verbatim unless it starts with an HTML tag -- reading it as literal
+Markdown as written, stripped at both ends, unless it starts with ``<`` and
+holds an HTML element -- reading it as literal
 text would escape it, and GLPI would receive literal asterisks.
 
 One sharp edge comes with the read side, from ``functools.cached_property``:
@@ -83,6 +84,7 @@ Rewrite the raw field, or rebuild through ``model_validate``.
 
 from __future__ import annotations
 
+import re
 from collections.abc import Iterator
 from contextlib import contextmanager
 from contextvars import ContextVar
@@ -159,6 +161,9 @@ _LAST_CONTENT_FAULT: ContextVar[GlpiContentError | None] = ContextVar(
     "glpi_last_content_fault", default=None
 )
 
+#: A UTF-16 surrogate standing alone, which UTF-8 cannot encode.
+_LONE_SURROGATE = re.compile("[\ud800-\udfff]")
+
 
 def _to_transport(value: str | None) -> str | None:
     """Render an outbound Markdown content value as the HTML GLPI expects.
@@ -167,6 +172,12 @@ def _to_transport(value: str | None) -> str | None:
     drop unset fields from request bodies. Empty Markdown is rendered as an
     empty string to stay consistent with the inbound converter behaviour.
 
+    A lone surrogate is written as U+FFFD, the way CommonMark writes a NUL:
+    cmark-gfm renders UTF-8, which cannot carry one, so the whole write
+    failed on a single character. Python strings can hold one -- decoding
+    with ``surrogateescape``, or ``json.loads`` of an unpaired ``\\ud800``
+    escape -- and the rest of the body keeps its Markdown.
+
     A failure is recorded in :data:`_LAST_CONTENT_FAULT` before it is
     raised, because raising it is not enough on its own: see
     :func:`restoring_content_faults`.
@@ -175,7 +186,7 @@ def _to_transport(value: str | None) -> str | None:
     if value is None:
         return None
     try:
-        return GlpiContentConverter.to_transport(value)
+        return GlpiContentConverter.to_transport(_LONE_SURROGATE.sub("\ufffd", value))
     except GlpiContentError as exc:
         _LAST_CONTENT_FAULT.set(exc)
         raise

{glpi_python_client-0.6.0.dist-info → glpi_python_client-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: glpi-python-client
-Version: 0.6.0
+Version: 0.6.2
 Summary: A typed Python client for GLPI ITSM APIs.
 Project-URL: Homepage, https://github.com/baraline/glpi_python_client
 Project-URL: Documentation, https://glpi-python-client.readthedocs.io/en/latest/
@@ -27,9 +27,9 @@ Requires-Dist: beautifulsoup4>=4.15
 Requires-Dist: cmarkgfm>=2025.10
 Requires-Dist: httpx>=0.28
 Requires-Dist: lxml>=4.9
-Requires-Dist: markdown-it-py>=3.0
-Requires-Dist: markdownify>=1.2
-Requires-Dist: mdformat-tables>=1.0
+Requires-Dist: markdown-it-py<4,>=3.0
+Requires-Dist: markdownify<1.3,>=1.2.3
+Requires-Dist: mdformat-tables<1.1,>=1.0
 Requires-Dist: mdformat<0.8,>=0.7.22
 Requires-Dist: pydantic>=2.8
 Requires-Dist: sniffio>=1.3

{glpi_python_client-0.6.0.dist-info → glpi_python_client-0.6.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-glpi_python_client/__init__.py,sha256=5ea1QJ2u_7suINrrs6xpXzkDM-stCYbsfZI9Kdlnirw,5538
-glpi_python_client/_errors.py,sha256=Nd3qciU9WMXiHIZmq4tMq37P_bSlq8lhmQqrjUBOkVk,7133
+glpi_python_client/__init__.py,sha256=DGjWsC96c-1sfryxVwHThPASrR5sy0IpNiooeAVx5Wk,5538
+glpi_python_client/_errors.py,sha256=Bc9UvlxulbdcGvzZIKXnJCTL78sW78R6EFg50P-1dpY,7151
 glpi_python_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 glpi_python_client/rsql.py,sha256=3u3lH3_-F1bvHbVzxALXTDPoHyoMATP1f4QPTar_sEU,8974
 glpi_python_client/_async/__init__.py,sha256=dsDxBNsx94R_-8IBrGj99JidRAnuTQ-10iLA4gtRJhs,602
 glpi_python_client/_async/_concurrency.py,sha256=hd0fGFf-lxQNnx6OFRX0pGCfA3jUOw4RzRpWlEfCqII,2688
-glpi_python_client/_async/_testing.py,sha256=AJSonZXqRZ1MIqO46HytwjFd33vWhAbagFGcxytv4wA,5286
+glpi_python_client/_async/_testing.py,sha256=xznvwVRgBEPE8QA4ilkWs9Wn0bdn1DdTYX8sOtEYrxs,5346
 glpi_python_client/_async/auth/__init__.py,sha256=h9xb1RcWtgHiod5a7ZDCiMaXJjS9C8J4KtwkkuxGykQ,455
 glpi_python_client/_async/auth/_v1_session.py,sha256=3t1OammbfUm9E-ANynrBFryxjx5UbbuZa4QHrH36IkI,18023
 glpi_python_client/_async/auth/auth.py,sha256=1vGG5uBNG8lMjcm20-mgcsH2e0GWKGujQo4k6vck1lE,14694
@@ -50,7 +50,7 @@ glpi_python_client/_async/clients/custom/_statistics.py,sha256=GFgxHLWWZvQzHxl2b
 glpi_python_client/_async/clients/custom/_ticket_context.py,sha256=9E01Rz2K1HBuiQz8x90UIDYzJy1t-7fLlz-k__8srT8,3021
 glpi_python_client/_sync/__init__.py,sha256=dsDxBNsx94R_-8IBrGj99JidRAnuTQ-10iLA4gtRJhs,602
 glpi_python_client/_sync/_concurrency.py,sha256=453f9hXoEOlWoQWDOzn65THBrP8xsRK4yc8jM-BJb_U,1574
-glpi_python_client/_sync/_testing.py,sha256=1lPzYl53HWkSXpGpFKWzf8bhrtervBSHXMVR78b0oGM,5242
+glpi_python_client/_sync/_testing.py,sha256=l_F9uQbY9wByaXBlyNGLy7jfLyN4TYpGicVE59RBudg,5302
 glpi_python_client/_sync/auth/__init__.py,sha256=wgr3wpYpbLMWvcTyH_Yw0Rg9FpLR68OOkaY92E6Vy7k,453
 glpi_python_client/_sync/auth/_v1_session.py,sha256=dlnYA2yi_aWI6wTpfnRD3nzRvnw1lbx-0BP-KD4jJYs,17870
 glpi_python_client/_sync/auth/auth.py,sha256=azWE3bqDswxU-PtO-m_aKb-luSVPRrRXDVuq2aFRz18,14608
@@ -95,12 +95,12 @@ glpi_python_client/_sync/clients/custom/__init__.py,sha256=sxfGlHVulucP7bacWhUMi
 glpi_python_client/_sync/clients/custom/_statistics.py,sha256=xrD5C99ieROJx60iUomBHacQ_49HpgQL4XjnfREUQvs,38616
 glpi_python_client/_sync/clients/custom/_ticket_context.py,sha256=LDUvKNr8VpZonF5bDo8QYYwMEsWmayVU28Ra3GonNmE,3004
 glpi_python_client/content/__init__.py,sha256=3H4IbrNhgFO0BJrc0xLoeXrFHUE1nqOaDlNgi2MtK9k,365
-glpi_python_client/content/conversion.py,sha256=3tF6fvw-yb8UJiJ0qBh1e0GqEBXs780wRCKl8nyNgN0,24750
+glpi_python_client/content/conversion.py,sha256=0IjZ-36WlGMGwo4sHk92bZ3DDsZxVK0YKGCwrFlnRpo,33158
 glpi_python_client/models/__init__.py,sha256=b6DPZtH0CxyBUnVB0x9vP9AMBIjgubDFm_1TOQuCiVA,5362
 glpi_python_client/models/_base.py,sha256=pYg69KHuR5TDED5utr4Knr7HncBnLTxXHJZYf6vEUKA,12183
 glpi_python_client/models/api_schema/__init__.py,sha256=yTxUYih1Xy7NUogzD7UKp2b8HyE4wdeC_FCKS6ZRVVM,1176
 glpi_python_client/models/api_schema/_common.py,sha256=wVtaIkUM9iS3jyDb0bpFopEkP_3vP1ax7D8rwHe9QkI,2004
-glpi_python_client/models/api_schema/_content.py,sha256=OMdcJ4J9-FnRM-EF_WtnVyIM4OzRY_4fJZZxA0hDCIM,12268
+glpi_python_client/models/api_schema/_content.py,sha256=DlsEmlXIK_0jyXh3j5PgU6vkwch2o0I8UpUkLq2fqYw,12826
 glpi_python_client/models/api_schema/enums.py,sha256=WDdEhnB_-ZggvY0RTnAX6C6bN8extGzpE9An-Nk5QuQ,4834
 glpi_python_client/models/api_schema/administration/__init__.py,sha256=uTr2rEMYq47T5foUMHm1rtsBmEQvdD1EQw5CZOUN38Y,706
 glpi_python_client/models/api_schema/administration/_entity.py,sha256=KdbxMyPXumGZKmmabDIciF3nFS61pLRp5SBOTFa8slk,3297
@@ -135,7 +135,7 @@ glpi_python_client/models/custom_schema/_ticket_context.py,sha256=jnlfgho-aDbmA9
 glpi_python_client/testing/__init__.py,sha256=iLtUyJjyv3fEhy3PN25NxNTbtqDl3SoHLbNium0Z80U,568
 glpi_python_client/testing/fixtures.py,sha256=HKt6MXHgcmLn4L98pSwp-oGlc9C--_vrABNe5G_iBeg,1286
 glpi_python_client/testing/utils.py,sha256=JyO3w2d-0kYdtC1hEZ2Tu_YjnCz8nUQ_Ck05-1EhsX4,4404
-glpi_python_client-0.6.0.dist-info/METADATA,sha256=wfWloBVKKI5itijSk2BjxPEzwhSi6SxOToUmAz9yoTU,8219
-glpi_python_client-0.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-glpi_python_client-0.6.0.dist-info/licenses/LICENSE,sha256=nL8re-TIKkxCoL7OkSBja6EB4NsQR1HoOJgxv_MEhtc,1088
-glpi_python_client-0.6.0.dist-info/RECORD,,
+glpi_python_client-0.6.2.dist-info/METADATA,sha256=9wihyUuKVM3_SjCpxgML5kJfV09itUlO6VTUoMwxzgw,8234
+glpi_python_client-0.6.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+glpi_python_client-0.6.2.dist-info/licenses/LICENSE,sha256=nL8re-TIKkxCoL7OkSBja6EB4NsQR1HoOJgxv_MEhtc,1088
+glpi_python_client-0.6.2.dist-info/RECORD,,