settfex 0.22.2__tar.gz → 0.23.0__tar.gz

{settfex-0.22.2 → settfex-0.23.0}/AGENTS.md

@@ -130,10 +130,19 @@ listing where **every** usable row was lost raises `IncompleteListingError` rath
 transport: a failed request raises `FetchError`, and a body that is not a listing page raises
 `ParseError`, instead of parsing to zero rows and looking like "this issuer filed nothing".
 
-One thing deliberately does **not** raise: a broken "display all results" page. That section keeps
-its truncated inline rows and the shortfall shows in `completeness()` — so check that before
-treating a section as complete. As of 2026-09-20 SEC's Thai `fs-kf` page answers HTTP 500, which is
-an upstream bug, not a settfex one.
+Two things deliberately do **not** raise. A broken "display all results" page: that section keeps
+its truncated inline rows and the shortfall shows in `completeness()`. And **one failing report
+code**: the others keep their documents, and the failure is recorded on
+`docs.accounting.failed_codes` (with a WARNING). So after a call that returned normally, check
+`docs.accounting.has_losses` before treating the result as complete — an exception is no longer how
+a partial failure announces itself. `repr(docs)` states it too.
+
+As of 2026-09-20 SEC's Thai `fs-kf` page answers HTTP 500, which is an upstream bug, not a settfex
+one; it shows up as a `key_financial_ratio` shortfall on Thai listings.
+
+⚠️ Read `.accounting` / `.reported_counts` off the object `get_sec_documents` returned: like
+`DownloadResult`, `SecDocumentList` is a `list` subclass, so slicing, `sorted()`, `list()` and
+comprehensions return a plain `list` and silently drop them.
 
 `download_sec_documents(...)` returns a `DownloadResult` — a list of the files that downloaded,
 which also carries `.failed` (each with its target and reason) and `.is_complete`. Check it before

{settfex-0.22.2 → settfex-0.23.0}/CHANGELOG.md

