librus-python-api 1.6.1__py3-none-any.whl → 1.6.2__py3-none-any.whl

librus_python_api/__init__.py

@@ -138,7 +138,7 @@ from librus_python_api.models import (
 from librus_python_api.sending import SendAttempt
 from librus_python_api.service import AccountClient, LibrusService
 
-__version__ = "1.6.1"
+__version__ = "1.6.2"
 
 __all__ = [
     "ArchiveAbsences",

librus_python_api/completed_lessons.py

@@ -9,10 +9,12 @@ from lxml import html
 
 from librus_python_api import markup
 from librus_python_api.config import (
+    COMPLETED_LESSONS_COLUMNS,
     COMPLETED_LESSONS_MAX_BATCH_ITEMS,
     COMPLETED_LESSONS_MAX_BATCH_PAGES,
     COMPLETED_LESSONS_MAX_PAGE_COUNT,
     COMPLETED_LESSONS_MAX_PAGE_ITEMS,
+    COMPLETED_LESSONS_OPTIONAL_HEADERS,
     SCHOOL_MAX_CONTENT_LENGTH,
     SCHOOL_MAX_FIELD_LENGTH,
     SCHOOL_MAX_TOTAL_TEXT_LENGTH,
@@ -65,7 +67,8 @@ def validate_selection(
     completed_lessons_form(cursor.start, cursor.end, cursor.page)
 
 
-def _pagination(document: html.HtmlElement, page: int) -> int:
+def _pagination(document: html.HtmlElement, page: int) -> tuple[int, int | None]:
+    """The page count and, when shown, the number of rows the page reports."""
     containers = [
         node
         for node in document.iter("div")
@@ -74,14 +77,19 @@ def _pagination(document: html.HtmlElement, page: int) -> int:
     if not containers:
         if page != 0:
             raise LibrusError(ErrorKind.PARSE)
-        return 1
+        return 1, None
     if len(containers) != 1:
         raise LibrusError(ErrorKind.PARSE)
     spans = [node for node in containers[0] if node.tag == "span"]
     if len(spans) != 1:
         raise LibrusError(ErrorKind.PARSE)
     value = markup.text(spans[0], SCHOOL_MAX_FIELD_LENGTH)
-    match = re.fullmatch(r"(?:Strona\s+)?([0-9]{1,4})\s+z\s+([0-9]{1,4})", value, re.I)
+    match = re.fullmatch(
+        r"(?:Strona\s+)?([0-9]{1,4})\s+z\s+([0-9]{1,4})"
+        r"(?:\s+Pozycje\s+([0-9]{1,6})\.\.([0-9]{1,6})\s+z\s+([0-9]{1,6}))?",
+        value,
+        re.I,
+    )
     if match is None:
         raise LibrusError(ErrorKind.PARSE)
     current, count = int(match[1]), int(match[2])
@@ -89,7 +97,53 @@ def _pagination(document: html.HtmlElement, page: int) -> int:
         raise LibrusError(ErrorKind.LIMIT)
     if not 1 <= current <= count or current != page + 1:
         raise LibrusError(ErrorKind.PARSE)
-    return count
+    if match[3] is None:
+        return count, None
+    # Some schools append the item range: "Pozycje first..last z total".
+    first, last, total = int(match[3]), int(match[4]), int(match[5])
+    if not 1 <= first <= last <= total:
+        raise LibrusError(ErrorKind.PARSE)
+    return count, last - first + 1
+
+
+def _optional_columns(table: html.HtmlElement) -> frozenset[int]:
+    """Row positions of optional columns, located by their header labels."""
+    positions: set[int] = set()
+    for row in markup.rows(table):
+        if not markup.in_header(row):
+            continue
+        position = 0
+        labels = [
+            (cell, markup.text(cell, SCHOOL_MAX_FIELD_LENGTH))
+            for cell in markup.cells(row)
+        ]
+        if not any(label in COMPLETED_LESSONS_OPTIONAL_HEADERS for _, label in labels):
+            continue
+        if positions:
+            raise LibrusError(ErrorKind.PARSE)
+        for cell, label in labels:
+            span = markup.colspan(cell)
+            if label in COMPLETED_LESSONS_OPTIONAL_HEADERS:
+                if span != 1:
+                    raise LibrusError(ErrorKind.PARSE)
+                positions.add(position)
+            position += span
+        # A labelled header must describe exactly the row layout it extends.
+        if position != COMPLETED_LESSONS_COLUMNS + len(positions):
+            raise LibrusError(ErrorKind.PARSE)
+    return frozenset(positions)
+
+
+def _closing_row(row: html.HtmlElement, width: int) -> bool:
+    """A blank full-width row that closes some schools' tables, not a lesson."""
+    cells = markup.cells(row)
+    return (
+        len(cells) == 1
+        and cells[0].tag == "td"
+        and markup.colspan(cells[0]) == width
+        and not any(isinstance(node.tag, str) for node in cells[0])
+        and not markup.text(cells[0], SCHOOL_MAX_FIELD_LENGTH)
+    )
 
 
 def _day(value: str) -> date:
@@ -109,15 +163,24 @@ def _day(value: str) -> date:
     return result
 
 
-def _lesson(row: html.HtmlElement, start: date, end: date) -> CompletedLesson:
+def _lesson(
+    row: html.HtmlElement, start: date, end: date, optional: frozenset[int]
+) -> CompletedLesson:
     cells = markup.cells(row)
-    if len(cells) != 7 or any(
+    if len(cells) != COMPLETED_LESSONS_COLUMNS + len(optional) or any(
         cell.tag != "td"
         or cell.get("rowspan", "1") != "1"
         or cell.get("colspan", "1") != "1"
         for cell in cells
     ):
         raise LibrusError(ErrorKind.PARSE)
+    for index in optional:
+        # Content in an optional column is not modelled; never drop it silently.
+        if any(isinstance(node.tag, str) for node in cells[index]) or markup.text(
+            cells[index], SCHOOL_MAX_FIELD_LENGTH
+        ):
+            raise LibrusError(ErrorKind.UNSUPPORTED_CAPABILITY)
+    cells = [cell for index, cell in enumerate(cells) if index not in optional]
     date_cells = [
         c for c in cells if {"center", "small"} <= set(c.get("class", "").split())
     ]
@@ -140,7 +203,8 @@ def _lesson(row: html.HtmlElement, start: date, end: date) -> CompletedLesson:
     raw_number, combined, topic, z_value, symbol = values
     if raw_number not in {"", "-"} and re.fullmatch(r"[0-9]{1,2}", raw_number) is None:
         raise LibrusError(ErrorKind.PARSE)
-    names = combined.split(", ")
+    # Some schools render "<b>Subject</b>, <br>Teacher" or pad the comma.
+    names = [name.strip() for name in combined.split(",")]
     subject, teacher = (names[0], names[1]) if len(names) == 2 else (combined, None)
     if not subject or teacher == "":
         raise LibrusError(ErrorKind.PARSE)
@@ -174,9 +238,13 @@ def parse_completed_lessons(
 ) -> tuple[tuple[CompletedLesson, ...], int, str]:
     completed_lessons_form(start, end, page)
     document = parse_page(body)
-    count = _pagination(document, page)
+    count, reported = _pagination(document, page)
+    # A date-filter form table shares the "decorated" class with the data table.
     tables = [
-        t for t in document.iter("table") if "decorated" in t.get("class", "").split()
+        t
+        for t in document.iter("table")
+        if "decorated" in (classes := t.get("class", "").split())
+        and "filters" not in classes
     ]
     empty = [
         n
@@ -190,10 +258,12 @@ def parse_completed_lessons(
     if tables:
         if list(tables[0].iterdescendants("table")):
             raise LibrusError(ErrorKind.UNSUPPORTED_CAPABILITY)
-        for row in markup.rows(tables[0]):
-            if next(row.iterancestors("thead"), None) is not None:
-                continue
-            item = _lesson(row, start, end)
+        optional = _optional_columns(tables[0])
+        lines = [row for row in markup.rows(tables[0]) if not markup.in_header(row)]
+        if lines and _closing_row(lines[-1], COMPLETED_LESSONS_COLUMNS + len(optional)):
+            lines.pop()
+        for row in lines:
+            item = _lesson(row, start, end, optional)
             total += sum(len(v) for v in astuple(item) if isinstance(v, str))
             items.append(item)
             if (
@@ -201,6 +271,8 @@ def parse_completed_lessons(
                 or total > SCHOOL_MAX_TOTAL_TEXT_LENGTH
             ):
                 raise LibrusError(ErrorKind.LIMIT)
+    if reported is not None and reported != len(items):
+        raise LibrusError(ErrorKind.PARSE)
     if (items and empty) or (not items and (not empty or count != 1 or page != 0)):
         raise LibrusError(ErrorKind.PARSE)
     # An unrecognized notice next to an empty marker is not a valid empty page.

librus_python_api/config.py

@@ -731,6 +731,8 @@ ATTENDANCE_MAX_SUBJECTS = 1024
 ATTENDANCE_DETAIL_PATH_PREFIX = "/przegladaj_nb/szczegoly/"
 # Recognition only: formative detail links are classified, never requested.
 FORMATIVE_DETAIL_PATH_PREFIX = "/przegladaj_oceny/szczegoly/ksztaltujace/"
+# Recognition only: behaviour-point detail links are classified, never requested.
+BEHAVIOUR_POINTS_DETAIL_PATH_PREFIX = "/przegladaj_oceny/zachowanie_szczegoly/"
 FORMATIVE_HEADERS = (
     "przedmiot",
     "ocena kształtująca",
@@ -882,6 +884,10 @@ COMPLETED_LESSONS_MAX_PAGE_COUNT = 1000
 COMPLETED_LESSONS_MAX_PAGE_ITEMS = 256
 COMPLETED_LESSONS_MAX_BATCH_PAGES = 8
 COMPLETED_LESSONS_MAX_BATCH_ITEMS = 256
+# Header labels of columns some schools add to the completed-lesson table. Their
+# content is not modelled: such a column must be empty in every lesson row.
+COMPLETED_LESSONS_OPTIONAL_HEADERS = frozenset({"e-Tablica"})
+COMPLETED_LESSONS_COLUMNS = 7
 AGENDA_DETAIL_PATH_PREFIX = "/terminarz/szczegoly/"
 # Recognition only: closure details are not ordinary agenda-detail references.
 AGENDA_CLOSURE_DETAIL_PATH_PREFIX = "/terminarz/szczegoly_wolne/"
@@ -931,7 +937,6 @@ MODERN_DIRECTORY_QUERIES = MappingProxyType(
         "modern_recipients": (("receiverType", "parentsCouncil"),),
     }
 )
-MODERN_SUPPORTED_RECIPIENT_TYPE = "parentsCouncil"
 MODERN_RECIPIENT_OPERATIONS = MappingProxyType(
     {
         **{

librus_python_api/detail_fields.py

@@ -34,7 +34,6 @@ def normalize_detail_fields(
     fields: tuple[tuple[str, str], ...],
     kind: Literal["agenda", "homework", "attendance"],
 ) -> tuple[DetailField, ...]:
-    """Run after bounded HTML parsing, before publishing or caching a result."""
     labels: set[str] = set()
     keys: set[DetailFieldKey] = set()
     result = []

librus_python_api/formative_grades.py

@@ -31,7 +31,6 @@ def _fail(kind: ErrorKind) -> NoReturn:
 
 
 def is_formative_table(table: html.HtmlElement) -> bool:
-    # Cheap structural gates first: other tables' header text is never read.
     if not {"stretch", "decorated"} <= set(table.get("class", "").split()):
         return False
     heads = [row for row in markup.rows(table) if markup.in_header(row)]

librus_python_api/grade_records.py

@@ -8,6 +8,7 @@ from lxml import html
 
 from librus_python_api import markup
 from librus_python_api.config import (
+    BEHAVIOUR_POINTS_DETAIL_PATH_PREFIX,
     FORMATIVE_DETAIL_PATH_PREFIX,
     GRADE_AVERAGE_HEADERS,
     GRADE_BODY_PREFIX_COLUMNS,
@@ -16,6 +17,7 @@ from librus_python_api.config import (
     GRADE_MAX_METADATA_LENGTH,
     GRADE_MAX_RECORDS,
     GRADE_MAX_SUBJECTS,
+    GRADE_MERGED_SUBJECTS,
     GRADE_PERIOD_HEADERS,
     GRADE_PREDICTED_ANNUAL_HEADER,
     GRADE_PREDICTED_PERIOD_HEADERS,
@@ -174,6 +176,50 @@ def _boxes(cell: html.HtmlElement) -> list[html.HtmlElement]:
     ]
 
 
+def _behaviour_points(cell: html.HtmlElement, collection: _Collection) -> bool:
+    """Recognize and validate a behaviour-points cell; points are not grades.
+
+    The cell holds one points tooltip (starting points or a running total; its
+    title is not interpreted) and point entries linking to behaviour details,
+    each with its own unlabelled tooltip. Any other content next to the points
+    tooltip fails instead of being skipped.
+    """
+    tallies = [
+        node
+        for node in cell
+        if node.tag == "span" and "tooltip" in node.get("class", "").split()
+    ]
+    if not tallies:
+        return False
+    elements = [node for node in cell if isinstance(node.tag, str)]
+    boxes = [node for node in elements if node not in tallies]
+    if (
+        len(tallies) != 1
+        or len(tallies[0])
+        or not re.fullmatch(r"-?[0-9]{1,4}", markup.text(tallies[0]))
+        or (cell.text or "").strip()
+        or any((node.tail or "").strip() for node in cell)
+        or _boxes(cell) != boxes
+    ):
+        raise LibrusError(ErrorKind.PARSE)
+    for box in boxes:
+        anchors = [node for node in box if isinstance(node.tag, str)]
+        if (
+            box.getparent() is not cell
+            or len(anchors) != 1
+            or anchors[0].tag != "a"
+            or len(anchors[0])
+            or markup.detail_id(
+                anchors[0].get("href"), BEHAVIOUR_POINTS_DETAIL_PATH_PREFIX
+            )
+            is None
+            or not re.fullmatch(r"[+-]?[0-9]{1,4}", markup.text(anchors[0]))
+        ):
+            raise LibrusError(ErrorKind.PARSE)
+        collection.consumed.add(box)
+    return True
+
+
 def _entries(
     cell: html.HtmlElement,
     subject: str,
@@ -320,9 +366,13 @@ def _read_numeric_table(table: html.HtmlElement, collection: _Collection) -> Non
         seen: set[html.HtmlElement] = set()
         for period, index in enumerate(current, start=1):
             if columns[index] not in seen:
-                _entries(
-                    columns[index], subject, cast(Literal[1, 2], period), collection
-                )
+                if not (
+                    subject in GRADE_MERGED_SUBJECTS
+                    and _behaviour_points(columns[index], collection)
+                ):
+                    _entries(
+                        columns[index], subject, cast(Literal[1, 2], period), collection
+                    )
                 seen.add(columns[index])
         for (period, kind), index in periods.items():
             cell = columns[index]

librus_python_api/notification_persistence.py

@@ -144,7 +144,6 @@ def _seen_after(
 class NotificationStore(_SQLiteStore):
     """Private native recovery store. No MCP files, auto migration or live access.
 
-    Context locks require POSIX flock. Unsupported platforms fail explicitly.
     Raw checkpoints contain private account/content metadata, never HTTP cookies.
     """
 

librus_python_api/persistence.py

@@ -1,4 +1,4 @@
-"""Explicit optional durable sending, independent of MCP and core transport."""
+"""Durable sending and the notification store and workflow."""
 
 import hashlib
 import json

librus_python_api/transport.py

@@ -210,51 +210,51 @@ class AiohttpTransport:
         self._modern_session: aiohttp.ClientSession | None = None
         self._closed = False
 
+    def _open_session(
+        self,
+        *,
+        cookie_jar: aiohttp.abc.AbstractCookieJar | None = None,
+        read_bufsize: int = 16 * 1024,
+        per_request_timeout: bool = False,
+    ) -> aiohttp.ClientSession:
+        _require_no_connection_retry()
+        timeout = (
+            None
+            if per_request_timeout
+            else aiohttp.ClientTimeout(
+                total=self._limits.request_timeout_seconds,
+                connect=self._limits.connect_timeout_seconds,
+            )
+        )
+        session = aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(
+                limit=1,
+                ssl=self._connection.ssl_context or True,
+            ),
+            cookie_jar=aiohttp.CookieJar() if cookie_jar is None else cookie_jar,
+            trust_env=False,
+            auto_decompress=False,
+            read_bufsize=read_bufsize,
+            timeout=timeout,
+            headers={"Accept-Encoding": "identity", "User-Agent": USER_AGENT},
+        )
+        # aiohttp otherwise silently replays GET on a stale keepalive
+        # connection. Some GETs mark read; every attempt must be budgeted.
+        session._retry_connection = False
+        return session
+
     def _get_session(self) -> aiohttp.ClientSession:
         if self._closed:
             raise LibrusError(ErrorKind.CLOSED)
         if self._session is None:
-            _require_no_connection_retry()
-            self._session = aiohttp.ClientSession(
-                connector=aiohttp.TCPConnector(
-                    limit=1,
-                    ssl=self._connection.ssl_context or True,
-                ),
-                cookie_jar=aiohttp.CookieJar(),
-                trust_env=False,
-                auto_decompress=False,
-                read_bufsize=16 * 1024,
-                timeout=aiohttp.ClientTimeout(
-                    total=self._limits.request_timeout_seconds,
-                    connect=self._limits.connect_timeout_seconds,
-                ),
-                headers={"Accept-Encoding": "identity", "User-Agent": USER_AGENT},
-            )
-            # aiohttp otherwise silently replays GET on a stale keepalive
-            # connection. Some GETs mark read; every attempt must be budgeted.
-            self._session._retry_connection = False
+            self._session = self._open_session()
         return self._session
 
     def _get_modern_session(self) -> aiohttp.ClientSession:
         if self._closed:
             raise LibrusError(ErrorKind.CLOSED)
         if self._modern_session is None:
-            _require_no_connection_retry()
-            self._modern_session = aiohttp.ClientSession(
-                connector=aiohttp.TCPConnector(
-                    limit=1, ssl=self._connection.ssl_context or True
-                ),
-                cookie_jar=aiohttp.CookieJar(),
-                trust_env=False,
-                auto_decompress=False,
-                read_bufsize=16 * 1024,
-                timeout=aiohttp.ClientTimeout(
-                    total=self._limits.request_timeout_seconds,
-                    connect=self._limits.connect_timeout_seconds,
-                ),
-                headers={"Accept-Encoding": "identity", "User-Agent": USER_AGENT},
-            )
-            self._modern_session._retry_connection = False
+            self._modern_session = self._open_session()
         return self._modern_session
 
     def _url(self, endpoint: Endpoint) -> str:
@@ -392,25 +392,12 @@ class AiohttpTransport:
         budget: RequestBudget,
         dispatched: Callable[[], None],
     ) -> TransportResponse:
-        payload = encode_modern_send(submission, self._account)
-        if self._closed:
-            raise LibrusError(ErrorKind.CLOSED)
-        kind: ErrorKind | None = None
-        try:
-            return await self._scheduler.run(
-                self._account,
-                budget,
-                partial(self._send_exchange, payload, budget, dispatched, modern=True),
-                preserve_completed=True,
-            )
-        except aiohttp.ClientError:
-            kind = ErrorKind.CONNECTION
-        except TimeoutError:
-            kind = ErrorKind.TIMEOUT
-        except (ValueError, OverflowError, zlib.error):
-            kind = ErrorKind.PARSE
-        assert kind is not None
-        raise LibrusError(kind)
+        return await self._send_exchange(
+            encode_modern_send(submission, self._account),
+            budget,
+            dispatched,
+            modern=True,
+        )
 
     async def send_message(
         self,
@@ -418,15 +405,61 @@ class AiohttpTransport:
         budget: RequestBudget,
         dispatched: Callable[[], None],
     ) -> TransportResponse:
-        payload = encode_send_form(submission, self._account)
+        return await self._send_exchange(
+            encode_send_form(submission, self._account),
+            budget,
+            dispatched,
+        )
+
+    async def _send_exchange(
+        self,
+        payload: bytes,
+        budget: RequestBudget,
+        dispatched: Callable[[], None],
+        *,
+        modern: bool = False,
+    ) -> TransportResponse:
         if self._closed:
             raise LibrusError(ErrorKind.CLOSED)
+
+        async def exchange() -> TransportResponse:
+            endpoint = ENDPOINTS["modern_send_message" if modern else "send_message"]
+            session = self._get_modern_session() if modern else self._get_session()
+            proxy = self._connection.proxy_url
+            dispatched()
+            async with session.post(
+                self._url(endpoint),
+                data=payload,
+                headers={
+                    "Content-Type": "application/json"
+                    if modern
+                    else "application/x-www-form-urlencoded; charset=utf-8"
+                },
+                allow_redirects=False,
+                proxy=proxy.get_secret_value() if proxy is not None else None,
+            ) as response:
+                self._check_headers(response)
+                if len(session.cookie_jar) > self._limits.max_cookies:
+                    session.cookie_jar.clear()
+                    raise LibrusError(ErrorKind.LIMIT)
+                if not modern or response.status not in (400, 422):
+                    self._check_status(response)
+                body = await self._read_body(response, budget)
+                return TransportResponse(
+                    response.status,
+                    body,
+                    str(response.url),
+                    MappingProxyType(
+                        {k.lower(): v for k, v in response.headers.items()}
+                    ),
+                )
+
         kind: ErrorKind | None = None
         try:
             return await self._scheduler.run(
                 self._account,
                 budget,
-                partial(self._send_exchange, payload, budget, dispatched),
+                exchange,
                 preserve_completed=True,
             )
         except aiohttp.ClientError:
@@ -438,43 +471,6 @@ class AiohttpTransport:
         assert kind is not None
         raise LibrusError(kind)
 
-    async def _send_exchange(
-        self,
-        payload: bytes,
-        budget: RequestBudget,
-        dispatched: Callable[[], None],
-        *,
-        modern: bool = False,
-    ) -> TransportResponse:
-        endpoint = ENDPOINTS["modern_send_message" if modern else "send_message"]
-        session = self._get_modern_session() if modern else self._get_session()
-        proxy = self._connection.proxy_url
-        dispatched()
-        async with session.post(
-            self._url(endpoint),
-            data=payload,
-            headers={
-                "Content-Type": "application/json"
-                if modern
-                else "application/x-www-form-urlencoded; charset=utf-8"
-            },
-            allow_redirects=False,
-            proxy=proxy.get_secret_value() if proxy is not None else None,
-        ) as response:
-            self._check_headers(response)
-            if len(session.cookie_jar) > self._limits.max_cookies:
-                session.cookie_jar.clear()
-                raise LibrusError(ErrorKind.LIMIT)
-            if not modern or response.status not in (400, 422):
-                self._check_status(response)
-            body = await self._read_body(response, budget)
-            return TransportResponse(
-                response.status,
-                body,
-                str(response.url),
-                MappingProxyType({k.lower(): v for k, v in response.headers.items()}),
-            )
-
     async def consume_schedule_events(
         self,
         budget: RequestBudget,
@@ -607,18 +603,11 @@ class AiohttpTransport:
         if self._closed:
             raise LibrusError(ErrorKind.CLOSED)
         if self._download_session is None:
-            _require_no_connection_retry()
-            self._download_session = aiohttp.ClientSession(
-                connector=aiohttp.TCPConnector(
-                    limit=1, ssl=self._connection.ssl_context or True
-                ),
+            self._download_session = self._open_session(
                 cookie_jar=aiohttp.DummyCookieJar(),
-                trust_env=False,
-                auto_decompress=False,
                 read_bufsize=ATTACHMENT_CHUNK_BYTES,
-                headers={"Accept-Encoding": "identity", "User-Agent": USER_AGENT},
+                per_request_timeout=True,
             )
-            self._download_session._retry_connection = False
         return self._download_session
 
     async def stream_download(

{librus_python_api-1.6.1.dist-info → librus_python_api-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: librus-python-api
-Version: 1.6.1
+Version: 1.6.2
 Summary: Independent bounded async Librus Synergia client
 Project-URL: Repository, https://github.com/krzysztofbury/librus-python-api
 Project-URL: Issues, https://github.com/krzysztofbury/librus-python-api/issues
@@ -42,7 +42,8 @@ private ACLs. Windows installations include `pywin32` and `tzdata` automatically
 Network paths, reparse-point paths and unsafe storage permissions fail closed.
 See [platform requirements](contracts/persistence.md#windows-disk-boundary-25).
 
-**Status:** `1.6.1` fixes Sunday grade-date labels and calendar closure events.
+**Status:** `1.6.2` accepts more completed-lesson and grade layouts, including
+behaviour points, which are validated and not reported as grades.
 Class free days, typed capability outcomes and the live-check freshness watchdog
 remain available. See [verification](VERIFICATION.md).
 The stable 1.x API does not guarantee every school layout. School features depend
@@ -54,7 +55,7 @@ See [limitations](#supported-features-and-limitations) below.
 Install the exact release from PyPI after its gated publication completes:
 
 ```sh
-python -m pip install librus-python-api==1.6.1
+python -m pip install librus-python-api==1.6.2
 ```
 
 Pin the exact version qualified by your application. Before publication, use a
@@ -70,7 +71,7 @@ python -m pip install .
 To install a locally built wheel instead:
 
 ```sh
-python -m pip install ./dist/librus_python_api-1.6.1-py3-none-any.whl
+python -m pip install ./dist/librus_python_api-1.6.2-py3-none-any.whl
 ```
 
 No CLI or background process is installed: import the library in your own program.

{librus_python_api-1.6.1.dist-info → librus_python_api-1.6.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-librus_python_api/__init__.py,sha256=xKt_-6GBCNzMZZdK3BH_ItqM6TbgoB-4vwhUBjDcsNw,6513
+librus_python_api/__init__.py,sha256=ZLWweFJqQFf-SdkQ7pHclXOKI0b-bfqNbNN1u14333w,6513
 librus_python_api/_notification_bootstrap.py,sha256=18nzH0doXBNaZXCz-_ckIvRrlHTWV5Mm1t5m2-5eYGI,4669
 librus_python_api/_notification_codec.py,sha256=hU6G3zGJ5fR8wfPC6fV2OqBKs-7XpT9eRnKO3FGsTzY,13451
 librus_python_api/_storage.py,sha256=M_6ZAzN4zs7laOdKJBRH1I2rvy3pgqYgC_MZtsd2xtM,15893
@@ -11,15 +11,15 @@ librus_python_api/attendance_frequency.py,sha256=SBhED5zuyRIHWdw4urFyTJYykb6EYB7
 librus_python_api/budget.py,sha256=8fvqT7eIxyVX2P2OBG27XsYHk_HbtSS4lzuecYpHtgs,2878
 librus_python_api/checkpoint.py,sha256=QBmG9GtpyaGRaFq-FXuGA3yR1BjuMFN9V3RTvvi_FNQ,1930
 librus_python_api/class_free_days.py,sha256=IwoCgr-9ZgEYYQ6717s4cDpyFzbosHMzESMabXJLGqA,2422
-librus_python_api/completed_lessons.py,sha256=sR2oLSGb2q1580l-2upCBv9sQfIcHi7CQfWr1K0EFXI,7635
-librus_python_api/config.py,sha256=ZkYxYxBy-FLNMpZSu3U9itHpoyrOCgZSG0dUdWgGGAY,55749
-librus_python_api/detail_fields.py,sha256=K10Stx_ehDTttkUI7-G7a2Ko9exYEu5NJpR-3sBnQ60,1789
+librus_python_api/completed_lessons.py,sha256=ngGfBD6K4B6dR4elPYvNRvp40Q-GlrhUsUKqBbYY1KE,10727
+librus_python_api/config.py,sha256=KEDe6KgS6XMjMViUexgUqlQnBtFVskVLd8NrVADD7BU,56109
+librus_python_api/detail_fields.py,sha256=vDDi5sV-e30-42SF0hwAUoldiZ5wvYtb1UlLt03lBHw,1708
 librus_python_api/diagnostics.py,sha256=2l7wq6RA3it-Gwj-JRLcw5qbI37fl3xII6GZA2mZj0o,856
 librus_python_api/exceptions.py,sha256=adVcJuzfB8wGrUlF2SfiyIlE9ZZyTAvGdWRtQIjsA3I,4879
 librus_python_api/files.py,sha256=pQBsIJyfTOZDz83ZB-5fcd-nPMcxR1HJ155h4zTHmsA,9223
-librus_python_api/formative_grades.py,sha256=-F-d1rnFVAIGwg1mN0cryCIBR76OW3v2L4mCWUZ3M7Q,6227
+librus_python_api/formative_grades.py,sha256=K_Qj13XMowYsIR10PjQqZ0MMta5eXIzLgQKCPL6yFJM,6150
 librus_python_api/grade_parsers.py,sha256=91Kr1-TArzqO-b94ipeIR0a98OV7tRCZQdBWsd9QLZ0,6141
-librus_python_api/grade_records.py,sha256=K0ZzmU1KsA8Jo1MXh30mStApgrigaOKk5ldoBnwRrH8,17901
+librus_python_api/grade_records.py,sha256=tGi1037deTacvfDYmiKf-N7McyKcyos6NPuBk_H_M3U,19794
 librus_python_api/homework_range.py,sha256=erYfvS6PhHU5XhnR6LkiLNy677hGVflY3UAuHOs-YUw,1663
 librus_python_api/lifecycle.py,sha256=XzA5CEdZFo7iL5IMUrawnRvf2m9BFe0OseP-fpQFaAE,856
 librus_python_api/markup.py,sha256=vd483NSUQbVYvSV2IaUmsyGcRhpWtbyDHMeEhbc7siA,5713
@@ -30,12 +30,12 @@ librus_python_api/modern_body.py,sha256=3L4P_cIrHdIxZqiinFSQrDMhG6iklT1GoA-VEWMJ
 librus_python_api/modern_mailbox.py,sha256=2jF9UnJZ5AF6dip-GrMcv_z2kSLpp87dIpVeXk9jMzA,20600
 librus_python_api/modern_messages.py,sha256=qt2CXtrxCZQ-jTt0aQCD6ZaPAJQZXf0BxmvacPo9B0w,10653
 librus_python_api/notification_models.py,sha256=4eLTAE9JzHhveoaWtZQwGBolmb87QUP5kOSW7Jjt7J0,4199
-librus_python_api/notification_persistence.py,sha256=hXKmzAh0yNYG_n5CLlZOcoYOZdQnlrSeNtjjXiDmLm4,49532
+librus_python_api/notification_persistence.py,sha256=8GYPbCVD0AecrC4IUXFkHkhNS-uGXkXzsuKxreTIk9I,49454
 librus_python_api/notification_workflow.py,sha256=MsBJdwn6J1UUGlz3Ldzi7WEBz5Qsama7eGmZvUQj25g,12924
 librus_python_api/notifications.py,sha256=VbA8pqNG_19yYo9y7IqpGRmfEb4qDcvA5gBb1syGJKs,7806
 librus_python_api/parsers.py,sha256=OFztbUMDzCywq17BgfFT485bVjyOqLksFHQJthZCx5Q,8120
 librus_python_api/parsing.py,sha256=H71srw5yx-RFrAKZFgj-QFX-DIXZmhnGrDTmJhazCB8,1838
-librus_python_api/persistence.py,sha256=C5oDHQg1Xzy9Jb9obVsRNndCiXps-QQQtQ_M7_l5BBI,15546
+librus_python_api/persistence.py,sha256=F35yBRu6D8aYgdwKTpzVdqVTyiUaLQludUmyyskb3Vo,15529
 librus_python_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 librus_python_api/recipients.py,sha256=6GQCKo-Zjg3VFSg1J8YXcDsy_U3r6-MUS4VCvz0xdaQ,10033
 librus_python_api/scheduler.py,sha256=3JplYxqvQdFz3aKXcoQUJHE9s3FPw_xRhQ2CPNLuQmA,10729
@@ -44,8 +44,8 @@ librus_python_api/school_year_archive.py,sha256=D0A1ywMKgoYgvi-d70__SFreMGvMb_72
 librus_python_api/sending.py,sha256=Nvvk2r-6D6Us53a2fH5GW9PcA6bWEfuOvy6c3M5QVcE,4549
 librus_python_api/service.py,sha256=7ioLx-8C-I0Qla8YUyu5UqhjBPlcUvEFpQSYH-9yjzs,96232
 librus_python_api/timetable.py,sha256=tX1QK9fQABxzfLaHHqTe8e6rAgdOkCoTOfAHdPwNmLE,9836
-librus_python_api/transport.py,sha256=QnYXnrv1lW4qToYoTv6HyZw-Lt4rDc-_SMTJpMp6_bc,35297
-librus_python_api-1.6.1.dist-info/METADATA,sha256=rMKHaG2F1BVuZ7gCBUdhmQXT8Ox6wrRSsiyN4UQXqqg,12005
-librus_python_api-1.6.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-librus_python_api-1.6.1.dist-info/licenses/LICENSE,sha256=IuerLb3cnZCsaB23znydjjvKqP-LmSJd3syKa9NGUts,1071
-librus_python_api-1.6.1.dist-info/RECORD,,
+librus_python_api/transport.py,sha256=VslHio0FrOiTkISfLNDlGVV_MeGAYidHDKZnoVUIwrI,34310
+librus_python_api-1.6.2.dist-info/METADATA,sha256=l317hh6HLcjPf2_EHZN2pVOMuoJvBNqaU8RcBtdhaaU,12070
+librus_python_api-1.6.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+librus_python_api-1.6.2.dist-info/licenses/LICENSE,sha256=IuerLb3cnZCsaB23znydjjvKqP-LmSJd3syKa9NGUts,1071
+librus_python_api-1.6.2.dist-info/RECORD,,