invinite-data-api 0.4.0__tar.gz → 0.5.0__tar.gz

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invinite_data_api
-Version: 0.4.0
+Version: 0.5.0
 Summary: Typed Python client for the Invinite Data API
 Home-page: 
 Author: OpenAPI Generator community

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 # Define package exports
 __all__ = [

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/api/earnings_calls_api.py

@@ -2353,8 +2353,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_document_search(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's documents (ticker or CIK, US only)")] = None,
         kind: Annotated[Optional[List[StrictStr]], Field(description="Only these document kinds, comma-separated or repeated: annual_report, ceo_letter, proxy_statement, proxy_supplement, esg_report, conference_presentation, investor_day_deck, earnings_deck, fact_sheet, financial_data, shareholder_letter, company_transcript, cfo_commentary, governance, press_release, infographic, webcast, other, prepared_remarks, sec_filing")] = None,
@@ -2377,11 +2377,11 @@ class EarningsCallsApi:
     ) -> EarningsCallsDocumentSearch200Response:
         """Search investor documents
 
-        Search the page text of investor documents by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
+        Search the page text of investor documents by keywords (default `mode=lexical`) or exact text (`literal`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; every word must match; ranked by `ts_rank_cd` (`websearch_to_tsquery`). Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -2440,7 +2440,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }
@@ -2458,8 +2457,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_document_search_with_http_info(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's documents (ticker or CIK, US only)")] = None,
         kind: Annotated[Optional[List[StrictStr]], Field(description="Only these document kinds, comma-separated or repeated: annual_report, ceo_letter, proxy_statement, proxy_supplement, esg_report, conference_presentation, investor_day_deck, earnings_deck, fact_sheet, financial_data, shareholder_letter, company_transcript, cfo_commentary, governance, press_release, infographic, webcast, other, prepared_remarks, sec_filing")] = None,
@@ -2482,11 +2481,11 @@ class EarningsCallsApi:
     ) -> ApiResponse[EarningsCallsDocumentSearch200Response]:
         """Search investor documents
 
-        Search the page text of investor documents by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
+        Search the page text of investor documents by keywords (default `mode=lexical`) or exact text (`literal`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; every word must match; ranked by `ts_rank_cd` (`websearch_to_tsquery`). Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -2545,7 +2544,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }
@@ -2563,8 +2561,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_document_search_without_preload_content(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's documents (ticker or CIK, US only)")] = None,
         kind: Annotated[Optional[List[StrictStr]], Field(description="Only these document kinds, comma-separated or repeated: annual_report, ceo_letter, proxy_statement, proxy_supplement, esg_report, conference_presentation, investor_day_deck, earnings_deck, fact_sheet, financial_data, shareholder_letter, company_transcript, cfo_commentary, governance, press_release, infographic, webcast, other, prepared_remarks, sec_filing")] = None,
@@ -2587,11 +2585,11 @@ class EarningsCallsApi:
     ) -> RESTResponseType:
         """Search investor documents
 
-        Search the page text of investor documents by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
+        Search the page text of investor documents by keywords (default `mode=lexical`) or exact text (`literal`): the documents of earnings calls (CFO commentary, shareholder letters, data sheets, the company's own transcripts) and companies' IR libraries (annual reports, proxy statements, ESG reports, investor-day decks).  ### What you get  - Up to 20 passages from company-published documents, with page numbers — not verified facts — and a signed URL of the file (open it at `#page=<page>`).  - Filter by company (`identifier`), kind, IR section, year or table.  - Each hit names the document's folder of the company's document tree (`group`, e.g. `earnings/fy2027/q2`, `group_label`, `category`), how it matched (`match`); the response says how much of the searched documents is indexed (`coverage`).  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; every word must match; ranked by `ts_rank_cd` (`websearch_to_tsquery`). Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for display: FREE.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -2650,7 +2648,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }
@@ -7991,8 +7988,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_search(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         event_id: Annotated[Optional[UUID], Field(description="Search one call")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's calls (ticker or CIK, US only)")] = None,
@@ -8016,11 +8013,11 @@ class EarningsCallsApi:
     ) -> EarningsCallsSearch200Response:
         """Search earnings calls
 
-        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
+        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`) or exact text (`literal`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; scoped by `identifier` or `event_id`, a passage needs any of the words, ranked by BM25 (rarer words weigh more), and the answer to a matching analyst question follows right after it (its `match.spans` may be empty); without a scope every word must match, ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -8082,7 +8079,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }
@@ -8100,8 +8096,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_search_with_http_info(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         event_id: Annotated[Optional[UUID], Field(description="Search one call")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's calls (ticker or CIK, US only)")] = None,
@@ -8125,11 +8121,11 @@ class EarningsCallsApi:
     ) -> ApiResponse[EarningsCallsSearch200Response]:
         """Search earnings calls
 
-        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
+        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`) or exact text (`literal`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; scoped by `identifier` or `event_id`, a passage needs any of the words, ranked by BM25 (rarer words weigh more), and the answer to a matching analyst question follows right after it (its `match.spans` may be empty); without a scope every word must match, ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -8191,7 +8187,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }
@@ -8209,8 +8204,8 @@ class EarningsCallsApi:
     @validate_call
     def earnings_calls_search_without_preload_content(
         self,
-        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for")],
-        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)")] = None,
+        q: Annotated[str, Field(min_length=2, strict=True, max_length=500, description="The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for")],
+        mode: Annotated[Optional[StrictStr], Field(description="lexical (keywords and phrases, default) or literal (exact characters)")] = None,
         case_sensitive: Annotated[Optional[StrictStr], Field(description="mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)")] = None,
         event_id: Annotated[Optional[UUID], Field(description="Search one call")] = None,
         identifier: Annotated[Optional[StrictStr], Field(description="Search one company's calls (ticker or CIK, US only)")] = None,