@@ -7,6 +7,86 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.23.0] - 2026-09-20
+
+### Fixed
+
+- **One failing report code discarded the successfully parsed documents of every other code**
+  (issue #132). `fetch_documents` defaults to all five categories, which collapse to three
+  `ddlReportType` codes run through `asyncio.gather` **without** `return_exceptions=True` — so the
+  first exception propagated before the line that collects the results was ever reached, and a
+  total loss in the `R562` search threw away the `FS` documents that had parsed perfectly well in
+  the same call.
+
+  The irony is worth stating, because it is the whole argument: 0.22.0 added
+  `IncompleteListingError` so a caller could tell loss from emptiness, and this `gather` discarded
+  the evidence of what *did* parse at the exact moment of raising it.
+
+  The rule is the one this module already uses twice — **a partial loss reports, a total loss
+  raises**: one code failing keeps its siblings' documents, records a `CodeFailure` and warns;
+  every code failing re-raises the first cause with its type and traceback intact. Anything that is
+  **not** a `FetchError` propagates untouched — a bug in settfex must not be laundered into an
+  accounting row, where it would be buried in a field most callers never read.
+
+  Deliberately **not** an `ExceptionGroup`, despite requiring Python 3.11+: `except FetchError`
+  does not catch one, so it would silently break every existing handler. When every code fails the
+  other causes ride along as **PEP 678 notes** on the raised one, so "the caller can always tell
+  which code failed and why" holds even in the total-failure case — with no new type, no changed
+  signature, and the traceback intact. "First" means first in **report-code order**, not first to
+  fail in time: `gather` returns positionally, so two identical runs raise the same cause.
+
+- **The same gather problem one level down**, on the "display all results" pages. 0.22.1 made a
+  failing ViewMore *response* degrade; a transport exception in that gather still killed the whole
+  call. It now degrades the same way: keep the section's truncated inline rows, warn, and let
+  `completeness()` show the shortfall.
+
+- **`IncompleteListingError` could not carry `unknown_sections`.** The field is inherited from
+  `ParseError`, but the subclass's `__init__` never accepted it, so it was **always `[]`** — a
+  field that looked answered and was not. A page can lose every row to a missing download link
+  *and* carry a heading nobody recognises; that combination is now visible.
+
+### Added
+
+- **`HTTPStatusError(FetchError)`** with `url` and `report_code`. `FetchError.status_code` already
+  distinguished a transport failure from an HTTP one; what was missing was somewhere for the two
+  facts a caller otherwise had to scrape out of the message string. An archive recording "the R562
+  search failed" should not have to parse prose to do it.
+
+- **`ListingAccounting.failed_codes`** — a list of `CodeFailure` (`code`, `categories`, `error`,
+  `error_type`, `status_code`, `url`), deliberately the same shape as `FailedDownload` from #128:
+  one pattern for "what did not make it", whether it was a file or a whole search. `has_losses` is
+  true when it is non-empty, because a search that never ran is the largest loss there is.
+
+- **`RowTally.unlinked_hrefs`** — a capped sample of the hrefs behind `no_link`, the smaller half of
+  issue #133. Every unknown download shape so far (`fsdl`, `viewdoc`, `capfin`) was found by a human
+  looking at a dropped row's URL, and each time that meant re-parsing the page by hand. The sample
+  is **diversity-first**: one href per distinct `(host, path)` before the cap of 20 is spent, so
+  twenty instances of an already-known shape can never crowd out the single instance of a new one —
+  which is precisely the row worth seeing. `no_link` remains the true total.
+
+- **`SecDocumentList.__repr__`**, and a failed-codes block in `summary()`. A summary that lists only
+  what arrived reads as success when an entire search is missing.
+
+### Changed
+
+- ⚠️ **Callers that relied on an exception to detect a partial failure must now check
+  `has_losses` / `accounting.failed_codes`.** Before 0.23.0, one report code failing raised and took
+  everything with it; now the call returns the documents that parsed. That is the point of the fix —
+  but a `try/except FetchError` that treated "no exception" as "complete" will now see a partial
+  result as a whole one. Every failed code is also logged at WARNING, which is the signal that
+  cannot be lost.
+
+### Documentation
+
+- **Issue #134's scope now covers `SecDocumentList`, not only `DownloadResult`** — verified: 6 of 8
+  ordinary list operations (slicing, `sorted()`, `list()`, concatenation, comprehensions) return a
+  plain `list` and drop `.accounting` and `.reported_counts`; `copy.copy()` and `filter()` are the
+  exceptions, and `filter()` only because 0.22.0 wired it through deliberately. This matters more
+  now that `failed_codes` rides on that same attribute, which is why each failed code is *also*
+  logged. Interim warning on the class and in the docs; the redesign is breaking and covers both
+  types as one decision.
+
+
 ## [0.22.2] - 2026-09-20
 
 ### Fixed

{settfex-0.22.2 → settfex-0.23.0}/CLAUDE.md

@@ -173,7 +173,7 @@ Host is **`market.sec.or.th`** (the Thai SEC IDISC system), NOT set.or.th — a
 
 | # | Service | Module | Endpoint Pattern | Key Data |
 |---|---|---|---|---|
-| 1 | SEC Documents | `sec/{company,financial_report,download,sec}.py` | `POST /public/idisc/api/company/valuebyuniqueId`; `GET`/`POST /public/idisc/{lang}/FinancialReport/{FS\|R561\|R562\|KFR}`; `GET /public/idisc/{lang}/ViewMore/{slug}`; `GET /public/idisc/Download?FILEID=`; `GET /ipos/Common/IPOSGetFile.aspx?id=`; `GET /public/idisc/Views/FinancialStatementDownload?query=`; `GET /public/idisc/views/viewdoc?TransId=` | List + download **raw disclosure documents** for any issuer across 5 categories (`DocumentCategory`: financial_statement/form_56_1/form_56_2/key_financial_ratio/mda). Company resolver (`resolve_company` → 10-digit uniqueIDReference); listing replays the ASP.NET WebForms search (GET `__VIEWSTATE` → form POST → stdlib HTML-table parse), follows ViewMore for complete large sections; downloads return raw bytes (`DownloadedFile.save()`), concurrent `download_all`, soft-404 detection (dead links = HTML "file not found" under HTTP 200 → `FetchError`). Listing returns a **`SecDocumentList`** (a `list[SecDocument]` subclass, backward compatible) with `years_by_category()`/`available_years()`/`filter(category=,year=)`/`categories()`/`summary()` helpers — pass a **wide** date window to see full year history. `SecCompany("CPALL")` facade; `get_sec_documents()`/`download_sec_document(s)()`. dd/mm/yyyy dates. Stateless host (no SessionManager). **Bilingual** — `lang="th"` returns the Thai-language filing documents (different files from the English ones), with Buddhist-era years/dates normalized to C.E. in the model; free-text cells stay in the page's language. `SecDocumentList.reported_counts`/`completeness()` carry what the site said each section holds, and an unclassifiable page raises `ParseError` instead of returning `[]`. **Row/column accounting** (`docs.accounting`: `no_link`/`placeholders`/`navigation`/`unmapped_headers`/`unverifiable_sections`/`by_category`, computed totals) makes every drop visible in the return value; a **total** loss raises `IncompleteListingError`, a partial one warns. `download_all` returns a `DownloadResult` (a `list[DownloadedFile]` subclass) carrying `.failed`. |
+| 1 | SEC Documents | `sec/{company,financial_report,download,sec}.py` | `POST /public/idisc/api/company/valuebyuniqueId`; `GET`/`POST /public/idisc/{lang}/FinancialReport/{FS\|R561\|R562\|KFR}`; `GET /public/idisc/{lang}/ViewMore/{slug}`; `GET /public/idisc/Download?FILEID=`; `GET /ipos/Common/IPOSGetFile.aspx?id=`; `GET /public/idisc/Views/FinancialStatementDownload?query=`; `GET /public/idisc/views/viewdoc?TransId=` | List + download **raw disclosure documents** for any issuer across 5 categories (`DocumentCategory`: financial_statement/form_56_1/form_56_2/key_financial_ratio/mda). Company resolver (`resolve_company` → 10-digit uniqueIDReference); listing replays the ASP.NET WebForms search (GET `__VIEWSTATE` → form POST → stdlib HTML-table parse), follows ViewMore for complete large sections; downloads return raw bytes (`DownloadedFile.save()`), concurrent `download_all`, soft-404 detection (dead links = HTML "file not found" under HTTP 200 → `FetchError`). Listing returns a **`SecDocumentList`** (a `list[SecDocument]` subclass, backward compatible) with `years_by_category()`/`available_years()`/`filter(category=,year=)`/`categories()`/`summary()` helpers — pass a **wide** date window to see full year history. `SecCompany("CPALL")` facade; `get_sec_documents()`/`download_sec_document(s)()`. dd/mm/yyyy dates. Stateless host (no SessionManager). **Bilingual** — `lang="th"` returns the Thai-language filing documents (different files from the English ones), with Buddhist-era years/dates normalized to C.E. in the model; free-text cells stay in the page's language. `SecDocumentList.reported_counts`/`completeness()` carry what the site said each section holds, and an unclassifiable page raises `ParseError` instead of returning `[]`. **Row/column accounting** (`docs.accounting`: `no_link`/`placeholders`/`navigation`/`unmapped_headers`/`unverifiable_sections`/`by_category`, computed totals) makes every drop visible in the return value; a **total** loss raises `IncompleteListingError`, a partial one warns. `download_all` returns a `DownloadResult` (a `list[DownloadedFile]` subclass) carrying `.failed`. **Transport guards** on every listing leg (non-2xx → `HTTPStatusError`, non-listing body → `ParseError`); **per-code isolation** so one failing `ddlReportType` keeps its siblings' documents and records a `CodeFailure` on `accounting.failed_codes`. |
 
 ### ThaiBMA Services (1)
 
@@ -418,6 +418,10 @@ See [`CHANGELOG.md`](CHANGELOG.md) for the full, versioned release history — t
 - **SEC's old-format filings are on a FIFTH host and behind a JavaScript indirection (issue #133):** `capital.sec.or.th/…/get_zip_all_public_page.php` carries pre-2014 `.DOC`/`.XLS` filings. The URL answers **HTTP 200 with a 2 KB HTML page whose entire body is `document.location = '/tmp/<id>.zip'`** — so recognising the link is necessary but not sufficient, and `download()` resolves the redirect at download time (one extra request). Three properties the code depends on: the target is **minted per request** (`XP`/`sD`/`V1` for the same filing across three captures), so `file_url` stays the stable indirection URL and the `/tmp/…` one is never stored; it is **per-language** (the Thai request mints a different archive, so `lang` is part of the `capfin:<comp_id>-<year>-<period>-<lang>` id); and `comp_id` is a **different id space from `set_id`** in the same query — they are not interchangeable. The redirect pattern accepts an absolute URL on purpose, so the same-host check is live rather than dead code.
 - **These old-format zips are MEMBER-STABLE, not byte-stable — do not key an archive on the container hash:** re-minting the same filing produced a different container sha256 while every member payload stayed byte-identical. Exactly **12 bytes of 334,498** differ, in four 3-byte runs, one per member: the Info-ZIP extended-timestamp (`UT`) extra field, i.e. the pack time. **Judge integrity per member.** A consumer that hashes the container will see a legitimate re-fetch as a new — or corrupted — object. (Also observed: one sample's embedded pack time *predated* the request that minted it, suggesting the server sometimes hands back a previously generated archive. INFERRED from two samples.)
 - **`DownloadResult` loses `.failed` the moment you derive a new list (issue #134, documented not fixed):** `.failed`, `.requested` and `.is_complete` are instance attributes on a `list` subclass, so slicing, `sorted()`, `list()`, concatenation and comprehensions all return a plain `list` without them — 6 of 7 ordinary operations, `copy.copy()` being the exception. `for f in sorted(result)` therefore quietly gives up the failure report #128 added. **Read `.failed` from the object `download_all` returned, before deriving anything from it.** `SecDocumentList` has the identical hazard for `.accounting`/`.reported_counts`. Removing the edge is a breaking change and is tracked for a later release.
+- **One failing report code no longer discards the others — and `has_losses` is now the only reliable "was it complete?" check:** `fetch_documents` collapses the requested categories to up to three `ddlReportType` codes run concurrently; the gather had no `return_exceptions=True`, so the first exception propagated before the collecting line ran and a total loss in `R562` threw away the `FS` documents that had parsed fine (issue #132). Now: **partial loss reports, total loss raises** — one code failing keeps its siblings' documents and records a `CodeFailure` on `accounting.failed_codes`; every code failing re-raises the first cause with its type and traceback intact. ⚠️ **Anything that is not a `FetchError` propagates untouched** — a settfex bug must not be laundered into an accounting row, where it would be buried in a field most callers never read. ⚠️ **Deliberately NOT an `ExceptionGroup`** despite the 3.11+ floor: `except FetchError` does not catch one, so it would silently break every existing handler. When every code fails, the other causes ride along as **PEP 678 notes** (`exc.add_note`) on the raised one — otherwise re-raising a single exception would quietly drop them, breaking the rule that a caller can always tell which code failed and why. **"First" means first in report-code order, not first to fail in time** (`gather` returns positionally), so the raised cause is deterministic across runs; a test pins that by making the last code fail instantly while the first yields 20 times. ⚠️ **Upgrade trap:** a `try/except FetchError` that treated "no exception" as "complete" now sees a partial result as a whole one — check `has_losses` / `failed_codes`. The same `return_exceptions` treatment was applied to the ViewMore gather, so a transport error there costs one section's completeness rather than the call.
+- **`unlinked_hrefs` is sampled for DIVERSITY, not "the first 20" — and that is the whole point:** `RowTally.unlinked_hrefs` keeps a capped sample of the hrefs behind `no_link`, because every unknown download shape so far (`fsdl`, `viewdoc`, `capfin`) was found by a human looking at a dropped row's URL, and each time that meant re-parsing the page by hand. The sampler takes **one href per distinct `(host, path)` first**, then fills to the cap of 20 — so thirty instances of an already-known shape can never crowd out the single instance of a new one, which is exactly the row worth seeing. `no_link` stays the true total, and `plus()` **re-samples** on merge rather than concatenating, or a merge could exceed the cap or lose the property the sample exists for.
+- **`IncompleteListingError` could not carry `unknown_sections` until 0.23.0 — a field that looked answered and was not:** it is inherited from `ParseError`, but the subclass's `__init__` never accepted it, so it was **always `[]`**. Anyone who inspected it concluded "no unrecognised headings" from a value that had never been populated. Fixed by accepting and forwarding it; a page can lose every row to a missing link *and* carry a heading nobody recognises.
+- **`SecDocumentList` has `DownloadResult`'s side-channel problem too (issue #134, documented not fixed):** 6 of 8 ordinary list operations — slicing, `sorted()`, `list()`, `+`, comprehensions — return a plain `list` and drop `.accounting` and `.reported_counts`. `copy.copy()` and `filter()` survive, and `filter()` only because 0.22.0 wired it through on purpose. **This got sharper in 0.23.0**, because `accounting.failed_codes` records which report code failed, so `sorted(docs, …)` would discard that too — which is why every failed code is **also logged at WARNING**: a log line cannot be sliced away. Read the accounting off the object `fetch_documents` returned. The redesign is breaking and covers both types as one decision.
 - **`no_href` was three different things, and only one is a defect:** a dropped SEC listing row is a `ไม่พบข้อมูล`/`Data not found` **placeholder** (the site saying the section is empty), a "display all results" **ViewMore navigation row** (how a long section truncates — 24% of live sections), or a **real data row whose download link is gone** (`no_link`). They shared one counter, which is why P1 could not be escalated: any rule strict enough to catch a genuine loss also fired on every truncated section. Split (`ListingAccounting.placeholders`/`navigation`/`no_link`), `no_link` is **0 on every real page captured** and non-zero only on a page derived to exhibit the bug — so it can be escalated without a record-count marker at all. `_MapResult.no_href` is kept as the sum of the three; **branch on `accounting.no_link`, never on `no_href`** (it is non-zero on perfectly healthy pages).
 - **Two cross-checks on a SEC listing, and they answer different questions:** `completeness()`/`reported_counts` compares what you hold against **the number the site printed** — a shortfall there is usually legitimate "view more" truncation, so it is reported and never raised. `docs.accounting` is **ours**: what the parser did with each row it received. A shortfall is a maybe; `accounting.no_link > 0` is always a loss. Do not fold one into the other.
 - **`IncompleteListingError` fires only on a TOTAL loss:** rows classified fine and *every* usable one was dropped for want of a download link. A **partial** loss warns and lands on `accounting.no_link` instead — raising there would turn one bad row in a 200-row listing into no listing at all, and unlike a total loss a partial one is visible in the return value. Same severity ladder as the 0.21.0 `ParseError` for unrecognised headings, and it is a `ParseError` subclass so `except ParseError`/`except FetchError` keep working. The escalation is scoped to the **requested** categories (a single `FS` search returns three sections) — the same principle PR #125 applied to `completeness()`.

{settfex-0.22.2 → settfex-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: settfex
-Version: 0.22.2
+Version: 0.23.0
 Summary: Async Python library for fetching real-time and historical data from the Stock Exchange of Thailand (SET) and Thailand Futures Exchange (TFEX)
 Project-URL: Homepage, https://github.com/lumduan/settfex
 Project-URL: Documentation, https://github.com/lumduan/settfex#readme

{settfex-0.22.2 → settfex-0.23.0}/docs/settfex/services/sec/financial_report.md

@@ -134,8 +134,22 @@ docs.accounting.navigation       # "display all results" rows — how a long sec
 docs.accounting.unmapped_headers # columns the site serves that map to no field
 docs.accounting.has_losses       # the one flag worth branching on
 docs.accounting.by_category      # the same tally per DocumentCategory
+docs.accounting.failed_codes     # report-code searches that failed while their siblings succeeded
+docs.accounting.by_category["financial_statement"].unlinked_hrefs   # a capped sample of the URLs
+                                                                    # behind no_link, for reporting
 ```
 
+> ⚠️ **After a call that returned normally, check `has_losses` before treating the result as
+> complete.** Since 0.23.0 one failing report code no longer takes the whole call down with it —
+> its siblings keep their documents and the failure is recorded on `failed_codes` (and logged at
+> WARNING). An exception is therefore no longer how a partial failure announces itself.
+> `repr(docs)` and `summary()` both state it.
+
+> ⚠️ **Read the accounting off the object `fetch_documents` returned.** `SecDocumentList` is a
+> `list` subclass, so slicing, `sorted()`, `list()`, concatenation and comprehensions return a
+> plain `list` and drop `.accounting` / `.reported_counts` — the same sharp edge `DownloadResult`
+> has (issue #134 covers both). `copy.copy()` and `.filter()` are the exceptions.
+
 The three drop reasons used to share one counter, so the only one that is a defect looked exactly
 like the two that are the site working normally. They are separated because `no_link` is the signal
 worth escalating and the other two must never be able to trigger it.
@@ -147,6 +161,9 @@ carries data rows and **none** of them can be classified — the signature of a
 An issuer with no filings still returns an empty list and does **not** raise: the check keys on
 unrecognised section headings, not on emptiness.
 
+`HTTPStatusError` (a subclass of `FetchError`) is raised for a non-2xx on any listing leg, carrying
+`status_code`, `url` and `report_code` as data rather than as message text.
+
 `IncompleteListingError` (a subclass of `ParseError`) is its sibling: rows classified fine and
 then **every** usable one was dropped for want of a download link. Deliberately
 narrow — a *partial* loss does not raise, it warns and lands on `accounting.no_link`, because a

{settfex-0.22.2 → settfex-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "settfex"
-version = "0.22.2"
+version = "0.23.0"
 description = "Async Python library for fetching real-time and historical data from the Stock Exchange of Thailand (SET) and Thailand Futures Exchange (TFEX)"
 readme = "README.md"
 requires-python = ">=3.11"

{settfex-0.22.2 → settfex-0.23.0}/settfex/__init__.py

@@ -35,7 +35,7 @@ Usage:
     >>> asyncio.run(main())
 """
 
-__version__ = "0.22.2"
+__version__ = "0.23.0"
 __author__ = "batt"
 __license__ = "MIT"
 

{settfex-0.22.2 → settfex-0.23.0}/settfex/exceptions.py

@@ -26,6 +26,7 @@ __all__ = [
     "StaleDataError",
     "ParseError",
     "IncompleteListingError",
+    "HTTPStatusError",
     "InvalidSymbolError",
     "InvalidLanguageError",
     "InvalidDateError",
@@ -160,6 +161,11 @@ class IncompleteListingError(ParseError):
     ``lost_rows`` is how many rows were dropped that way; ``reported`` is what the page said each
     section holds. Subclasses :class:`ParseError`, so ``except ParseError`` and
     ``except FetchError`` handlers keep working.
+
+    ``unknown_sections`` is inherited from :class:`ParseError` and, until 0.23.0, this subclass had
+    no way to accept it — so it was **always** ``[]`` here, a field that looked answered and was
+    not. A page can lose every row to a missing download link *and* carry a heading nobody
+    recognises, and that combination is worth seeing.
     """
 
     def __init__(
@@ -168,14 +174,48 @@ class IncompleteListingError(ParseError):
         *,
         url: str | None = None,
         rows_parsed: int | None = None,
+        unknown_sections: list[str] | None = None,
         lost_rows: int | None = None,
         reported: dict[str, int] | None = None,
     ) -> None:
-        super().__init__(message, url=url, rows_parsed=rows_parsed)
+        super().__init__(
+            message, url=url, rows_parsed=rows_parsed, unknown_sections=unknown_sections
+        )
         self.lost_rows = lost_rows
         self.reported = dict(reported or {})
 
 
+class HTTPStatusError(FetchError):
+    """A request returned a non-2xx status, with the context needed to act on it.
+
+    :class:`FetchError` already carries ``status_code``, so this adds no new *capability* — what it
+    adds is a place for the two facts a caller otherwise has to scrape out of the message string:
+    which URL, and which report code. An archive recording "the R562 search failed" should not have
+    to parse prose to do it, which is the same failure mode this family of fixes keeps closing.
+
+    Deliberately **not** raised via ``raise_for_status``: that helper maps 404 to
+    :class:`SymbolNotFoundError` and consults the symbol suggester, which is wrong on an endpoint
+    where the identifier was already resolved — a 404 there means the route or the host is wrong,
+    not that an issuer does not exist. (The same reasoning gives the DR-profile and
+    analyst-consensus endpoints their own handling; see CLAUDE.md's Known Gotchas.)
+
+    Subclasses :class:`FetchError`, so ``except FetchError`` keeps working.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        url: str | None = None,
+        report_code: str | None = None,
+        symbol: str | None = None,
+    ) -> None:
+        super().__init__(message, status_code=status_code, symbol=symbol)
+        self.url = url
+        self.report_code = report_code
+
+
 class InvalidSymbolError(ValueError):
     """A symbol was empty or invalid."""
 

{settfex-0.22.2 → settfex-0.23.0}/settfex/services/sec/__init__.py

@@ -19,6 +19,7 @@ from settfex.services.sec.download import (
 )
 from settfex.services.sec.financial_report import (
     CATEGORY_TO_REPORT_TYPE,
+    CodeFailure,
     DocumentCategory,
     FinancialReportService,
     ListingAccounting,
@@ -33,6 +34,7 @@ from settfex.services.sec.sec import SecCompany
 
 __all__ = [
     "CATEGORY_TO_REPORT_TYPE",
+    "CodeFailure",
     "CompanyMatch",
     "DocumentCategory",
     "DocumentDownloadService",