pyedookit 0.3.0__tar.gz → 0.3.2__tar.gz

{pyedookit-0.3.0 → pyedookit-0.3.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Tomas Liska
+Copyright (c) 2026 TFoxik
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

pyedookit-0.3.2/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: pyedookit
+Version: 0.3.2
+Summary: Async client for the Edookit parent portal (edookit.net)
+Project-URL: Homepage, https://github.com/TFoxik/pyedookit
+Author: TFoxik
+License: MIT
+License-File: LICENSE
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiohttp>=3.14.3
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: lxml>=6.1.0
+Requires-Dist: yarl>=1.24
+Description-Content-Type: text/markdown
+
+# pyedookit
+
+[![PyPI](https://img.shields.io/pypi/v/pyedookit)](https://pypi.org/project/pyedookit/)
+[![CI](https://github.com/TFoxik/pyedookit/actions/workflows/ci.yml/badge.svg)](https://github.com/TFoxik/pyedookit/actions/workflows/ci.yml)
+
+Unofficial async Python client for the [Edookit](https://edookit.com) parent
+portal (`https://<school>.edookit.net`) used by Czech schools. It powers the
+[ha-edookit](https://github.com/TFoxik/ha-edookit) Home Assistant integration
+and works standalone.
+
+Edookit's REST API only works if a school administrator enables it, so this
+library signs in like a parent does (Plus4U OIDC, no browser) and reads the
+portal's pages. Edookit doesn't support it, and a change to the portal's
+markup can break a parser until it's updated.
+
+## Install
+
+```bash
+pip install pyedookit
+```
+
+Requires Python 3.12+.
+
+## Usage
+
+```python
+import asyncio
+from pyedookit import EdookitClient, login
+
+async def main():
+    session = await login("zs-example", "parent@example.com", "hunter2")
+    client = EdookitClient(session)
+    for lesson in await client.get_timetable():
+        print(lesson.start, lesson.subject, lesson.room)
+
+asyncio.run(main())
+```
+
+| Call | Returns |
+|---|---|
+| `get_timetable()` | this week's `Lesson`s, times in `PORTAL_TZ` (Europe/Prague) |
+| `get_events()` | upcoming `SchoolEvent`s; all-day events have `date` start/end, end inclusive |
+| `get_payments()` | `Payments` totals and requests, amounts as `Decimal` |
+| `fetch_page(name)` | raw HTML of a page without a parser yet (`CAPTURE_PAGES`) |
+
+`content_fingerprint(html)` tells you when such a page's content changed.
+
+### Sessions
+
+The password is only used by `login()`. Store `session.to_json()` instead,
+and treat it like a password: it holds the Plus4U cookie, which signs in
+for about 19 days. Load it with `Session.from_json()`.
+
+The edookit session itself lasts 30-60 minutes. When it runs out, call
+`refresh(session)` to get a new one from the Plus4U cookie. When `refresh()`
+raises `AuthError`, the Plus4U cookie has expired too and you need `login()`
+again.
+
+| Exception | Meaning | What to do |
+|---|---|---|
+| `SessionExpired` | the edookit session ran out | `refresh()` and retry |
+| `AuthError` | bad credentials, or the Plus4U cookie expired | `login()` |
+| `EdookitConnectionError` | network error or 30 s timeout | retry later |
+| `ParseError` | the portal's markup changed | the parser needs updating |
+
+All of them derive from `EdookitError`. `login()`, `refresh()` and
+`EdookitClient` accept an `http: aiohttp.ClientSession` to reuse. Create it
+with `cookie_jar=aiohttp.DummyCookieJar()`: cookies are handled per host by
+hand, and a real jar would resend them.
+
+## Limitations
+
+- **Current week only.** The portal ignores `week_offset=1`, and the real
+  week-navigation parameter hasn't been found yet. A browser HAR trace of
+  clicking the next-week arrow would solve it; `scripts/capture_fixtures.py`
+  captures portal HTML.
+- **Cancelled and changed lessons are unverified.** No real capture has had
+  one yet, so `Lesson.is_changed` and `is_cancelled` are always `False`.
+- **Unpaid payment requests are unverified.** Only paid ones have been seen.
+  A request without the "accepted" marker is reported as unpaid.
+
+## Development
+
+```bash
+uv sync --group dev
+uv run pytest
+uv run ruff check .
+uv run mypy src
+```
+
+To release, bump `version` in `pyproject.toml` and push a `vX.Y.Z` tag. The
+publish workflow checks that the tag matches the version, then tests, builds
+and uploads to PyPI with trusted publishing.

pyedookit-0.3.2/README.md

@@ -0,0 +1,93 @@
+# pyedookit
+
+[![PyPI](https://img.shields.io/pypi/v/pyedookit)](https://pypi.org/project/pyedookit/)
+[![CI](https://github.com/TFoxik/pyedookit/actions/workflows/ci.yml/badge.svg)](https://github.com/TFoxik/pyedookit/actions/workflows/ci.yml)
+
+Unofficial async Python client for the [Edookit](https://edookit.com) parent
+portal (`https://<school>.edookit.net`) used by Czech schools. It powers the
+[ha-edookit](https://github.com/TFoxik/ha-edookit) Home Assistant integration
+and works standalone.
+
+Edookit's REST API only works if a school administrator enables it, so this
+library signs in like a parent does (Plus4U OIDC, no browser) and reads the
+portal's pages. Edookit doesn't support it, and a change to the portal's
+markup can break a parser until it's updated.
+
+## Install
+
+```bash
+pip install pyedookit
+```
+
+Requires Python 3.12+.
+
+## Usage
+
+```python
+import asyncio
+from pyedookit import EdookitClient, login
+
+async def main():
+    session = await login("zs-example", "parent@example.com", "hunter2")
+    client = EdookitClient(session)
+    for lesson in await client.get_timetable():
+        print(lesson.start, lesson.subject, lesson.room)
+
+asyncio.run(main())
+```
+
+| Call | Returns |
+|---|---|
+| `get_timetable()` | this week's `Lesson`s, times in `PORTAL_TZ` (Europe/Prague) |
+| `get_events()` | upcoming `SchoolEvent`s; all-day events have `date` start/end, end inclusive |
+| `get_payments()` | `Payments` totals and requests, amounts as `Decimal` |
+| `fetch_page(name)` | raw HTML of a page without a parser yet (`CAPTURE_PAGES`) |
+
+`content_fingerprint(html)` tells you when such a page's content changed.
+
+### Sessions
+
+The password is only used by `login()`. Store `session.to_json()` instead,
+and treat it like a password: it holds the Plus4U cookie, which signs in
+for about 19 days. Load it with `Session.from_json()`.
+
+The edookit session itself lasts 30-60 minutes. When it runs out, call
+`refresh(session)` to get a new one from the Plus4U cookie. When `refresh()`
+raises `AuthError`, the Plus4U cookie has expired too and you need `login()`
+again.
+
+| Exception | Meaning | What to do |
+|---|---|---|
+| `SessionExpired` | the edookit session ran out | `refresh()` and retry |
+| `AuthError` | bad credentials, or the Plus4U cookie expired | `login()` |
+| `EdookitConnectionError` | network error or 30 s timeout | retry later |
+| `ParseError` | the portal's markup changed | the parser needs updating |
+
+All of them derive from `EdookitError`. `login()`, `refresh()` and
+`EdookitClient` accept an `http: aiohttp.ClientSession` to reuse. Create it
+with `cookie_jar=aiohttp.DummyCookieJar()`: cookies are handled per host by
+hand, and a real jar would resend them.
+
+## Limitations
+
+- **Current week only.** The portal ignores `week_offset=1`, and the real
+  week-navigation parameter hasn't been found yet. A browser HAR trace of
+  clicking the next-week arrow would solve it; `scripts/capture_fixtures.py`
+  captures portal HTML.
+- **Cancelled and changed lessons are unverified.** No real capture has had
+  one yet, so `Lesson.is_changed` and `is_cancelled` are always `False`.
+- **Unpaid payment requests are unverified.** Only paid ones have been seen.
+  A request without the "accepted" marker is reported as unpaid.
+
+## Development
+
+```bash
+uv sync --group dev
+uv run pytest
+uv run ruff check .
+uv run mypy src
+```
+
+To release, bump `version` in `pyproject.toml` and push a `vX.Y.Z` tag. The
+publish workflow checks that the tag matches the version, then tests, builds
+and uploads to PyPI with trusted publishing.

{pyedookit-0.3.0 → pyedookit-0.3.2}/pyproject.toml

@@ -4,16 +4,26 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyedookit"
-version = "0.3.0"
+version = "0.3.2"
 description = "Async client for the Edookit parent portal (edookit.net)"
 readme = "README.md"
 requires-python = ">=3.12"
 license = { text = "MIT" }
-authors = [{ name = "tomas.liska" }]
+authors = [{ name = "TFoxik" }]
+classifiers = [
+    "Framework :: AsyncIO",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
 dependencies = [
-    "aiohttp>=3.9",
+    "aiohttp>=3.14.3",
     "beautifulsoup4>=4.12",
-    "lxml>=5.0",
+    "lxml>=6.1.0",
+    "yarl>=1.24",
 ]
 
 [project.urls]
@@ -22,6 +32,9 @@ Homepage = "https://github.com/TFoxik/pyedookit"
 [tool.hatch.build.targets.wheel]
 packages = ["src/pyedookit"]
 
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
@@ -39,9 +52,9 @@ python_version = "3.12"
 
 [dependency-groups]
 dev = [
-    "pytest>=8.0",
-    "pytest-asyncio>=0.24",
-    "multidict>=6.0",
-    "ruff>=0.6",
-    "mypy>=1.11",
+    "pytest>=9.0",
+    "pytest-asyncio>=1.0",
+    "multidict>=6.9.1",
+    "ruff>=0.17",
+    "mypy>=2.4",
 ]

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/__init__.py

@@ -7,7 +7,7 @@ from .exceptions import (
     ParseError,
     SessionExpired,
 )
-from .models import PORTAL_TZ, Lesson, PaymentRequest, Payments, SchoolEvent, Student, Term
+from .models import PORTAL_TZ, Lesson, PaymentRequest, Payments, SchoolEvent, Term
 from .parsers.fingerprint import content_fingerprint
 from .session import Session
 
@@ -25,7 +25,6 @@ __all__ = [
     "SchoolEvent",
     "Session",
     "SessionExpired",
-    "Student",
     "Term",
     "content_fingerprint",
     "login",

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/auth.py

@@ -11,7 +11,7 @@ import aiohttp
 from yarl import URL
 
 from .exceptions import AuthError, EdookitConnectionError
-from .session import Session
+from .session import Session, school_base, validate_school
 
 _PLUS4U_OIDC_BASE = (
     "https://uuidentity.plus4u.net/uu-oidc-maing02/bb977a99f4cc4c37a2afce3fd599d0a7"
@@ -32,11 +32,9 @@ _CLIENT_ID_RE = re.compile(
 
 _PLUS4U_HOST = "uuidentity.plus4u.net"
 _MAX_REDIRECTS = 5
-
-# A school subdomain becomes part of a URL (redirect_uri, portal base) with
-# no other encoding, so reject anything that isn't a bare hostname label -
-# otherwise a value like "evil.com/" would redirect the OIDC flow off-portal.
-_SCHOOL_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,62}$")
+# Every hop of the login flow stays on these over https; anything else means
+# a response was tampered with, and must not receive cookies or the code.
+_ALLOWED_HOST_SUFFIXES = (".plus4u.net", ".edookit.net")
 
 REDIRECT_STATUSES = frozenset({301, 302, 303, 307, 308})
 
@@ -66,24 +64,24 @@ class _FetchResult:
     url: str
     text: str
     location: str | None
-    is_redirect: bool
-
 
-def _validate_school(school: str) -> None:
-    if not _SCHOOL_RE.match(school):
-        raise AuthError(f"{school!r} is not a valid Edookit school subdomain")
+    @property
+    def is_redirect(self) -> bool:
+        return self.status in REDIRECT_STATUSES
 
 
 def _school_host(school: str) -> str:
     return f"{school}.edookit.net"
 
 
-def _school_base(school: str) -> str:
-    return f"https://{_school_host(school)}"
+def _callback_url(school: str) -> str:
+    return f"{school_base(school)}/user/oidc-login-callback"
 
 
-def _callback_url(school: str) -> str:
-    return f"{_school_base(school)}/user/oidc-login-callback"
+def _check_hop(url: URL) -> None:
+    host = url.host or ""
+    if url.scheme != "https" or not host.endswith(_ALLOWED_HOST_SUFFIXES):
+        raise AuthError(f"login flow tried to leave Plus4U/Edookit (to {url.scheme}://{host})")
 
 
 def _apply_set_cookies(headers: Iterable[str], jar: dict[str, str]) -> None:
@@ -140,7 +138,7 @@ async def _discover_client_id(
     - PHPSESSID etc. - joins the same cookie tracking the rest of the login
     flow uses, rather than being discarded.
     """
-    result = await _fetch(http, "GET", f"{_school_base(school)}/user/login", cookies_by_host)
+    result = await _fetch(http, "GET", f"{school_base(school)}/user/login", cookies_by_host)
     match = _CLIENT_ID_RE.search(result.text)
     if not match:
         raise AuthError(f"could not find a Plus4U client_id on {school}'s login page")
@@ -170,7 +168,9 @@ async def _fetch(
     current_params = params
 
     for _ in range(_MAX_REDIRECTS + 1):
-        host = URL(current_url).host or ""
+        parsed = URL(current_url)
+        _check_hop(parsed)
+        host = parsed.host or ""
         headers: dict[str, str] = {}
         host_cookies = cookies_by_host.get(host)
         if host_cookies:
@@ -189,20 +189,17 @@ async def _fetch(
                 if set_cookies := resp.headers.getall("Set-Cookie", []):
                     _apply_set_cookies(set_cookies, cookies_by_host.setdefault(host, {}))
 
-                is_redirect = resp.status in REDIRECT_STATUSES
                 location = resp.headers.get("Location")
-                text = "" if is_redirect else await resp.text()
                 result = _FetchResult(
                     status=resp.status,
                     url=str(resp.url),
-                    text=text,
+                    text="" if resp.status in REDIRECT_STATUSES else await resp.text(),
                     location=location,
-                    is_redirect=is_redirect,
                 )
         except (aiohttp.ClientError, TimeoutError) as err:
             raise EdookitConnectionError(f"request to {host} failed: {err}") from err
 
-        if not (follow_redirects and is_redirect and location):
+        if not (follow_redirects and result.is_redirect and location):
             return result
 
         current_url = str(URL(current_url).join(URL(location)))
@@ -221,7 +218,7 @@ def _new_http_session() -> aiohttp.ClientSession:
 
 
 @asynccontextmanager
-async def _http_session(http: aiohttp.ClientSession | None) -> AsyncIterator[aiohttp.ClientSession]:
+async def http_session(http: aiohttp.ClientSession | None) -> AsyncIterator[aiohttp.ClientSession]:
     if http is not None:
         yield http
         return
@@ -264,7 +261,7 @@ async def _finish_callback(
     result = await _fetch(http, "GET", callback_url, cookies_by_host, follow_redirects=True)
     if is_login_url(result.url):
         raise AuthError("edookit rejected the Plus4U authorization code")
-    settle = await _fetch(http, "GET", _school_base(school), cookies_by_host, follow_redirects=True)
+    settle = await _fetch(http, "GET", school_base(school), cookies_by_host, follow_redirects=True)
     if is_login_url(settle.url):
         raise AuthError("session did not settle after the OIDC callback")
     return _session_from_cookies(school, cookies_by_host)
@@ -276,12 +273,26 @@ async def probe_client_id(school: str) -> str:
     Used by scripts/capture_fixtures.py to show what login()/refresh() will
     use for this school before spending the user's password.
     """
-    _validate_school(school)
+    validate_school(school)
     cookies_by_host: CookiesByHost = {}
     async with _new_http_session() as http:
         return await _discover_client_id(http, school, cookies_by_host)
 
 
+async def _authorize(
+    http: aiohttp.ClientSession,
+    school: str,
+    cookies_by_host: CookiesByHost,
+    *,
+    prompt_none: bool = False,
+) -> tuple[str, str, _FetchResult]:
+    """Start the OIDC authorization: shared opening of login() and refresh()."""
+    client_id = await _discover_client_id(http, school, cookies_by_host)
+    state = secrets.token_urlsafe(16)
+    params = _auth_params(school, client_id, state, prompt_none=prompt_none)
+    return client_id, state, await _fetch(http, "GET", _AUTH_URL, cookies_by_host, params=params)
+
+
 async def login(
     school: str,
     username: str,
@@ -299,18 +310,10 @@ async def login(
     `aiohttp.DummyCookieJar()`): cookies are tracked per host by hand here,
     and a real jar would also collect and resend them.
     """
-    _validate_school(school)
+    validate_school(school)
     cookies_by_host: CookiesByHost = {}
-    async with _http_session(http) as http:
-        client_id = await _discover_client_id(http, school, cookies_by_host)
-        state = secrets.token_urlsafe(16)
-        step1 = await _fetch(
-            http,
-            "GET",
-            _AUTH_URL,
-            cookies_by_host,
-            params=_auth_params(school, client_id, state),
-        )
+    async with http_session(http) as http:
+        client_id, state, step1 = await _authorize(http, school, cookies_by_host)
         if not step1.is_redirect or not step1.location:
             raise AuthError(f"expected a redirect from Plus4U auth endpoint, got {step1.status}")
         login_url = URL(step1.location)
@@ -355,21 +358,12 @@ async def refresh(session: Session, *, http: aiohttp.ClientSession | None = None
     every 19 days), which means a full `login()` with the password is needed.
     `http` has the same cookie-jar requirement as in `login()`.
     """
-    _validate_school(session.school)
     # Only the Plus4U cookies: the portal answers /user/login with a redirect
     # to /oidc/logout when it sees the expired edookit session, so the new
     # edookit session is built from scratch, exactly like in login().
     cookies_by_host: CookiesByHost = {_PLUS4U_HOST: dict(session.plus4u_cookies)}
-    async with _http_session(http) as http:
-        client_id = await _discover_client_id(http, session.school, cookies_by_host)
-        state = secrets.token_urlsafe(16)
-        step1 = await _fetch(
-            http,
-            "GET",
-            _AUTH_URL,
-            cookies_by_host,
-            params=_auth_params(session.school, client_id, state, prompt_none=True),
-        )
+    async with http_session(http) as http:
+        _, _, step1 = await _authorize(http, session.school, cookies_by_host, prompt_none=True)
         if not step1.is_redirect or not step1.location or "code=" not in step1.location:
             raise AuthError("Plus4U session expired; full login required")
 

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/client.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import asyncio
+import json
+
 import aiohttp
 
 from . import auth
@@ -35,6 +38,9 @@ class EdookitClient:
     and closed per request. Cookies are sent by hand, so give it a
     `aiohttp.DummyCookieJar()` rather than a shared session whose jar would
     also collect the portal's cookies.
+
+    Pages are parsed in a worker thread so a large timetable doesn't stall
+    the caller's event loop.
     """
 
     def __init__(self, session: Session, http: aiohttp.ClientSession | None = None) -> None:
@@ -46,12 +52,11 @@ class EdookitClient:
         return self._session
 
     async def get_terms(self) -> list[Term]:
-        html = await self.fetch_timetable_html()
-        return parse_terms(html)
+        return await asyncio.to_thread(parse_terms, await self.fetch_timetable_html())
 
     async def get_timetable(self, week_offset: int = 0) -> list[Lesson]:
         html = await self.fetch_timetable_html(week_offset)
-        return parse_timetable(html)
+        return await asyncio.to_thread(parse_timetable, html)
 
     async def fetch_timetable_html(self, week_offset: int = 0) -> str:
         """Raw `/timetable/` HTML for one week - also used by
@@ -59,10 +64,10 @@ class EdookitClient:
         return await self._get(_TIMETABLE_PATH, params={"familyTimetable-value": week_offset})
 
     async def get_events(self) -> list[SchoolEvent]:
-        return parse_events(await self._get(_EVENTS_PATH))
+        return await asyncio.to_thread(parse_events, await self._get(_EVENTS_PATH))
 
     async def get_payments(self) -> Payments:
-        return parse_payments(await self._get(_PAYMENTS_PATH))
+        return await asyncio.to_thread(parse_payments, await self._get(_PAYMENTS_PATH))
 
     async def fetch_page(self, name: str) -> str:
         """Raw HTML of one of `CAPTURE_PAGES`, for pages without a parser yet."""
@@ -74,34 +79,44 @@ class EdookitClient:
 
     async def _get(self, path: str, params: dict[str, int] | None = None) -> str:
         url = f"{self._session.base_url}{path}"
-        headers = auth.build_headers(self._session)
-        if self._http is not None:
-            return await self._request(self._http, url, params, headers)
-        async with aiohttp.ClientSession() as http:
-            return await self._request(http, url, params, headers)
-
-    async def _request(
-        self,
-        http: aiohttp.ClientSession,
-        url: str,
-        params: dict[str, int] | None,
-        headers: dict[str, str],
-    ) -> str:
         # allow_redirects=False: our Cookie/CSRF headers are set manually, and
         # older aiohttp forwards a manually-set Cookie header to a redirect's
         # target even when that target is a different host - so an expired
         # session's redirect to Plus4U must never be followed with them
         # attached. Any redirect at all means the session isn't good anymore.
         try:
-            async with http.get(
-                url,
-                params=params,
-                headers=headers,
-                allow_redirects=False,
-                timeout=auth.REQUEST_TIMEOUT,
-            ) as resp:
-                if resp.status in auth.REDIRECT_STATUSES or auth.is_login_url(str(resp.url)):
+            async with (
+                auth.http_session(self._http) as http,
+                http.get(
+                    url,
+                    params=params,
+                    headers=auth.build_headers(self._session),
+                    allow_redirects=False,
+                    timeout=auth.REQUEST_TIMEOUT,
+                ) as resp,
+            ):
+                if resp.status in auth.REDIRECT_STATUSES:
                     raise SessionExpired("edookit session has expired")
-                return await resp.text()
+                body = await resp.text()
         except (aiohttp.ClientError, TimeoutError) as err:
             raise EdookitConnectionError(f"request to {url} failed: {err}") from err
+        if _redirects_to_login(resp.headers.get("Content-Type", ""), body):
+            raise SessionExpired("edookit session has expired")
+        return body
+
+
+def _redirects_to_login(content_type: str, body: str) -> bool:
+    """Whether the portal answered with its AJAX-style login redirect.
+
+    Requests carry X-Requested-With, so an expired session gets a 200 with
+    {"redirect": "https://<school>.edookit.net/user/login?message=1"} rather
+    than an HTTP redirect (confirmed against a real portal).
+    """
+    if not content_type.startswith("application/json"):
+        return False
+    try:
+        data = json.loads(body)
+    except ValueError:
+        return False
+    redirect = data.get("redirect") if isinstance(data, dict) else None
+    return isinstance(redirect, str) and auth.is_login_url(redirect)

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/models.py

@@ -29,12 +29,6 @@ class Term:
     name: str
 
 
-@dataclass(frozen=True, slots=True)
-class Student:
-    id: str
-    name: str
-
-
 @dataclass(frozen=True, slots=True)
 class SchoolEvent:
     id: str

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/parsers/dates.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import re
-from datetime import date, timedelta
+from datetime import date, datetime, timedelta
+
+from ..models import PORTAL_TZ
 
 # The portal writes the year only when it isn't the current one, and uses a
 # word instead of a date for recent days ("Dnes , 8:00 – 8:45"; Včera/Dnes
@@ -15,6 +17,10 @@ _DAY_RE = re.compile(
 TIME_RE = re.compile(r"(\d{1,2}):(\d{2})")
 
 
+def portal_today() -> date:
+    return datetime.now(PORTAL_TZ).date()
+
+
 def find_days(text: str, today: date) -> list[date]:
     days: list[date] = []
     for match in _DAY_RE.finditer(text):

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/parsers/events.py

@@ -8,7 +8,7 @@ from bs4 import BeautifulSoup, Tag
 
 from ..exceptions import ParseError
 from ..models import PORTAL_TZ, SchoolEvent
-from .dates import TIME_RE, find_days
+from .dates import TIME_RE, find_days, portal_today
 
 _EVENT_ID_RE = re.compile(r"event=(\d+)")
 
@@ -27,7 +27,7 @@ def parse_events(html: str, today: date | None = None) -> list[SchoolEvent]:
     if soup.select_one("section.content") is None:
         raise ParseError("upcoming events page has no content section")
     if today is None:
-        today = datetime.now(PORTAL_TZ).date()
+        today = portal_today()
 
     events: list[SchoolEvent] = []
     for row in soup.select("div.events_table ul.table_row"):
@@ -71,7 +71,7 @@ def _parse_row(row: Tag, today: date) -> SchoolEvent | None:
         start, end = days[0], days[-1]
 
     description = " ".join(
-        p.get_text(" ", strip=True) for p in row.select("li.c2 > p") if p.get_text(strip=True)
+        text for p in row.select("li.c2 > p") if (text := p.get_text(" ", strip=True))
     )
     creator = row.select_one("li.c3 div.smaller p b")
     return SchoolEvent(

{pyedookit-0.3.0 → pyedookit-0.3.2}/src/pyedookit/parsers/timetable.py

@@ -8,7 +8,7 @@ from bs4 import BeautifulSoup, Tag
 
 from ..exceptions import ParseError
 from ..models import PORTAL_TZ, Lesson, Term
-from .dates import find_days
+from .dates import find_days, portal_today
 
 _TIME_RANGE_RE = re.compile(r"(\d{1,2}):(\d{2})\s*[-–]\s*(\d{1,2}):(\d{2})")
 _TERM_ID_RE = re.compile(r"termSelector-new=(\d+)")
@@ -44,7 +44,7 @@ def parse_timetable(html: str, today: date | None = None) -> list[Lesson]:
         raise ParseError("no lesson-info blocks found on timetable page")
 
     if today is None:
-        today = datetime.now(PORTAL_TZ).date()
+        today = portal_today()
     lessons = []
     for block in blocks:
         lesson = _parse_lesson_info(block, today)