@@ -8234,11 +8229,11 @@ class EarningsCallsApi:
     ) -> RESTResponseType:
         """Search earnings calls
 
-        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`), exact text (`literal`), meaning (`semantic`) or both (`hybrid`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work (`websearch_to_tsquery`); ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `semantic`: meaning-based search (multilingual sentence embeddings); `score` is the cosine similarity.  - `hybrid`: `lexical` and `semantic` fused by reciprocal rank (`score = Σ 1 / (60 + rank)`, equal weights, ties by passage); `match.lexical_rank` / `match.semantic_rank` give each leg's rank. Best for natural-language questions.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`). Semantic matches carry no spans. An exact mode never expands into semantic or fuzzy results. Every mode costs the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed, or a hybrid leg was unavailable) or `unknown` (a mode's index is not built for the searched scope, e.g. `semantic_index_missing`) — read it before treating an empty list as \"not found\".  - `coverage.lexical` / `coverage.semantic` count the searched transcripts or documents per index (`indexed`, `pending`, `failed`); null for a leg the mode did not use. `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, both legs null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`; pass `mode=semantic` for the previous behaviour (or `mode=hybrid` for natural-language questions).  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `429 upstream_rate_limited` and `503 search_unavailable` carry `Retry-After` (`503` also when a keyword search runs over its time limit — never an empty answer).  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
+        \"Ask this call\": search earnings-call transcripts and slide text by keywords (default `mode=lexical`) or exact text (`literal`) — one call (`event_id`), one company (`identifier`) or every call (default: the last 365 days).  ### What you get  - Up to 8 passages with speaker and `start_ms`, how each matched (`match`) and the index coverage of the search (`coverage`). Cite `event_id` and `start_ms`.  - On plans that include the audio and slides routes (PRO): `audio_url` opens the recording's permanent URL at the passage (`#t=<seconds>`; null while no recording is available) and `slide.image_url` (a signed URL) shows the slide.  ### Event types  - `event_type` (default `earnings_call`; `all` = every type) selects investor days, conferences or shareholder meetings too.  ### Search modes  - `lexical` (default): keyword search — English full text with stemming; quoted phrases, `OR` and `-word` work; scoped by `identifier` or `event_id`, a passage needs any of the words, ranked by BM25 (rarer words weigh more), and the answer to a matching analyst question follows right after it (its `match.spans` may be empty); without a scope every word must match, ranked by `ts_rank_cd`. Finance tokens such as `FY2027`, `10-K`, `Q3` or `EBITDA` match as written.  - `literal`: the exact characters of the passage — no stemming, no fuzzy matching, `%` / `_` / `\\` match themselves; case-sensitive unless `case_sensitive=false` (only allowed with `mode=literal`; default `true`). A pattern under 3 characters needs `identifier` or `event_id`. Newest first; `score` is 0.  - `match.spans` mark the matched characters in `text` (zero-based, end-exclusive Unicode code-point offsets); `text` is cut around the first match (`text_truncated`); `match.lexical_rank` is the hit's 1-based rank. Neither mode expands into fuzzy results. Both modes cost the same.  ### Coverage  - `coverage.completeness` = `complete` (every searched passage is indexed: no hits is a genuine no-result), `partial` (some passages are still being indexed or failed) or `unknown` (nothing of the searched scope is indexed yet, or the counts could not be read) — read it before treating an empty list as \"not found\".  - `coverage.lexical` counts the searched transcripts or documents in the text index (`indexed`, `pending`, `failed`). `reasons` lists why the answer may be incomplete. The counts come from the indexing ledger: a transcript or document whose current version the index has not confirmed counts as `pending`; when they cannot be read, the hits are still returned with `completeness: unknown`, `lexical` null and `coverage_unavailable`.  ### Changelog  - 2026-10: modes added and the default mode changed from semantic to `lexical`.  - 2026-11: modes `semantic` and `hybrid` removed; vector search is gone, pass `mode=lexical` (default) or `literal`.  ### Errors  - `400` for a `mode=lexical` query of stopwords only (no searchable words), for `case_sensitive` with any mode but `literal`, and for a `mode=literal` pattern under 3 characters without a scope (see Search modes).  - `503 search_unavailable` (a search over its time limit — never an empty answer) carries `Retry-After`.  - `503 search_disabled` while search is switched off.  ### Freshness and coverage  - Data is replicated from the capture pipeline with a lag of about a minute.  - Only US earnings calls captured by Invinite are served.  Minimum tier for rag: STANDARD.
 
-        :param q: The keywords, exact text (mode=literal) or question (semantic / hybrid) to search for (required)
+        :param q: The keywords or phrases (mode=lexical) or exact text (mode=literal) to search for (required)
         :type q: str
-        :param mode: lexical (keywords, default), literal (exact characters), semantic (meaning) or hybrid (lexical + semantic, fused)
+        :param mode: lexical (keywords and phrases, default) or literal (exact characters)
         :type mode: str
         :param case_sensitive: mode=literal only: \"false\" matches regardless of case (default \"true\": case-sensitive)
         :type case_sensitive: str
@@ -8300,7 +8295,6 @@ class EarningsCallsApi:
             '400': "CompanyAvailableCompanies401Response",
             '401': "CompanyAvailableCompanies401Response",
             '404': "CompanyAvailableCompanies401Response",
-            '429': "CompanyAvailableCompanies401Response",
             '500': "CompanyAvailableCompanies401Response",
             '503': "CompanyAvailableCompanies401Response",
         }

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/0.4.0/python'
+        self.user_agent = 'OpenAPI-Generator/0.5.0/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/configuration.py

@@ -533,7 +533,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 1.0.0\n"\
-               "SDK Package Version: 0.4.0".\
+               "SDK Package Version: 0.5.0".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/earnings_calls_document_search200_response.py

@@ -38,8 +38,8 @@ class EarningsCallsDocumentSearch200Response(BaseModel):
     @field_validator('mode')
     def mode_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['lexical', 'literal', 'semantic', 'hybrid']):
-            raise ValueError("must be one of enum values ('lexical', 'literal', 'semantic', 'hybrid')")
+        if value not in set(['lexical', 'literal']):
+            raise ValueError("must be one of enum values ('lexical', 'literal')")
         return value
 
     model_config = ConfigDict(

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/earnings_calls_document_search200_response_hits_inner.py

@@ -30,7 +30,7 @@ class EarningsCallsDocumentSearch200ResponseHitsInner(BaseModel):
     """
     EarningsCallsDocumentSearch200ResponseHitsInner
     """ # noqa: E501
-    score: Union[StrictFloat, StrictInt] = Field(description="Relevance per mode: lexical = ts_rank_cd (4 decimals), literal = 0 (hits are ordered newest year first), semantic = cosine similarity (4 decimals), hybrid = reciprocal-rank-fusion score (6 decimals)")
+    score: Union[StrictFloat, StrictInt] = Field(description="Relevance per mode: lexical = ts_rank_cd (4 decimals), literal = 0 (hits are ordered newest year first)")
     match: HitMatch
     document_id: UUID = Field(description="Document identifier (company_documents: /v1/earnings-calls/company-documents/{document_id})")
     table: StrictStr = Field(description="Which document table the passage is from")

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/earnings_calls_search200_response.py

@@ -38,8 +38,8 @@ class EarningsCallsSearch200Response(BaseModel):
     @field_validator('mode')
     def mode_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['lexical', 'literal', 'semantic', 'hybrid']):
-            raise ValueError("must be one of enum values ('lexical', 'literal', 'semantic', 'hybrid')")
+        if value not in set(['lexical', 'literal']):
+            raise ValueError("must be one of enum values ('lexical', 'literal')")
         return value
 
     model_config = ConfigDict(

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/earnings_calls_search200_response_hits_inner.py

@@ -45,7 +45,7 @@ class EarningsCallsSearch200ResponseHitsInner(BaseModel):
     chunk_index: Optional[StrictInt] = Field(description="Position of the passage among the call's transcript (or slide) passages; null for a passage indexed before positions were stored")
     text: StrictStr = Field(description="The passage, cut to at most 600 characters on word boundaries around the first match")
     text_truncated: StrictBool = Field(description="true = text is shorter than the passage")
-    score: Union[StrictFloat, StrictInt] = Field(description="Relevance per mode: lexical = ts_rank_cd (4 decimals), literal = 0 (hits are ordered newest call first), semantic = cosine similarity (4 decimals), hybrid = reciprocal-rank-fusion score (6 decimals)")
+    score: Union[StrictFloat, StrictInt] = Field(description="Relevance per mode: lexical = BM25 with `identifier` / `event_id` (an answer attached to its question scores 0.99 × the question), else ts_rank_cd (4 decimals), literal = 0 (hits are ordered newest call first)")
     match: HitMatch
     audio_url: Optional[StrictStr] = Field(description="The recording's permanent URL opening at the passage (#t=<seconds>); null without the PRO plan, without a servable recording, without start_ms or for an audio opt-out.")
     slide: Optional[EarningsCallsSearch200ResponseHitsInnerSlide]

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/hit_match.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List
 from invinite_data_api.models.match_span import MatchSpan
 from typing import Optional, Set
 from typing_extensions import Self
@@ -28,17 +28,16 @@ class HitMatch(BaseModel):
     """
     How the passage matched
     """ # noqa: E501
-    type: StrictStr = Field(description="The leg that found the passage; hybrid = both legs of mode=hybrid")
-    lexical_rank: Optional[StrictInt] = Field(description="1-based rank in the keyword leg (lexical / literal); null when it did not find it")
-    semantic_rank: Optional[StrictInt] = Field(description="1-based rank in the semantic leg; null when it did not find it")
-    spans: List[MatchSpan] = Field(description="Matched characters in `text`; empty for semantic matches")
-    __properties: ClassVar[List[str]] = ["type", "lexical_rank", "semantic_rank", "spans"]
+    type: StrictStr = Field(description="The mode that found the passage")
+    lexical_rank: StrictInt = Field(description="1-based rank of the passage in the answer")
+    spans: List[MatchSpan] = Field(description="Matched characters in `text`; empty for an answer attached after its matched question (scoped lexical transcript search)")
+    __properties: ClassVar[List[str]] = ["type", "lexical_rank", "spans"]
 
     @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['lexical', 'literal', 'semantic', 'hybrid']):
-            raise ValueError("must be one of enum values ('lexical', 'literal', 'semantic', 'hybrid')")
+        if value not in set(['lexical', 'literal']):
+            raise ValueError("must be one of enum values ('lexical', 'literal')")
         return value
 
     model_config = ConfigDict(
@@ -87,16 +86,6 @@ class HitMatch(BaseModel):
                 if _item_spans:
                     _items.append(_item_spans.to_dict())
             _dict['spans'] = _items
-        # set to None if lexical_rank (nullable) is None
-        # and model_fields_set contains the field
-        if self.lexical_rank is None and "lexical_rank" in self.model_fields_set:
-            _dict['lexical_rank'] = None
-
-        # set to None if semantic_rank (nullable) is None
-        # and model_fields_set contains the field
-        if self.semantic_rank is None and "semantic_rank" in self.model_fields_set:
-            _dict['semantic_rank'] = None
-
         return _dict
 
     @classmethod
@@ -111,7 +100,6 @@ class HitMatch(BaseModel):
         _obj = cls.model_validate({
             "type": obj.get("type"),
             "lexical_rank": obj.get("lexical_rank"),
-            "semantic_rank": obj.get("semantic_rank"),
             "spans": [MatchSpan.from_dict(_item) for _item in obj["spans"]] if obj.get("spans") is not None else None
         })
         return _obj

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/search_coverage.py

@@ -26,13 +26,12 @@ from pydantic_core import to_jsonable_python
 
 class SearchCoverage(BaseModel):
     """
