librus-python-api 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

librus_python_api/__init__.py

@@ -1,5 +1,8 @@
 """Independent bounded async client. General live compatibility is unqualified."""
 
+# Before the imports: config reads it for the User-Agent.
+__version__ = "1.8.2"
+
 from librus_python_api.attachments import AttachmentStream, ModernAttachmentStream
 from librus_python_api.budget import RequestBudget
 from librus_python_api.config import (
@@ -138,8 +141,6 @@ from librus_python_api.models import (
 from librus_python_api.sending import SendAttempt
 from librus_python_api.service import AccountClient, LibrusService
 
-__version__ = "1.8.0"
-
 __all__ = [
     "ArchiveAbsences",
     "ArchiveAchievement",

librus_python_api/attachments.py

@@ -15,7 +15,10 @@ from librus_python_api.attachment_routes import (
 )
 from librus_python_api.budget import RequestBudget
 from librus_python_api.config import ATTACHMENT_MAX_BYTES
-from librus_python_api.exceptions import ErrorKind, LibrusError, SessionExpiredError
+from librus_python_api.exceptions import (
+    ErrorKind,
+    LibrusError,
+)
 from librus_python_api.lifecycle import join_owned
 from librus_python_api.models import (
     AttachmentHeaders,
@@ -283,9 +286,7 @@ class ModernAttachmentStream(AttachmentStream):
                 budget,
             )
         except BaseException as error:
-            client._invalidate_modern()
-            if isinstance(error, SessionExpiredError):
-                error._messages_origin = True
+            client._modern_read_failed(error)
             raise
         await client._transport.stream_download(
             key,

librus_python_api/config.py

@@ -31,6 +31,7 @@ from pydantic import (
     model_validator,
 )
 
+from librus_python_api import __version__
 from librus_python_api.exceptions import ErrorKind, LibrusError
 from librus_python_api.models import (
     AttendanceView,
@@ -113,7 +114,7 @@ UPSTREAM_ORIGINS = MappingProxyType(
 OAUTH_QUERY = (("client_id", "46"),)
 SESSION_COOKIE = "oauth_token"
 AUTH_COOKIES = frozenset({SESSION_COOKIE, "DZIENNIKSID", "SDZIENNIKSID"})
-USER_AGENT = "librus-python-api/0.4 (independent client)"
+USER_AGENT = f"librus-python-api/{__version__} (independent client)"
 ENDPOINTS: Mapping[str, Endpoint] = MappingProxyType(
     {
         item.operation_id: item
@@ -435,7 +436,7 @@ ENDPOINTS: Mapping[str, Endpoint] = MappingProxyType(
             ),
             # Gateway reads behind the grades page's new-schema descriptive
             # table. Routes and field names come from public client code and the
-            # official page script, not from an observed populated response.
+            # official page script; one authorized read parsed four records.
             Endpoint(
                 "descriptive_token_info",
                 "GET",
@@ -688,6 +689,21 @@ PROFILE_LABELS = MappingProxyType(
         "Szkoła": "school",
     }
 )
+# Rows the information page lists for the login's own user after the
+# student's rows (observed); never read, named by failure diagnostics.
+PROFILE_OWNER_LABELS = ("Imię i nazwisko użytkownika", "Login", "Hasło")
+# The page header shows the lucky number as `span.luckyNumber > b` (observed
+# 2026-10-29). "?" there is reported where no number is drawn, for a school
+# without lucky numbers and possibly on days without a draw; neither it nor
+# an empty marker has been observed.
+PROFILE_LUCKY_NUMBER_CLASS = "luckyNumber"
+# For a session it no longer knows, Synergia answers every page read with 200
+# and a page whose only heading is "Brak dostępu" (`h2.inside`), without the
+# signed-in menu, not with a login redirect (observed 2026-10-29). A signed-in
+# user's timetable page has no menu either, so the heading is required too.
+LOGGED_IN_PAGE_MARKER = "graphic-menu"
+LOGGED_OUT_HEADING = "Brak dostępu"
+PROFILE_LUCKY_NUMBER_DISABLED = "?"
 
 # HTML summary headers omit the two leading body cells: expander and subject.
 # These labels/layout rules are source-informed requirements, not live evidence.
@@ -847,9 +863,11 @@ FORMATIVE_TEMPLATE_ID = "000000"
 FORMATIVE_MAX_TEXT_LENGTH = 65536
 ATTENDANCE_DETAIL_MAX_FIELDS = 32
 ATTENDANCE_METADATA_CACHE_SIZE = 256
-ATTENDANCE_RESULT_CACHE_SIZE = 64
 ATTENDANCE_METADATA_TTL_SECONDS = 3600
 
+# Entries of every cached read of one account, oldest first out.
+ACCOUNT_RESULT_CACHE_SIZE = 64
+
 ANNOUNCEMENT_MAX_ITEMS = 256
 ANNOUNCEMENT_MAX_FIELD_LENGTH = 1024
 ANNOUNCEMENT_MAX_CONTENT_LENGTH = 65536

librus_python_api/diagnostics.py

@@ -30,6 +30,16 @@ _ELEMENT_LOCALS = 4
 _DEPTH = 6
 _NODES = 120
 _ELEMENT_BYTES = 8 * 1024
+_PAGE_TABLES = 12
+_PAGE_ROWS = 40
+_PAGE_CELLS = 8
+_PAGE_NOTICES = 4
+# Input types a login, search or settings form uses; others are shown as "?".
+_INPUT_TYPES = frozenset(
+    {"button", "checkbox", "hidden", "password", "radio", "submit", "text"}
+)
+# Element IDs whose presence tells a Synergia page from a login or error page.
+_PAGE_MARKERS = ("graphic-menu", "user-section")
 _REPORT_BYTES = 32 * 1024
 # Markup observed on Synergia pages. Other class tokens, tags and attribute
 # names are shown only as lengths, since they could carry data.
@@ -45,6 +55,7 @@ _CLASSES = frozenset(
         "decorated",
         "detail-grades",
         "double",
+        "form",
         "gradesCell",
         "grade-box",
         "grade-box-mapping",
@@ -53,6 +64,7 @@ _CLASSES = frozenset(
         "legend",
         "line0",
         "line1",
+        "luckyNumber",
         "micro",
         "newSchemaGradesByStudentTable",
         "no-border-left",
@@ -65,6 +77,7 @@ _CLASSES = frozenset(
         "stretch",
         "studentRow",
         "tooltip",
+        "warning-content",
     }
 )
 _TAGS = frozenset(
@@ -164,6 +177,7 @@ def logging_sink(event: DiagnosticEvent) -> None:
             "budget_requests_dispatched": event.budget_requests_dispatched,
             "budget_response_bytes": event.budget_response_bytes,
             "frames": event.frames,
+            "http_status": event.http_status,
         },
     )
 
@@ -242,6 +256,9 @@ def _redaction_vocabulary() -> tuple[
         *config.GRADE_AVERAGE_HEADERS,
     }
     texts |= {label.casefold() for label in config.FORMATIVE_HEADERS}
+    profile = (*config.PROFILE_LABELS, *config.PROFILE_OWNER_LABELS)
+    texts |= set(profile) | {f"{label}:" for label in profile}
+    texts |= set(config.PAGE_NOTICES) | {config.LOGGED_OUT_HEADING}
     prefixes = tuple(
         sorted(
             (
@@ -398,13 +415,91 @@ def _path(element: html.HtmlElement, redactor: _Redactor) -> str:
     return " > ".join(reversed(steps))
 
 
+def _cell(cell: html.HtmlElement, redactor: _Redactor) -> str:
+    spans = "".join(
+        f" {redactor.attribute(name, str(cell.get(name)))}"
+        for name in ("colspan", "rowspan")
+        if cell.get(name, "1") != "1"
+    )
+    text = redactor.text(cell.text_content()) or "EMPTY"
+    return f"{_tag(str(cell.tag))}{spans}[{text}]"
+
+
+def _shown(label: str, texts: list[str]) -> str:
+    return " ".join([f"  {label}: {len(texts)}", *texts[:_PAGE_NOTICES]])
+
+
+def _page_summary(document: html.HtmlElement, redactor: _Redactor) -> list[str]:
+    """A whole page as its markers, forms, notices and tables, row by row.
+
+    A page that fails as a whole (no expected table, an unknown notice, a
+    login or error page) is told apart by these, not by its first elements.
+    Only the first tables, rows and cells are shown.
+    """
+    body = document.find("body")
+    text = " ".join((body if body is not None else document).text_content().split())
+    present = {
+        marker: document.get_element_by_id(marker, None) is not None
+        for marker in _PAGE_MARKERS
+    }
+    markers = " ".join(
+        f"{marker}={'yes' if found else 'no'}" for marker, found in present.items()
+    )
+    lines = [f"  body text len={len(text)} {markers}"]
+    title = document.find(".//title")
+    titles = [] if title is None else [redactor.text(title.text_content()) or "EMPTY"]
+    lines.append(_shown("title", titles))
+    headings = [
+        redactor.text(heading.text_content()) or "EMPTY"
+        for heading in document.iter("h1", "h2", "h3")
+    ]
+    lines.append(_shown("headings", headings))
+    notices = document.xpath(
+        '//div[contains(concat(" ",normalize-space(@class)," ")," warning-content ")]'
+    )
+    shown = [redactor.text(notice.text_content()) or "EMPTY" for notice in notices]
+    lines.append(_shown("notices", shown))
+    forms = [redactor.href(form.get("action", "")) for form in document.iter("form")]
+    inputs: dict[str, int] = {}
+    for field in document.iter("input"):
+        kind = field.get("type", "text").casefold()
+        kind = kind if kind in _INPUT_TYPES else "?"
+        inputs[kind] = inputs.get(kind, 0) + 1
+    counted = " ".join(f"{kind}={count}" for kind, count in sorted(inputs.items()))
+    lines.append(_shown("forms", forms) + (f"; inputs {counted}" if counted else ""))
+    tables = list(document.iter("table"))
+    lines.append(f"  tables: {len(tables)}")
+    for table in tables[:_PAGE_TABLES]:
+        rows = [
+            row
+            for row in table.iter("tr")
+            if next(row.iterancestors("table"), None) is table
+        ]
+        lines.append(f"  {_path(table, redactor)}: {len(rows)} rows")
+        for row in rows[:_PAGE_ROWS]:
+            cells = [cell for cell in row if cell.tag in ("td", "th")]
+            more = " ..." if len(cells) > _PAGE_CELLS else ""
+            rendered = " ".join(_cell(cell, redactor) for cell in cells[:_PAGE_CELLS])
+            lines.append(f"    {rendered}{more}")
+        if len(rows) > _PAGE_ROWS:
+            lines.append("    ...")
+    if len(tables) > _PAGE_TABLES:
+        lines.append("  ...")
+    return lines
+
+
+def _is_page(element: html.HtmlElement) -> bool:
+    return element.getparent() is None and element.tag == "html"
+
+
 def describe_failure(error: BaseException) -> str | None:
     """The page structure around a failure, for a bug report.
 
     Shows the HTML elements held by the innermost library frame that holds
     any: tags, safe class tokens, known tooltip labels, known link families
-    and lengths. Text and attribute values are masked unless they equal a
-    parser constant. Returns None when there is nothing to show; never raises.
+    and lengths. A whole page is summarized last (see _page_summary). Text
+    and attribute values are masked unless they equal a parser constant.
+    Returns None when there is nothing to show; never raises.
     """
     try:
         redactor = _Redactor()
@@ -425,8 +520,15 @@ def describe_failure(error: BaseException) -> str | None:
             if not elements and not sequences:
                 continue
             lines = [f"at {_site(frame, line)}"]
-            for name, value in elements:
+            # The elements nearest the failure first; a page summary last.
+            for name, value in sorted(elements, key=lambda item: _is_page(item[1])):
                 redactor.nodes = 0
+                if _is_page(value):
+                    summary = "\n".join(_page_summary(value, redactor))
+                    if len(summary) > _ELEMENT_BYTES:
+                        summary = summary[:_ELEMENT_BYTES] + "...(truncated)"
+                    lines += [f"{name}: page", summary]
+                    continue
                 lines.append(f"{name}: {_path(value, redactor)}")
                 rendered = redactor.element(value)
                 if len(rendered) > _ELEMENT_BYTES:

librus_python_api/exceptions.py

@@ -7,6 +7,7 @@ __all__ = [
     "AccountActionRequiredError",
     "ClosedError",
     "CheckpointError",
+    "ConsentRequiredError",
     "ConnectionError",
     "CredentialsRejectedError",
     "ErrorKind",
@@ -31,6 +32,7 @@ __all__ = [
 class ErrorKind(StrEnum):
     CHECKPOINT = "checkpoint"
     INVALID_INPUT = "invalid_input"
+    CONSENT_REQUIRED = "consent_required"
     CREDENTIALS_REJECTED = "credentials_rejected"
     ACCOUNT_ACTION_REQUIRED = "account_action_required"
     SESSION_EXPIRED = "session_expired"
@@ -78,6 +80,13 @@ class InvalidInputError(LibrusError):
     pass
 
 
+class ConsentRequiredError(InvalidInputError):
+    """A call with an effect the user must agree to was made without consent.
+
+    A subclass of InvalidInputError, which these calls raised before 1.8.1.
+    """
+
+
 class CredentialsRejectedError(LibrusError):
     pass
 
@@ -89,6 +98,9 @@ class AccountActionRequiredError(LibrusError):
 class SessionExpiredError(LibrusError):
     # Library-private provenance only; never attach a URL, body or credentials.
     _messages_origin = False
+    # Inferred from a page without the logged-in menu, not from a 401 or a
+    # login redirect; a fresh session getting the same page is a layout.
+    _logged_out_page = False
 
 
 class AccessDeniedError(LibrusError):
@@ -124,7 +136,9 @@ class OperationTimeoutError(LibrusError):
 
 
 class LimitError(LibrusError):
-    pass
+    # Library-private: the bound was the cookie count and the jar was emptied,
+    # so the session behind it is gone.
+    _cookies_cleared = False
 
 
 class ParseError(LibrusError):
@@ -154,6 +168,7 @@ class StorageError(LibrusError):
 _ERROR_TYPES: dict[ErrorKind, type[LibrusError]] = {
     ErrorKind.CHECKPOINT: CheckpointError,
     ErrorKind.INVALID_INPUT: InvalidInputError,
+    ErrorKind.CONSENT_REQUIRED: ConsentRequiredError,
     ErrorKind.CREDENTIALS_REJECTED: CredentialsRejectedError,
     ErrorKind.ACCOUNT_ACTION_REQUIRED: AccountActionRequiredError,
     ErrorKind.SESSION_EXPIRED: SessionExpiredError,

librus_python_api/gateway_grades.py

@@ -3,8 +3,9 @@
 The grades page of a school on the new descriptive grading schema renders a
 subject table whose semester cells are empty; the page script then loads the
 grades from gateway JSON routes. Routes and field names come from public client
-code and the official page script, not from an observed populated response,
-so every unexpected shape fails instead of producing a partial collection.
+code and the official page script. One authorized read on 2026-10-28 parsed four
+PartialGrades records on one school; pagination keys are still unknown, so every
+unexpected shape fails instead of producing a partial collection.
 """
 
 import re

librus_python_api/inspect_page.py

@@ -1,6 +1,7 @@
 """Run one parser on a saved Synergia page and report the outcome offline.
 
     python -m librus_python_api.inspect_page grades page.html
+    python -m librus_python_api.inspect_page profile informacja.html
 
 The report holds counts, code locations and page structure built from
 allowlists (see diagnostics.describe_failure), never page text or values.
@@ -20,6 +21,8 @@ from librus_python_api.diagnostics import describe_failure, failure_frames
 from librus_python_api.exceptions import LibrusError
 from librus_python_api.grade_parsers import parse_final_grades
 from librus_python_api.grade_records import parse_grade_records
+from librus_python_api.models import Availability
+from librus_python_api.parsers import parse_profile
 
 NOTICE = (
     "This report holds counts, code locations and page structure only, no page "
@@ -45,10 +48,19 @@ def _final_grades(body: bytes) -> dict[str, int]:
     return {"subjects": len(parse_final_grades(body))}
 
 
+def _profile(body: bytes) -> dict[str, int]:
+    lucky = parse_profile(body).lucky_number.availability
+    return {"lucky_number": int(lucky == Availability.AVAILABLE)}
+
+
 PARSERS: dict[str, Callable[[bytes], dict[str, int]]] = {
     "grades": _grades,
     "final-grades": _final_grades,
+    "profile": _profile,
 }
+# macOS TextEdit saves a viewed page source as a new document holding the
+# source as text, not the page itself.
+_TEXT_EXPORT = re.compile(rb'<meta name="Generator" content="Cocoa HTML Writer"', re.I)
 
 
 def inspect(parser: str, body: bytes) -> tuple[bool, list[str]]:
@@ -60,6 +72,12 @@ def inspect(parser: str, body: bytes) -> tuple[bool, list[str]]:
         # Synergia serves UTF-8; another encoding is a saving problem, not a layout.
         lines.append("FAILED input: the file is not UTF-8; save the page as UTF-8")
         return False, lines
+    if _TEXT_EXPORT.search(body[:4096]):
+        lines.append(
+            "FAILED input: the file is page source saved as a text document; "
+            "save the page itself (Safari: File > Save As, format Page Source)"
+        )
+        return False, lines
     if not re.search(rb"<html[\s>]", body[:4096], re.I):
         # A copied table (outerHTML) is a fragment; parsers expect a page.
         body = b"<!doctype html><html><body>" + body + b"</body></html>"

librus_python_api/models.py

@@ -90,6 +90,8 @@ class DiagnosticEvent:
     budget_response_bytes: int
     # Code locations of a failure (see diagnostics.failure_frames), else empty.
     frames: tuple[str, ...] = ()
+    # HTTP status of the operation's last checked read response, if any.
+    http_status: int | None = None
 
 
 @dataclass(frozen=True, slots=True)

librus_python_api/parsers.py

@@ -8,7 +8,14 @@ from typing import Any
 from lxml import etree, html
 from pydantic import ValidationError
 
-from librus_python_api.config import PAGE_NOTICES, PROFILE_LABELS
+from librus_python_api.config import (
+    LOGGED_IN_PAGE_MARKER,
+    LOGGED_OUT_HEADING,
+    PAGE_NOTICES,
+    PROFILE_LABELS,
+    PROFILE_LUCKY_NUMBER_CLASS,
+    PROFILE_LUCKY_NUMBER_DISABLED,
+)
 from librus_python_api.exceptions import ErrorKind, LibrusError
 from librus_python_api.models import (
     Availability,
@@ -178,6 +185,23 @@ def parse_page(body: bytes, *, repeatable_id: str | None = None) -> html.HtmlEle
     return document
 
 
+def is_logged_out_page(body: bytes) -> bool:
+    """Synergia's page for a session it no longer knows; never raises."""
+    if LOGGED_OUT_HEADING.encode() not in body:
+        return False
+    try:
+        parser = html.HTMLParser(no_network=True, recover=True, huge_tree=False)
+        document = html.document_fromstring(body.decode("utf-8"), parser=parser)
+    except (UnicodeError, etree.LxmlError, ValueError):
+        return False
+    if document.get_element_by_id(LOGGED_IN_PAGE_MARKER, None) is not None:
+        return False
+    headings = [
+        " ".join(h.text_content().split()) for h in document.iter("h1", "h2", "h3")
+    ]
+    return headings == [LOGGED_OUT_HEADING]
+
+
 def parse_profile(body: bytes) -> ProfileFields:
     document = parse_page(body)
     required = {"name", "class_name", "register_number", "tutor", "school"}
@@ -210,15 +234,21 @@ def parse_profile(body: bytes) -> ProfileFields:
         raise LibrusError(ErrorKind.PARSE)
     if not re.fullmatch(r"[0-9]{1,4}", candidates[0]["register_number"]):
         raise LibrusError(ErrorKind.PARSE)
-    markers = document.xpath('//*[@id="luckyNumber"]')
+    markers = document.xpath(
+        '//span[contains(concat(" ",normalize-space(@class)," "),$token)]',
+        token=f" {PROFILE_LUCKY_NUMBER_CLASS} ",
+    )
     if not markers:
         lucky = LuckyNumber(Availability.UNAVAILABLE)
     elif len(markers) == 1:
         value = " ".join(markers[0].text_content().split())
-        if not re.fullmatch(r"[0-9]{1,4}", value):
+        if value in ("", PROFILE_LUCKY_NUMBER_DISABLED):
+            lucky = LuckyNumber(Availability.UNAVAILABLE)
+        elif re.fullmatch(r"[0-9]{1,4}", value):
+            # No evidenced civil date in this marker. Never fabricate today's date.
+            lucky = LuckyNumber(Availability.AVAILABLE, int(value))
+        else:
             raise LibrusError(ErrorKind.PARSE)
-        # No evidenced civil date in this marker. Never fabricate today's date.
-        lucky = LuckyNumber(Availability.AVAILABLE, int(value))
     else:
         raise LibrusError(ErrorKind.PARSE)
     fields = candidates[0]

librus_python_api/service.py

@@ -1,6 +1,7 @@
 """Public login-scoped account service under one shared traffic boundary."""
 
 import asyncio
+import contextvars
 import hashlib
 import hmac
 import json
@@ -33,11 +34,11 @@ from librus_python_api.completed_lessons import (
     validate_selection,
 )
 from librus_python_api.config import (
+    ACCOUNT_RESULT_CACHE_SIZE,
     ATTACHMENT_MAX_BYTES,
     ATTENDANCE_MAX_WINDOW_DAYS,
     ATTENDANCE_METADATA_CACHE_SIZE,
     ATTENDANCE_METADATA_TTL_SECONDS,
-    ATTENDANCE_RESULT_CACHE_SIZE,
     CHECKPOINT_TIMEOUT_SECONDS,
     ENDPOINTS,
     GRADE_MAX_RECORDS,
@@ -52,6 +53,7 @@ from librus_python_api.config import (
     ConnectionSettings,
     OperationLimits,
     SchedulerLimits,
+    SideEffect,
     TransportLimits,
     agenda_form,
     attendance_view_form,
@@ -69,7 +71,13 @@ from librus_python_api.config import (
 )
 from librus_python_api.detail_fields import normalize_detail_fields
 from librus_python_api.diagnostics import DiagnosticSink, failure_frames
-from librus_python_api.exceptions import ErrorKind, LibrusError, SessionExpiredError
+from librus_python_api.exceptions import (
+    ErrorKind,
+    LibrusError,
+    LimitError,
+    ParseError,
+    SessionExpiredError,
+)
 from librus_python_api.gateway_grades import (
     DescriptiveTable,
     descriptive_grades,
@@ -198,7 +206,12 @@ from librus_python_api.notifications import (
     parse_schedule_events,
     validate_response,
 )
-from librus_python_api.parsers import parse_identity, parse_login, parse_profile
+from librus_python_api.parsers import (
+    is_logged_out_page,
+    parse_identity,
+    parse_login,
+    parse_profile,
+)
 from librus_python_api.parsing import ParserPool
 from librus_python_api.recipients import (
     parse_recipient_group_choices,
@@ -381,6 +394,24 @@ def _require_dates(*days: date | None, max_days: int | None = None) -> None:
             raise LibrusError(ErrorKind.INVALID_INPUT)
 
 
+def _cooldown_due(error: LibrusError) -> bool:
+    """A denial, an unrecovered expiry, or a logged-out page that a session
+    just signed in also got: signing in again at once cannot help."""
+    if error.kind in (ErrorKind.ACCESS_DENIED, ErrorKind.SESSION_EXPIRED):
+        return True
+    cause = error.__cause__
+    return (
+        error.kind is ErrorKind.PARSE
+        and isinstance(cause, SessionExpiredError)
+        and cause._logged_out_page
+    )
+
+
+# The running operation's last checked read status, for its diagnostic event.
+# A holder per operation, so concurrent operations do not share one.
+_READ_STATUS: contextvars.ContextVar[list[int | None] | None] = contextvars.ContextVar(
+    "librus_read_status", default=None
+)
 _METADATA_MAP_FALLBACK = frozenset(
     {ErrorKind.ACCESS_DENIED, ErrorKind.CONNECTION, ErrorKind.LIMIT, ErrorKind.PARSE}
 )
@@ -894,10 +925,10 @@ class AccountClient:
         max_age_seconds: float = 0.0,
     ) -> ModernMessageContent:
         validate_modern_message_reference(reference, self._alias)
-        if type(allow_mark_read) is not bool or (
-            reference.folder is MessageFolder.RECEIVED and not allow_mark_read
-        ):
+        if type(allow_mark_read) is not bool:
             raise LibrusError(ErrorKind.INVALID_INPUT)
+        if reference.folder is MessageFolder.RECEIVED and not allow_mark_read:
+            raise LibrusError(ErrorKind.CONSENT_REQUIRED)
         if reference.archived:
             # No archived content route or mark-read effect is established yet.
             raise LibrusError(ErrorKind.UNSUPPORTED_CAPABILITY)
@@ -1178,6 +1209,8 @@ class AccountClient:
         started = time.monotonic()
         outcome: ErrorKind | Literal["ok", "cancelled"] = "ok"
         frames: tuple[str, ...] = ()
+        status: list[int | None] = [None]
+        status_token = _READ_STATUS.set(status)
         try:
             if deadline is None:
                 deadline = asyncio.timeout(None)
@@ -1195,10 +1228,7 @@ class AccountClient:
             outcome = error.kind
             if self._service._diagnostic_sink is not None:
                 frames = failure_frames(error)
-            if authenticate and error.kind in (
-                ErrorKind.ACCESS_DENIED,
-                ErrorKind.SESSION_EXPIRED,
-            ):
+            if authenticate and _cooldown_due(error):
                 self._cooldowns[operation] = (
                     time.monotonic() + self._service._transport_limits.cooldown_seconds,
                     error.kind,
@@ -1215,6 +1245,7 @@ class AccountClient:
             # produce a misleading success diagnostic at this owner boundary.
             outcome = ErrorKind.CONNECTION
         finally:
+            _READ_STATUS.reset(status_token)
             self._emit(
                 DiagnosticEvent(
                     operation,
@@ -1223,6 +1254,7 @@ class AccountClient:
                     budget.requests_dispatched,
                     budget.response_bytes,
                     frames,
+                    status[0],
                 )
             )
 
@@ -1277,7 +1309,7 @@ class AccountClient:
         budget: RequestBudget | None = None,
         max_age_seconds: float = 0.0,
     ) -> Grades:
-        """Select a grade view with one non-replayed view-changing POST.
+        """Select a grade view with one view-changing POST.
 
         Changes the selected grade filter, not school records. A cache hit makes
         no POST. Missing inline weight/count data remains unknown. In the all
@@ -1370,7 +1402,7 @@ class AccountClient:
         budget: RequestBudget | None = None,
         max_age_seconds: float = 0.0,
     ) -> Attendance:
-        """Read a fixed upstream attendance view without replaying its POST."""
+        """Read a fixed upstream attendance view with one view-changing POST."""
         form = attendance_view_form(view)
 
         async def fetch(budget: RequestBudget, _: bool) -> Attendance:
@@ -1509,7 +1541,7 @@ class AccountClient:
         budget: RequestBudget | None = None,
         max_age_seconds: float = 0.0,
     ) -> Timetable:
-        """Select an explicit school civil week; never replay its selection POST."""
+        """Select an explicit school civil week with one view-changing POST."""
         form = timetable_form(monday)
 
         async def fetch(budget: RequestBudget, _: bool) -> Timetable:
@@ -1761,10 +1793,10 @@ class AccountClient:
     ) -> MessageContent:
         """Open one message; received opens require explicit read-effect consent."""
         validate_reference(reference, self._alias)
-        if type(allow_mark_read) is not bool or (
-            reference.folder is MessageFolder.RECEIVED and not allow_mark_read
-        ):
+        if type(allow_mark_read) is not bool:
             raise LibrusError(ErrorKind.INVALID_INPUT)
+        if reference.folder is MessageFolder.RECEIVED and not allow_mark_read:
+            raise LibrusError(ErrorKind.CONSENT_REQUIRED)
         operation: Literal["message_content_received", "message_content_sent"] = (
             "message_content_received"
             if reference.folder is MessageFolder.RECEIVED
@@ -2044,6 +2076,8 @@ class AccountClient:
         started = time.monotonic()
         outcome: ErrorKind | Literal["ok", "cancelled"] = "ok"
         frames: tuple[str, ...] = ()
+        status: list[int | None] = [None]
+        status_token = _READ_STATUS.set(status)
         try:
             async with asyncio.timeout(budget.remaining_seconds()):
                 async with self._lock:
@@ -2062,6 +2096,7 @@ class AccountClient:
             outcome = ErrorKind.TIMEOUT
             raise LibrusError(ErrorKind.TIMEOUT) from None
         finally:
+            _READ_STATUS.reset(status_token)
             self._emit(
                 DiagnosticEvent(
                     operation,
@@ -2070,6 +2105,7 @@ class AccountClient:
                     budget.requests_dispatched,
                     budget.response_bytes,
                     frames,
+                    status[0],
                 )
             )
 
@@ -2101,25 +2137,29 @@ class AccountClient:
         try:
             result = await self._authenticated(fetch, budget, retry_safe)
         except LibrusError as error:
-            if error.kind in (ErrorKind.ACCESS_DENIED, ErrorKind.SESSION_EXPIRED):
+            if _cooldown_due(error):
                 self._cooldowns[operation] = (
                     time.monotonic() + self._service._transport_limits.cooldown_seconds,
                     error.kind,
                 )
             raise
         self._cache[key] = (time.monotonic(), result)
-        if len(self._cache) > ATTENDANCE_RESULT_CACHE_SIZE:
+        if len(self._cache) > ACCOUNT_RESULT_CACHE_SIZE:
             del self._cache[next(iter(self._cache))]
         return result
 
     async def _authenticated[T](
         self, fetch: Fetch[T], budget: RequestBudget, retry_safe: bool
     ) -> T:
-        """Run a read in a session; recover proven expiry once for safe reads.
+        """Run a read in a session; recover expiry once where a repeat is safe.
 
         Initial login is never retried: a failed credential submission must not
-        be replayed. A view-changing POST is never replayed either; expiry only
-        clears the session so a later explicit call can log in again.
+        be replayed. A retry-safe read is repeated once after a new login, and
+        so is a read without an account effect (`NONE` or `SELECT_VIEW`, never
+        mark-read) answered with a logged-out page, which proves the request
+        was not applied. Other expiry only clears the session so a later
+        explicit call can log in again. A session just signed in that gets the
+        logged-out page fails as PARSE.
         """
         fresh_login = self._identity is None
         if fresh_login:
@@ -2127,18 +2167,22 @@ class AccountClient:
         try:
             return await fetch(budget, fresh_login)
         except SessionExpiredError as error:
+            if error._logged_out_page and fresh_login:
+                raise LibrusError(ErrorKind.PARSE) from error
             modern_expired = error._messages_origin
             if modern_expired:
                 self._invalidate_modern()
             else:
                 self._invalidate()
-            if not retry_safe:
+            if not retry_safe and not error._logged_out_page:
                 raise
         if not modern_expired:
             await self._authenticate(budget)
         try:
             return await fetch(budget, not modern_expired)
         except SessionExpiredError as error:
+            if error._logged_out_page:
+                raise LibrusError(ErrorKind.PARSE) from error
             if error._messages_origin:
                 self._invalidate_modern()
             else:
@@ -2167,12 +2211,29 @@ class AccountClient:
                     endpoint, budget, form=form, reference_id=reference, query=query
                 )
             self._validate_read_response(response, content_type)
-            return await self._service._parsers.run(parse, response.body, budget)
+            try:
+                return await self._service._parsers.run(parse, response.body, budget)
+            except ParseError as error:
+                if (
+                    content_type != HTML
+                    or ENDPOINTS[endpoint].origin != "synergia"
+                    or not await self._service._parsers.run(
+                        is_logged_out_page, response.body, budget
+                    )
+                ):
+                    raise
+                # Synergia's answer to a session it no longer knows. A read
+                # with an account effect (mark-read) is not repeated: it fails
+                # as an unrecovered expiry and the next call signs in.
+                expired = SessionExpiredError(ErrorKind.SESSION_EXPIRED)
+                expired._logged_out_page = ENDPOINTS[endpoint].side_effect in (
+                    SideEffect.NONE,
+                    SideEffect.SELECT_VIEW,
+                )
+                raise expired from error
         except BaseException as error:
             if ENDPOINTS[endpoint].origin == "messages":
-                self._invalidate_modern()
-                if isinstance(error, SessionExpiredError):
-                    error._messages_origin = True
+                self._modern_read_failed(error)
             raise
 
     def _check_cooldown(self, key: str) -> None:
@@ -2188,6 +2249,22 @@ class AccountClient:
         self._metadata_maps.clear()
         self._transport.clear_auth()
 
+    def _modern_read_failed(self, error: BaseException) -> None:
+        """Drop the modern session unless the failure says nothing about it.
+
+        A cancel or a local bound keeps it. Every other failure drops it, an
+        unrecognized body included: a session the upstream no longer knows may
+        be answered with one, and keeping it would fail every later read, while
+        dropping it costs one launch.
+        """
+        if isinstance(error, asyncio.CancelledError) or (
+            isinstance(error, LimitError) and not error._cookies_cleared
+        ):
+            return
+        self._invalidate_modern()
+        if isinstance(error, SessionExpiredError):
+            error._messages_origin = True
+
     def _invalidate_modern(self) -> None:
         self._modern_account = None
         for key in tuple(self._cache):
@@ -2548,6 +2625,9 @@ class AccountClient:
     def _validate_read_response(
         self, response: TransportResponse, content_type: str
     ) -> None:
+        holder = _READ_STATUS.get()
+        if holder is not None:
+            holder[0] = response.status
         if 300 <= response.status < 400:
             if self._is_module_unavailable_redirect(response):
                 raise LibrusError(ErrorKind.MODULE_UNAVAILABLE)

librus_python_api/transport.py

@@ -50,7 +50,12 @@ from librus_python_api.config import (
     recipient_form,
     validate_modern_query,
 )
-from librus_python_api.exceptions import ErrorKind, LibrusError, SessionExpiredError
+from librus_python_api.exceptions import (
+    ErrorKind,
+    LibrusError,
+    LimitError,
+    SessionExpiredError,
+)
 from librus_python_api.models import (
     AttachmentHeaders,
     LoginSubmission,
@@ -451,9 +456,7 @@ class AiohttpTransport:
                 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)
+                self._check_cookies(session)
                 if not modern or response.status not in (400, 422):
                     self._check_status(response)
                 body = await self._read_body(response, budget)
@@ -542,9 +545,7 @@ class AiohttpTransport:
             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)
+            self._check_cookies(session)
             self._check_status(response)
             body = await self._read_payload(response, budget)
             if response.status == 200:
@@ -843,9 +844,7 @@ class AiohttpTransport:
             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)
+            self._check_cookies(session)
             self._check_status(response)
             body = await self._read_body(response, budget)
             return TransportResponse(
@@ -863,6 +862,13 @@ class AiohttpTransport:
         ):
             raise LibrusError(ErrorKind.LIMIT)
 
+    def _check_cookies(self, session: aiohttp.ClientSession) -> None:
+        if len(session.cookie_jar) > self._limits.max_cookies:
+            session.cookie_jar.clear()
+            error = LimitError(ErrorKind.LIMIT)
+            error._cookies_cleared = True
+            raise error
+
     def _check_status(self, response: aiohttp.ClientResponse) -> None:
         if response.status in (429, 503):
             pause = self._limits.cooldown_seconds

{librus_python_api-1.8.0.dist-info → librus_python_api-1.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: librus-python-api
-Version: 1.8.0
+Version: 1.8.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,9 +42,13 @@ 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.8.0` reports where a failure happened (code locations and a
-redacted page structure, see [failure diagnostics](API.md#failure-diagnostics-180)),
-reads gateway descriptive grades for schools on the new descriptive schema
+**Status:** `1.8.2` keeps the modern mailbox session across a cancelled read
+or a reached limit and sends its own version in the `User-Agent`. `1.8.1` recovers a session Synergia no longer knows (it answers
+with a "Brak dostępu" page, not a login redirect), reads the lucky number
+from the page header and summarizes a page that fails as a whole in
+diagnostics. `1.8.0` reports where a failure
+happened (code locations and a redacted page structure, see
+[failure diagnostics](API.md#failure-diagnostics-180)), reads gateway descriptive grades for schools on the new descriptive schema
 (source-informed, first populated read live on one school) and keeps the 1.7.1 point
 grades and multi-line grade comments. It keeps the 1.6.4 linear-time message body
 rendering and the 1.6.2 completed-lesson and grade layouts, including behaviour
@@ -60,7 +64,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.8.0
+python -m pip install librus-python-api==1.8.2
 ```
 
 Pin the exact version qualified by your application. Before publication, use a
@@ -76,7 +80,7 @@ python -m pip install .
 To install a locally built wheel instead:
 
 ```sh
-python -m pip install ./dist/librus_python_api-1.8.0-py3-none-any.whl
+python -m pip install ./dist/librus_python_api-1.8.2-py3-none-any.whl
 ```
 
 No console script or background process is installed: import the library in your
@@ -280,7 +284,10 @@ except LibrusError as error:
 
 To check a saved page offline (a page source saved with Ctrl+U, or a copied
 table), run `python -m librus_python_api.inspect_page grades page.html` (or
-`final-grades`). It prints counts, or the failure's code locations and masked
+`final-grades`, or `profile` for the information page `/informacja`). Save the
+page source itself: in Safari use File > Save As with format Page Source; in
+Chrome on macOS open it with Option+Cmd+U, then Cmd+S. A source view copied
+into TextEdit is a text document, which `inspect_page` rejects. It prints counts, or the failure's code locations and masked
 structure, and makes no request. Pass a `diagnostic_sink` to `LibrusService`
 to receive one `DiagnosticEvent` per operation, with `frames` on failure.
 None of these print page text, values, logins or exception messages.

{librus_python_api-1.8.0.dist-info → librus_python_api-1.8.2.dist-info}/RECORD

@@ -1,33 +1,33 @@
-librus_python_api/__init__.py,sha256=DmUSk3fOr0x7n27EcLzjJy-CQhMvjr1J_DPKkFCZ1CA,6513
+librus_python_api/__init__.py,sha256=CDi6pTko967g3RViVcZCIWhE-Lzof5VN6E4NkQJ4aUU,6571
 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
 librus_python_api/_windows_filesystem.py,sha256=pQANIGkYrb4Q75gz5mdr5mqYhM_PFblWwTxPGM0bQ78,14063
 librus_python_api/announcements.py,sha256=13FoOR1sq7tt9w6aLf0vclcFKDqLUiIYaO5iYD2QVLA,5928
 librus_python_api/attachment_routes.py,sha256=uSg5wCQqHJiphF0KdI0GatQxZr5SLUx6xWQRsl_U4_U,4123
-librus_python_api/attachments.py,sha256=kyIBpFxeK34Al5_jCkxYKpZnsSLa5DYaGS6vHADpy_g,10921
+librus_python_api/attachments.py,sha256=Iq-ERZWc3gYXu6Lcv6womT2EXCc-c1Q7r_Q6VyaCm2E,10818
 librus_python_api/attendance.py,sha256=HeFAfnIUn4N__yp1zr635Dve55S2jmwtkeIy_6mV5B4,6924
 librus_python_api/attendance_frequency.py,sha256=SBhED5zuyRIHWdw4urFyTJYykb6EYB7eL4dU3mif1EY,5309
 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=ngGfBD6K4B6dR4elPYvNRvp40Q-GlrhUsUKqBbYY1KE,10727
-librus_python_api/config.py,sha256=wGWZXg7CeISl9v_z8X759Yq3f4q7ril1kELazEhVt80,60184
+librus_python_api/config.py,sha256=CBMwuuACfrB7TzTVkTP8QAuPz5hv43YOsbto81-uEJc,61248
 librus_python_api/detail_fields.py,sha256=vDDi5sV-e30-42SF0hwAUoldiZ5wvYtb1UlLt03lBHw,1708
-librus_python_api/diagnostics.py,sha256=_mWLbOj0HQrVSgTR_TrGybzN7OOYHLsdfLFI-matmww,14595
-librus_python_api/exceptions.py,sha256=adVcJuzfB8wGrUlF2SfiyIlE9ZZyTAvGdWRtQIjsA3I,4879
+librus_python_api/diagnostics.py,sha256=5YbJB8J8RXMqMTmulcn5mJRF1vpi0Pvx00ETrXn9hUY,19036
+librus_python_api/exceptions.py,sha256=x8_z5UTNmuRINTK4buLYiKdYcFA2w6GZP9ZXOL-OnRU,5531
 librus_python_api/files.py,sha256=pQBsIJyfTOZDz83ZB-5fcd-nPMcxR1HJ155h4zTHmsA,9223
 librus_python_api/formative_grades.py,sha256=VykwtGvViZVOJMwPH3Re1RTDCHMr1_m9_xHjZyaXDIQ,6452
-librus_python_api/gateway_grades.py,sha256=HHXJqtC47v2BTP3ufak9i9Q68phOxwtzWjahKdxkyX4,16086
+librus_python_api/gateway_grades.py,sha256=T-G5KN0kpROi6xSGwAUba2qWDGNhg8TeGmQN140iLxc,16163
 librus_python_api/grade_parsers.py,sha256=ROfffkCP8yj5Q708TZdpp0PDTyVmoh6X7m0y2fyJcwg,11202
 librus_python_api/grade_records.py,sha256=YltZ_OQLsfxj0nvK8_xTuv8ifMOu2jJBnVn6TTQKzaY,22722
 librus_python_api/homework_range.py,sha256=erYfvS6PhHU5XhnR6LkiLNy677hGVflY3UAuHOs-YUw,1663
-librus_python_api/inspect_page.py,sha256=W7F0dt8qPbJnG6gMnA5kiVEFKXc6MbA7RLookR2IJ5Q,4457
+librus_python_api/inspect_page.py,sha256=AUm-n2Ewe4cQUnlFnhttcGK5B9shvFde_7t1JF7mEm0,5285
 librus_python_api/lifecycle.py,sha256=XzA5CEdZFo7iL5IMUrawnRvf2m9BFe0OseP-fpQFaAE,856
 librus_python_api/markup.py,sha256=p97ZRPqhGYTEBbzJq_0j4j8AKihgQzJqTv__QUNm8Ws,6084
 librus_python_api/message_content.py,sha256=v_qoEAoaYS0_9MQBaj57i5XnC7pzv_HHWefgTt4CNyM,9043
 librus_python_api/messages.py,sha256=K9F8XVs1SojfFpdxxLV8gx9E0g81YxEHjigDzLHmDCg,10230
-librus_python_api/models.py,sha256=g6N5WBNU8ieZbxydihpbicwU3_Y8SuQZY_IXOZH7I9s,41843
+librus_python_api/models.py,sha256=IO-SYpqpQeuTej6kqNjBRXDbAbKITRZ1njRUyoEZ8t0,41951
 librus_python_api/modern_body.py,sha256=SocXJTyGm1Q_2owzh1PE1zcCB2kqZTz1KPJ2R4yMyoc,3895
 librus_python_api/modern_mailbox.py,sha256=2jF9UnJZ5AF6dip-GrMcv_z2kSLpp87dIpVeXk9jMzA,20600
 librus_python_api/modern_messages.py,sha256=qt2CXtrxCZQ-jTt0aQCD6ZaPAJQZXf0BxmvacPo9B0w,10653
@@ -35,7 +35,7 @@ librus_python_api/notification_models.py,sha256=4eLTAE9JzHhveoaWtZQwGBolmb87QUP5
 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/parsers.py,sha256=8sdfPsOZYHNYVZ4rwX_de5Y5rPl0umoQPon3uflQFlY,9178
 librus_python_api/parsing.py,sha256=H71srw5yx-RFrAKZFgj-QFX-DIXZmhnGrDTmJhazCB8,1838
 librus_python_api/persistence.py,sha256=F35yBRu6D8aYgdwKTpzVdqVTyiUaLQludUmyyskb3Vo,15529
 librus_python_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -44,10 +44,10 @@ librus_python_api/scheduler.py,sha256=3JplYxqvQdFz3aKXcoQUJHE9s3FPw_xRhQ2CPNLuQm
 librus_python_api/school_reads.py,sha256=YHta7DmhjS5vSa4Djq8pzp01-2jhVfGOo1Mnc738rV4,15209
 librus_python_api/school_year_archive.py,sha256=D0A1ywMKgoYgvi-d70__SFreMGvMb_72870Akkbb_m8,15492
 librus_python_api/sending.py,sha256=Nvvk2r-6D6Us53a2fH5GW9PcA6bWEfuOvy6c3M5QVcE,4549
-librus_python_api/service.py,sha256=7s5NAtuKHIPL4u-ctu9RNEbd8ctGgvPzSXQ5XEOCeCg,99697
+librus_python_api/service.py,sha256=34o-EQSuERhSHZAme-RDhVznhd_y1-GT0SPfduJ5LoM,102964
 librus_python_api/timetable.py,sha256=tX1QK9fQABxzfLaHHqTe8e6rAgdOkCoTOfAHdPwNmLE,9836
-librus_python_api/transport.py,sha256=n3goXE34xcsO-bilsLVYEUW3JkJR-9rbgmqPu7ff9J8,35036
-librus_python_api-1.8.0.dist-info/METADATA,sha256=sOS6jBJ9c6o1-1lnKEqPwcs5ILCx090B6CuxP0i9qDY,13572
-librus_python_api-1.8.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-librus_python_api-1.8.0.dist-info/licenses/LICENSE,sha256=IuerLb3cnZCsaB23znydjjvKqP-LmSJd3syKa9NGUts,1071
-librus_python_api-1.8.0.dist-info/RECORD,,
+librus_python_api/transport.py,sha256=yF-DnFy4xGYS_RWQ9161b9WJXOlYF8cFRgdjXmVVUIk,34988
+librus_python_api-1.8.2.dist-info/METADATA,sha256=78cqj_uSkFU-4NhnUV0FCj3U8-QmJRK51bvIzIRVask,14202
+librus_python_api-1.8.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+librus_python_api-1.8.2.dist-info/licenses/LICENSE,sha256=IuerLb3cnZCsaB23znydjjvKqP-LmSJd3syKa9NGUts,1071
+librus_python_api-1.8.2.dist-info/RECORD,,