Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@holidays/countries/germany.py`:
- Around line 156-160: The _populate_school_holidays method fails to handle the
deprecated "BYP" subdivision so Germany(subdiv="BYP", categories=SCHOOL) returns
no data; update the logic in _populate_school_holidays to map "BYP" to Bavaria
the same way _populate_public_holidays does—i.e., when self._normalized_subdiv
equals "augsburg" OR equals "byp" (case-insensitive normalized form), set subdiv
= "BY" (using self._normalized_subdiv and the existing "BY" mapping) so school
holidays for Bavaria are returned for the deprecated code.

In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 190-203: The function ensure_pdf_sources currently returns any
cached PDFs immediately; instead always query the KMK index via
_get_school_year_pdf_links(index_url) to determine the authoritative set of pdf
URLs, compute the desired filenames (using urlparse(...).path.name), then
reconcile the raw_pdf_dir: download any missing desired PDFs, remove any extras
that are not in the authoritative list, and finally return the sorted list of
current pdf Paths. Update ensure_pdf_sources to perform this reconciliation (use
_get_school_year_pdf_links, urlparse(url).path.name, _fetch_url) rather than
short-circuiting when any *.pdf exists.
- Around line 267-276: The code currently zips columns with raw_row[1:] which
silently truncates ragged rows from extract_table(); update the loop that builds
rows to validate row width before zipping by checking that len(raw_row) - 1 ==
len(columns) (or at least >=), and if it doesn't match, raise or log a clear
exception including state_label/subdiv and the offending raw_row so generation
fails loudly; only proceed to create rows[subdiv] via zip(columns, raw_row[1:])
(and/or explicitly pad missing cells with "" if you prefer to tolerate short
rows) after the width check, referencing variables raw_row, columns,
state_label, STATE_LABEL_TO_CODE, and _normalize_cell to locate the change.

In `@tests/common.py`:
- Around line 600-603: In _assertLocalizedHolidays, the current fallback
`categories = categories or self.test_class.supported_categories` overwrites
intentionally empty values like ()—change it to only assign the default when
categories is None (e.g., `if categories is None: categories =
self.test_class.supported_categories`) so explicit empty tuples/lists are
preserved; update the logic in the _assertLocalizedHolidays method of the test
class accordingly.

---

Outside diff comments:
In `@tests/countries/test_germany.py`:
- Around line 40-50: The test_no_holidays currently only checks SCHOOL without a
subdivision and misses categories beyond PUBLIC; update test_no_holidays to
iterate all supported categories using Germany.supported_categories and for each
subdiv in Germany.subdivisions instantiate Germany(subdiv=subdiv,
years=self.start_year - 1, categories=category) (and for categories that aren't
subdiv-dependent also test without subdiv) so you validate that no holidays
exist before start_year across all supported categories; ensure the existing
specific checks (e.g., years=1989 and years=2025 for SCHOOL) remain or are
adapted to use Germany.supported_categories where appropriate.
- Around line 448-549: The localization tests currently never exercise
SCHOOL-scoped translations; add a new subdivision-scoped test in
tests/countries/test_germany.py (e.g., def test_l10n_de_by_school(self):) that
calls assertLocalizedHolidays with the Bavaria subdivision identifier and
includes the school-only holiday names, passing categories=(SCHOOL,) or
categories=(PUBLIC, SCHOOL) so the new DE.po SCHOOL entries are verified;
reference assertLocalizedHolidays and ensure the test name and the categories
argument target SCHOOL so the school-holiday translations in DE.po are
exercised.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 157-159: The _fetch_url function currently calls urlopen(url) with
no timeout which can hang; update the call in function _fetch_url to pass a
reasonable timeout (e.g., timeout=30) to urlopen (urlopen(url, timeout=30)) so
network reads will fail fast on stalled connections and keep the generator
responsive.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 389-391: The outer loop currently declares an unused variable
"year" in the construct "for year, year_data in data.items()" — update the loop
to avoid the unused variable by either iterating over values ("for year_data in
data.values()") or renaming "year" to "_" ("for _, year_data in data.items()")
so linters don't flag it; keep the inner body that sorts and deduplicates
"year_data[subdiv]".

In `@tests/countries/test_germany.py`:
- Around line 146-150: The test is mocking Germany._add_holiday with an
incorrect return type (False) even though the method returns date | None; update
the mock in the test to return None instead of False so the mocked behavior
matches the real function signature (locate the mock.patch.object(Germany,
"_add_holiday", return_value=...) in tests/countries/test_germany.py and change
the return_value to None), leaving the _add_multiday_holiday mock and its
assert_not_called() check unchanged.

---

Duplicate comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 283-284: The dict comprehension using zip(columns, row_cells) in
the generator that builds rows (mapping column: _normalize_cell(cell or "") for
column, cell in zip(columns, row_cells)) should use zip(columns, row_cells,
strict=True) to enforce equal-length iterables and silence Ruff B905; update
that expression to add strict=True so any mismatch raises immediately and keeps
the existing row length checks as defense-in-depth.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 40-43: DEFAULT_RAW_PDF_DIR currently points under the repo
ROOT_DIR which risks accidental commits; change the default to a per-user or OS
temp cache (e.g. use appdirs.user_cache_dir or tempfile.gettempdir() and build a
subpath like "holidays-germany-school-holidays/pdfs") instead of
ROOT_DIR/.cache, while leaving the existing CLI/config override (--input-dir /
input_dir) intact; update the constant DEFAULT_RAW_PDF_DIR and any code that
constructs the path to use the new user-temp/user-cache location (reference
DEFAULT_RAW_PDF_DIR and ROOT_DIR in the file) so only explicit overrides put
files under the repo.
- Around line 211-226: Several re.sub patterns use Java/POSIX-style possessive
quantifiers (e.g. "++" and "*+") which break on Python 3.10; update those
regexes to standard quantifiers. Locate the label-cleanup block (patterns like
r"^\d++\s++", r"\s*+\([^)]*+\)", r"\s++\d++$") and change "++" to "+" and "*+"
to "*" (e.g. r"^\d+\s+", r"\s*\([^)]*\)", r"\s+\d+$"); likewise update patterns
in _normalize_cell (r"\s*+/\s*+" -> r"\s*/\s*", r"\s*+-\s*+" -> r"\s*-\s*",
etc.). Keep the rest of the regexes unchanged.

In `@tests/countries/test_germany.py`:
- Around line 49-50: Replace the hardcoded 1989 SCHOOL check with the real
boundary check by using self.start_year - 1 for the Germany(subdiv="BY",
categories=SCHOOL) call, remove the duplicate Germany(years=1989,
categories=SCHOOL) assertion, and ensure the generic no-holidays test uses all
supported categories by invoking
test_no_holidays(categories=Germany.supported_categories) (or
CountryClass.supported_categories) so pre-start_year checks cover PUBLIC,
SCHOOL, OPTIONAL and subdivision-specific data; update the assertions that
reference Germany and the test_no_holidays helper accordingly.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 441-444: The output file is written with locale defaults; change
the write to explicitly use UTF-8 and LF endings by replacing the
OUTPUT_PATH.write_text(render_python_module(data)) call in main() with an
explicit open/write using OUTPUT_PATH.open("w", encoding="utf-8", newline="\n")
and write(render_python_module(data)) so the generated module is encoded as
UTF-8 and uses '\n' line endings.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 298-299: The current lookup for the school-year header using
next(...) can raise an opaque StopIteration if no header contains "/", so change
it to safely attempt the find (e.g., next(..., None)) and if not found raise a
clear, file-specific ValueError explaining the missing or unexpected school-year
header; reference the column_years mapping and the subsequent call to
_parse_school_year(school_year) in the error message so the failure points to
the exact cause and input shape problem.
- Around line 246-251: The _parse_school_year function mishandles two-digit end
years across centuries (e.g., "1999/00" -> 1900); fix by computing candidate_end
= (start_year // 100) * 100 + int(end_year_str) when end_year_str length != 4,
and if candidate_end <= start_year add 100 to roll into the next century, then
assign end_year = candidate_end; update the logic around start_year, end_year,
start_year_str, end_year_str in _parse_school_year accordingly so ranges like
"1999/00" become (1999, 2000).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@holidays/countries/germany.py`:
- Around line 181-185: The loop that reads GERMANY_SCHOOL_HOLIDAYS currently
only looks up GERMANY_SCHOOL_HOLIDAYS.get(self._year, {}).get(subdiv, ()) so
cross-year breaks that start in the previous year (e.g., a Christmas break
starting in year-1 and ending in self._year) are missed; update the iteration to
also include entries from GERMANY_SCHOOL_HOLIDAYS.get(self._year - 1,
{}).get(subdiv, ()) (or merge both year dicts) and still apply the same
start/end normalization (start_date, end_date, active_start, active_end) so
January continuations from prior-year records are considered when populating
self._year.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@holidays/countries/germany.py`:
- Around line 173-191: The loop only reads GERMANY_SCHOOL_HOLIDAYS entries keyed
by self._year, so multi-day holidays that start in the prior year and continue
into January are missed; fix by iterating over both year keys (self._year and
self._year - 1) for the given subdiv, e.g. gather records =
GERMANY_SCHOOL_HOLIDAYS.get(self._year, {}) and records_prev =
GERMANY_SCHOOL_HOLIDAYS.get(self._year - 1, {}) and loop over both sets; when
constructing start_date/end_date use the corresponding year_key (year_key +
start_year_offset and year_key + end_year_offset) rather than always self._year
so _add_holiday and _add_multiday_holiday see January continuations.

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 449-484: The normalize_ranges function is doing too much (parsing
cells, resolving years, clipping to calendar years, and building 7-tuples) which
pushes cognitive complexity over the threshold; extract the per-cell expansion
into a helper (e.g., _expand_cell_ranges or expand_cell_ranges) that takes
(column_key, year_label, cell) and yields the 7-tuple entries
(start_year_offset, start_month, start_day, end_year_offset, end_month, end_day,
holiday_id) by using parse_cell_ranges, _resolve_years and HOLIDAY_IDS, and
performing the year clipping there; then simplify normalize_ranges to iterate
sources -> rows -> subdivisions -> use the new helper to extend
data[year][subdiv], and keep the existing dedupe/sort step and final dict
construction.
- Around line 329-377: The _parse_pdf_table function is too complex — extract
the row-processing and subdivision-check logic into small helpers to lower
cognitive complexity without changing behavior: create a helper
_build_rows(table_rows, column_specs, path) that encapsulates the loop that maps
raw_row -> (subdiv -> list of (column, year_label, normalized_cell)) and raises
the same ValueError when column counts mismatch (use symbols row_cells, columns,
column_specs, _normalize_cell, _normalize_state_label, STATE_LABEL_TO_CODE), and
create a helper _validate_subdivision_set(rows, path) that performs the
missing/extra subdivision checks and raises the identical ValueError when the
sets differ (use EXPECTED_SUBDIVISIONS and rows.keys()); call these helpers from
_parse_pdf_table and keep the school_year detection and return semantics
unchanged.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 520-525: The generated calendar module currently appends a
"__all__ = (...)" block to the output; remove that append so the generator no
longer emits any "__all__" declaration (delete the code that pushes the string
starting with "__all__ = (" and its associated lines into the generated file
content). Locate the string literal "__all__ = (" in the generator and remove
the block that writes "__all__" (and any trailing closing lines), ensuring the
rest of the generated constants and functions (e.g., AUTUMN_BREAK,
CHRISTMAS_BREAK, GERMANY_SCHOOL_HOLIDAYS) are left untouched so the produced
module matches the other calendar modules.

---

Duplicate comments:
In `@scripts/calendar/germany_school_holidays_generator.py`:
- Around line 449-484: The normalize_ranges function is too complex; extract the
per-cell expansion loop (parse_cell_ranges → _resolve_years → year clipping →
emitting the 7-tuple with HOLIDAY_IDS) into a new generator helper (e.g.,
expand_cell_ranges or iter_cell_tuples) that yields (start_year_offset,
start_month, start_day, end_year_offset, end_month, end_day, holiday_id) for a
given column_key, year_label and cell; then have normalize_ranges call that
helper to extend data[year][subdiv] for each yielded tuple and keep the rest
(dedupe/sort and final dict construction) unchanged so cognitive complexity of
normalize_ranges is reduced.
- Around line 219-221: The current loop builds existing_paths from
raw_pdf_dir.glob("*.pdf") and then unlinks any names not in indexed_pdfs, which
can delete arbitrary PDFs in a caller-supplied --input-dir; instead restrict
deletion to the generator's managed cache or only files the generator previously
created: change the source of files checked from raw_pdf_dir to the internal
cache directory (or a dedicated managed subdirectory), or filter existing_paths
to only include files with the generator's filename pattern/marker or those
recorded in a “created_files” set, then iterate over that restricted set and
call unlink on extra_name; update references to existing_paths, raw_pdf_dir,
indexed_pdfs, extra_name, and unlink accordingly so only controlled files are
removed.
- Around line 329-377: The function _parse_pdf_table is too complex; extract the
row-processing loop that builds rows[subdiv] and the subdivision validation
block into two small helpers (e.g., _build_rows_from_table(table_rows,
column_specs, path) -> dict and _validate_subdivisions(rows, path) -> None) so
_parse_pdf_table only orchestrates extraction, header/column checks and
school-year detection; ensure the helpers accept the same inputs used in the
loop (raw table rows, column_specs, EXPECTED_SUBDIVISIONS, STATE_LABEL_TO_CODE,
_normalize_state_label, _normalize_cell) and preserve all existing ValueError
messages and return types (start_year, rows) so behavior doesn't change.