-    How much of the searched scope the mode's indexes cover
+    How much of the searched scope the text index covers
     """ # noqa: E501
     completeness: StrictStr = Field(description="complete = no hits is a genuine no-result; partial / unknown = the answer may be incomplete")
     lexical: Optional[SearchCoverageLeg]
-    semantic: Optional[SearchCoverageLeg]
     reasons: List[StrictStr] = Field(description="Why the answer may be incomplete")
-    __properties: ClassVar[List[str]] = ["completeness", "lexical", "semantic", "reasons"]
+    __properties: ClassVar[List[str]] = ["completeness", "lexical", "reasons"]
 
     @field_validator('completeness')
     def completeness_validate_enum(cls, value):
@@ -45,8 +44,8 @@ class SearchCoverage(BaseModel):
     def reasons_validate_enum(cls, value):
         """Validates the enum"""
         for i in value:
-            if i not in set(['lexical_backfill_pending', 'projection_failed', 'semantic_index_missing', 'semantic_backfill_pending', 'lexical_unavailable', 'semantic_unavailable', 'coverage_unavailable']):
-                raise ValueError("each list item must be one of ('lexical_backfill_pending', 'projection_failed', 'semantic_index_missing', 'semantic_backfill_pending', 'lexical_unavailable', 'semantic_unavailable', 'coverage_unavailable')")
+            if i not in set(['lexical_backfill_pending', 'projection_failed', 'coverage_unavailable']):
+                raise ValueError("each list item must be one of ('lexical_backfill_pending', 'projection_failed', 'coverage_unavailable')")
         return value
 
     model_config = ConfigDict(
@@ -91,19 +90,11 @@ class SearchCoverage(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of lexical
         if self.lexical:
             _dict['lexical'] = self.lexical.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of semantic
-        if self.semantic:
-            _dict['semantic'] = self.semantic.to_dict()
         # set to None if lexical (nullable) is None
         # and model_fields_set contains the field
         if self.lexical is None and "lexical" in self.model_fields_set:
             _dict['lexical'] = None
 
-        # set to None if semantic (nullable) is None
-        # and model_fields_set contains the field
-        if self.semantic is None and "semantic" in self.model_fields_set:
-            _dict['semantic'] = None
-
         return _dict
 
     @classmethod
@@ -118,7 +109,6 @@ class SearchCoverage(BaseModel):
         _obj = cls.model_validate({
             "completeness": obj.get("completeness"),
             "lexical": SearchCoverageLeg.from_dict(obj["lexical"]) if obj.get("lexical") is not None else None,
-            "semantic": SearchCoverageLeg.from_dict(obj["semantic"]) if obj.get("semantic") is not None else None,
             "reasons": obj.get("reasons")
         })
         return _obj

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api/models/search_coverage_leg.py

@@ -25,7 +25,7 @@ from pydantic_core import to_jsonable_python
 
 class SearchCoverageLeg(BaseModel):
     """
-    The keyword index (lexical / literal / hybrid); null when the mode did not use it
+    The text index (lexical and literal); null when the counts could not be read
     """ # noqa: E501
     state: StrictStr = Field(description="ready = nothing outstanding; partial = some owners outstanding; not_ready = nothing indexed")
     indexed: StrictInt = Field(description="Transcripts / documents of the scope searchable in this index")

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/invinite_data_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invinite_data_api
-Version: 0.4.0
+Version: 0.5.0
 Summary: Typed Python client for the Invinite Data API
 Home-page: 
 Author: OpenAPI Generator community

{invinite_data_api-0.4.0 → invinite_data_api-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "invinite_data_api"
-version = "0.4.0"
+version = "0.5.0"
 description = "Typed Python client for the Invinite Data API"
 authors = [
   {name = "OpenAPI Generator Community",email = "team@openapitools.org"},