arkleon 0.1.0__tar.gz

arkleon-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

arkleon-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arkleon LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arkleon-0.1.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.5
+Name: arkleon
+Version: 0.1.0
+Summary: Point-in-time SEC EDGAR fundamentals: free fetch/parse helpers, an optional certified /v1 client, and a built-in MCP server.
+Project-URL: Homepage, https://github.com/arkleon/arkleon
+Project-URL: Repository, https://github.com/arkleon/arkleon
+Project-URL: SEC fair access, https://www.sec.gov/os/accessing-edgar-data
+Author-email: Arkleon LLC <founder@arkleon.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 10-K,10-Q,as-reported,edgar,filings,financial-data,financial-statement-data-sets,fundamentals,mcp,point-in-time,sec,xbrl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Provides-Extra: all
+Requires-Dist: httpx>=0.27; extra == 'all'
+Requires-Dist: mcp>=1.9; extra == 'all'
+Requires-Dist: pandas>=2.0; extra == 'all'
+Provides-Extra: api
+Requires-Dist: httpx>=0.27; extra == 'api'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.9; extra == 'mcp'
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0; extra == 'pandas'
+Description-Content-Type: text/markdown
+
+# arkleon
+
+Point-in-time SEC EDGAR fundamentals: free EDGAR fetch/parse helpers with zero
+credentials, plus an optional certified `/v1` client and a built-in MCP server.
+
+The free EDGAR core requires no account and no API key. The optional paid `/v1`
+client and the corpus-backed point-in-time features are the only parts that need
+a key.
+
+## Install
+
+```bash
+pip install arkleon
+```
+
+## Quickstart: free, no API key
+
+The EDGAR helpers work on the first line of code with no Arkleon account and no
+key. The only string they require is an SEC fair-access `User-Agent`, which you
+write yourself.
+
+```python
+from arkleon.edgar import EdgarClient
+
+# SEC fair-access User-Agent: a self-declared contact string, NOT an Arkleon key.
+edgar = EdgarClient(user_agent="Acme Research contact@acme.com")
+
+# Fetch a company's 10-K filings by CIK (Apple = 320193):
+for filing in edgar.filings(cik=320193, form="10-K"):
+    print(filing.filed, filing.accession, filing.form)
+
+# Parse as-reported numeric facts, filtered best-effort to a date:
+assets = edgar.concept(cik=320193, tag="Assets", taxonomy="us-gaap")
+for fact in assets.as_of("2020-01-01"):        # keep only filed <= 2020-01-01
+    print(fact.period_end, fact.value, fact.unit, fact.filed)
+```
+
+*No account, no key, no Arkleon network. Live-EDGAR, best-effort point-in-time.*
+
+## Quickstart: optional paid `/v1` client (certified point-in-time)
+
+```python
+# pip install "arkleon[api]"
+from arkleon.api import DataClient
+
+client = DataClient(api_key="ak_...")          # or ARKLEON_API_KEY env
+page = client.facts(cik=320193, tag="Assets", as_of="2020-01-01")
+for fact in page.data:
+    print(fact["period_end"], fact["value"], fact.get("source_url"))
+```
+
+*Certified corpus. `as_of` required, filters on filing date, identical query +
+`as_of` returns identical data permanently.*
+
+## The free/paid boundary
+
+The `arkleon.edgar` helpers never require a key and never contact Arkleon: their
+only remote hosts are `data.sec.gov` and `www.sec.gov`. Only the `arkleon[api]`
+client and the corpus-backed point-in-time features call Arkleon, and they refuse
+to operate without an `ak_`-prefixed key. Installing `arkleon[api]` does not by
+itself activate the paid path; a key must still be supplied at runtime.
+
+## MCP server
+
+Install the server extra and launch the stdio server with the console script:
+
+```bash
+pip install "arkleon[mcp]"
+arkleon-mcp
+```
+
+An agent host launches it the same way. Set `ARKLEON_API_KEY` in the launch
+environment to unlock the paid tools:
+
+```json
+{
+  "mcpServers": {
+    "arkleon": {
+      "command": "arkleon-mcp",
+      "env": { "ARKLEON_API_KEY": "ak_..." }
+    }
+  }
+}
+```
+
+The free EDGAR tools register **unconditionally**; the paid tools register **only
+when an `ak_` key is present**. An agent with no key sees exactly the free set.
+
+| Tool | Backed by | Key required? |
+|---|---|---|
+| `edgar_list_filings` | free EDGAR core | No |
+| `edgar_company_facts` | free EDGAR core | No |
+| `edgar_concept` | free EDGAR core | No |
+| `edgar_facts_as_of` (best-effort, live EDGAR) | free EDGAR core | No |
+| `edgar_resolve_cik` (current-snapshot, non-point-in-time) | free EDGAR core | No |
+| `pit_facts` (certified point-in-time) | paid `/v1` client | Yes |
+| `pit_filings` | paid `/v1` client | Yes |
+| `resolve_company` | paid `/v1` client | Yes |
+| `pit_revision_history` | paid `/v1` client | Yes |
+
+## What it returns, and what it does not
+
+**Returns:** as-reported numeric XBRL facts, filing and company metadata, and the
+lineage linking each figure to its source filing.
+
+**Does not return:** market prices, analyst estimates, narrative disclosure
+(MD&A, risk factors, footnotes), or derived analytics, ratios, scores, or
+signals. Neither layer serves these. It is a research corpus, not a real-time
+filing feed: the paid corpus refreshes on the SEC's quarterly cadence.
+
+## Point-in-time, in two sentences
+
+`as_of` filters on the **filing date** (`filed <= as_of`), never on the period a
+fact describes, so a query sees only values that were already public on that
+date. Because a fact from a later filing never appears, a historical query cannot
+observe information that did not yet exist, which is what keeps a study free of
+look-ahead bias.
+
+## The certified corpus (paid)
+
+The paid `/v1` client serves the certified corpus. Per
+`docs/data-layer/api-v1-contract.md` Appendix A, which is the sole authority for
+what any surface may state, the claimable figures are:
+
+| Quantity | Figure | Kind |
+|---|---|---|
+| Filings | 426,003 | EXACT |
+| Facts | 181,350,662 | EXACT |
+| Distinct companies (CIK) | 16,811 | EXACT |
+| Quarters spanned | 69 (2009q1–2026q1) | exact |
+| Quarters populated | 68 | exact |
+
+The EXACT/exact label travels with each number and is not presentational. These
+figures are keyed to the date each filing became public, include values that
+later filings revised, and trace to their source filing. The earliest filed date
+in the corpus is 2009-04-15, so a query with an `as_of` earlier than that date
+correctly returns empty. Treat the contract's Appendix A, not this table, as the
+authority: a later corpus revision updates the contract, and any figure that
+disagrees with it is stale.
+
+## Identifiers
+
+**CIK is the addressable identifier** across both layers. In the free layer,
+`resolve_cik(ticker)` maps a symbol to a CIK from SEC's current ticker snapshot;
+it is a convenience, not a reproducible identity resolver, because it has no
+ticker history, a symbol is reassigned over time, and one CIK carries several
+symbols at once (`GOOG` and `GOOGL`, `BRK.A` and `BRK.B`). The `/v1` API does not
+serve the `ticker` filter today: a `ticker` request returns a distinct
+"not served in this release" error rather than silently resolving through the
+free snapshot. Address facts by CIK.
+
+## Install matrix
+
+| Install | Adds |
+|---|---|
+| `arkleon` | The free EDGAR fetch/parse core. No key, no Arkleon network. |
+| `arkleon[api]` | The optional paid `/v1` `DataClient`. Requires an `ak_` key at runtime. |
+| `arkleon[mcp]` | The built-in MCP server and the `arkleon-mcp` console script. |
+| `arkleon[pandas]` | Optional pandas DataFrame adapters for the free core. Never required. |
+| `arkleon[all]` | Convenience union of `api`, `mcp`, and `pandas`. |
+
+Base plus `[pandas]` stays fully free and credential-free. `[api]` and the paid
+tools in `[mcp]` are the only parts that consume an `ak_` key.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- **`/v1` API contract:** `docs/data-layer/api-v1-contract.md` (Appendix A is the
+  authority for the corpus figures above).
+- **Issues and contributing:** https://github.com/arkleon/arkleon
+- **SEC fair-access policy:** https://www.sec.gov/os/accessing-edgar-data

arkleon-0.1.0/README.md

@@ -0,0 +1,174 @@
+# arkleon
+
+Point-in-time SEC EDGAR fundamentals: free EDGAR fetch/parse helpers with zero
+credentials, plus an optional certified `/v1` client and a built-in MCP server.
+
+The free EDGAR core requires no account and no API key. The optional paid `/v1`
+client and the corpus-backed point-in-time features are the only parts that need
+a key.
+
+## Install
+
+```bash
+pip install arkleon
+```
+
+## Quickstart: free, no API key
+
+The EDGAR helpers work on the first line of code with no Arkleon account and no
+key. The only string they require is an SEC fair-access `User-Agent`, which you
+write yourself.
+
+```python
+from arkleon.edgar import EdgarClient
+
+# SEC fair-access User-Agent: a self-declared contact string, NOT an Arkleon key.
+edgar = EdgarClient(user_agent="Acme Research contact@acme.com")
+
+# Fetch a company's 10-K filings by CIK (Apple = 320193):
+for filing in edgar.filings(cik=320193, form="10-K"):
+    print(filing.filed, filing.accession, filing.form)
+
+# Parse as-reported numeric facts, filtered best-effort to a date:
+assets = edgar.concept(cik=320193, tag="Assets", taxonomy="us-gaap")
+for fact in assets.as_of("2020-01-01"):        # keep only filed <= 2020-01-01
+    print(fact.period_end, fact.value, fact.unit, fact.filed)
+```
+
+*No account, no key, no Arkleon network. Live-EDGAR, best-effort point-in-time.*
+
+## Quickstart: optional paid `/v1` client (certified point-in-time)
+
+```python
+# pip install "arkleon[api]"
+from arkleon.api import DataClient
+
+client = DataClient(api_key="ak_...")          # or ARKLEON_API_KEY env
+page = client.facts(cik=320193, tag="Assets", as_of="2020-01-01")
+for fact in page.data:
+    print(fact["period_end"], fact["value"], fact.get("source_url"))
+```
+
+*Certified corpus. `as_of` required, filters on filing date, identical query +
+`as_of` returns identical data permanently.*
+
+## The free/paid boundary
+
+The `arkleon.edgar` helpers never require a key and never contact Arkleon: their
+only remote hosts are `data.sec.gov` and `www.sec.gov`. Only the `arkleon[api]`
+client and the corpus-backed point-in-time features call Arkleon, and they refuse
+to operate without an `ak_`-prefixed key. Installing `arkleon[api]` does not by
+itself activate the paid path; a key must still be supplied at runtime.
+
+## MCP server
+
+Install the server extra and launch the stdio server with the console script:
+
+```bash
+pip install "arkleon[mcp]"
+arkleon-mcp
+```
+
+An agent host launches it the same way. Set `ARKLEON_API_KEY` in the launch
+environment to unlock the paid tools:
+
+```json
+{
+  "mcpServers": {
+    "arkleon": {
+      "command": "arkleon-mcp",
+      "env": { "ARKLEON_API_KEY": "ak_..." }
+    }
+  }
+}
+```
+
+The free EDGAR tools register **unconditionally**; the paid tools register **only
+when an `ak_` key is present**. An agent with no key sees exactly the free set.
+
+| Tool | Backed by | Key required? |
+|---|---|---|
+| `edgar_list_filings` | free EDGAR core | No |
+| `edgar_company_facts` | free EDGAR core | No |
+| `edgar_concept` | free EDGAR core | No |
+| `edgar_facts_as_of` (best-effort, live EDGAR) | free EDGAR core | No |
+| `edgar_resolve_cik` (current-snapshot, non-point-in-time) | free EDGAR core | No |
+| `pit_facts` (certified point-in-time) | paid `/v1` client | Yes |
+| `pit_filings` | paid `/v1` client | Yes |
+| `resolve_company` | paid `/v1` client | Yes |
+| `pit_revision_history` | paid `/v1` client | Yes |
+
+## What it returns, and what it does not
+
+**Returns:** as-reported numeric XBRL facts, filing and company metadata, and the
+lineage linking each figure to its source filing.
+
+**Does not return:** market prices, analyst estimates, narrative disclosure
+(MD&A, risk factors, footnotes), or derived analytics, ratios, scores, or
+signals. Neither layer serves these. It is a research corpus, not a real-time
+filing feed: the paid corpus refreshes on the SEC's quarterly cadence.
+
+## Point-in-time, in two sentences
+
+`as_of` filters on the **filing date** (`filed <= as_of`), never on the period a
+fact describes, so a query sees only values that were already public on that
+date. Because a fact from a later filing never appears, a historical query cannot
+observe information that did not yet exist, which is what keeps a study free of
+look-ahead bias.
+
+## The certified corpus (paid)
+
+The paid `/v1` client serves the certified corpus. Per
+`docs/data-layer/api-v1-contract.md` Appendix A, which is the sole authority for
+what any surface may state, the claimable figures are:
+
+| Quantity | Figure | Kind |
+|---|---|---|
+| Filings | 426,003 | EXACT |
+| Facts | 181,350,662 | EXACT |
+| Distinct companies (CIK) | 16,811 | EXACT |
+| Quarters spanned | 69 (2009q1–2026q1) | exact |
+| Quarters populated | 68 | exact |
+
+The EXACT/exact label travels with each number and is not presentational. These
+figures are keyed to the date each filing became public, include values that
+later filings revised, and trace to their source filing. The earliest filed date
+in the corpus is 2009-04-15, so a query with an `as_of` earlier than that date
+correctly returns empty. Treat the contract's Appendix A, not this table, as the
+authority: a later corpus revision updates the contract, and any figure that
+disagrees with it is stale.
+
+## Identifiers
+
+**CIK is the addressable identifier** across both layers. In the free layer,
+`resolve_cik(ticker)` maps a symbol to a CIK from SEC's current ticker snapshot;
+it is a convenience, not a reproducible identity resolver, because it has no
+ticker history, a symbol is reassigned over time, and one CIK carries several
+symbols at once (`GOOG` and `GOOGL`, `BRK.A` and `BRK.B`). The `/v1` API does not
+serve the `ticker` filter today: a `ticker` request returns a distinct
+"not served in this release" error rather than silently resolving through the
+free snapshot. Address facts by CIK.
+
+## Install matrix
+
+| Install | Adds |
+|---|---|
+| `arkleon` | The free EDGAR fetch/parse core. No key, no Arkleon network. |
+| `arkleon[api]` | The optional paid `/v1` `DataClient`. Requires an `ak_` key at runtime. |
+| `arkleon[mcp]` | The built-in MCP server and the `arkleon-mcp` console script. |
+| `arkleon[pandas]` | Optional pandas DataFrame adapters for the free core. Never required. |
+| `arkleon[all]` | Convenience union of `api`, `mcp`, and `pandas`. |
+
+Base plus `[pandas]` stays fully free and credential-free. `[api]` and the paid
+tools in `[mcp]` are the only parts that consume an `ak_` key.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- **`/v1` API contract:** `docs/data-layer/api-v1-contract.md` (Appendix A is the
+  authority for the corpus figures above).
+- **Issues and contributing:** https://github.com/arkleon/arkleon
+- **SEC fair-access policy:** https://www.sec.gov/os/accessing-edgar-data

arkleon-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "arkleon"
+version = "0.1.0"
+description = "Point-in-time SEC EDGAR fundamentals: free fetch/parse helpers, an optional certified /v1 client, and a built-in MCP server."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Arkleon LLC", email = "founder@arkleon.com" }]
+keywords = [
+    "sec",
+    "edgar",
+    "xbrl",
+    "fundamentals",
+    "point-in-time",
+    "as-reported",
+    "financial-data",
+    "filings",
+    "10-K",
+    "10-Q",
+    "mcp",
+    "financial-statement-data-sets",
+]
+dependencies = ["httpx>=0.27"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Office/Business :: Financial",
+]
+
+[project.optional-dependencies]
+api = ["httpx>=0.27"]
+mcp = ["mcp>=1.9"]
+pandas = ["pandas>=2.0"]
+all = ["httpx>=0.27", "mcp>=1.9", "pandas>=2.0"]
+
+[project.urls]
+Homepage = "https://github.com/arkleon/arkleon"
+Repository = "https://github.com/arkleon/arkleon"
+"SEC fair access" = "https://www.sec.gov/os/accessing-edgar-data"
+
+[project.scripts]
+arkleon-mcp = "arkleon.mcp.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/arkleon"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src/arkleon",
+    "/README.md",
+    "/LICENSE",
+]

arkleon-0.1.0/src/arkleon/__init__.py

@@ -0,0 +1,48 @@
+"""Free EDGAR core imported by default; api and mcp are optional extras."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .edgar import (
+    AS_OF_WARNING,
+    Company,
+    EdgarClient,
+    Fact,
+    FactSet,
+    Filing,
+    MissingUserAgentError,
+    RateLimiter,
+    as_of,
+    build_ticker_map,
+    cik_to_int,
+    facts_to_dataframe,
+    normalize_cik,
+    parse_company_concept,
+    parse_company_facts,
+    parse_fsds_zip,
+    parse_submissions,
+    resolve_user_agent,
+)
+
+__all__ = [
+    "AS_OF_WARNING",
+    "Company",
+    "EdgarClient",
+    "Fact",
+    "FactSet",
+    "Filing",
+    "MissingUserAgentError",
+    "RateLimiter",
+    "as_of",
+    "build_ticker_map",
+    "cik_to_int",
+    "facts_to_dataframe",
+    "normalize_cik",
+    "parse_company_concept",
+    "parse_company_facts",
+    "parse_fsds_zip",
+    "parse_submissions",
+    "resolve_user_agent",
+    "__version__",
+]

arkleon-0.1.0/src/arkleon/api/__init__.py

@@ -0,0 +1,49 @@
+"""Optional paid /v1 client for the Arkleon Data API.
+
+Component (b) of the arkleon package (spec section 6). This subpackage is
+always importable because its HTTP dependency (httpx) is a base dependency;
+there is no import gate. The paid gate is a RUNTIME requirement instead: the
+client refuses to construct without an ak_-prefixed key (contract section 6.2),
+resolved from the constructor argument or the ARKLEON_API_KEY environment
+variable.
+
+Nothing here activates without a key. Installing the client does not activate
+the paid path; a key must still be supplied at runtime.
+"""
+
+from __future__ import annotations
+
+from .client import DataClient
+from .errors import (
+    ArkleonAPIError,
+    AuthError,
+    ConflictError,
+    NotFoundError,
+    NotServedError,
+    RateLimitError,
+    RequestError,
+    ScopeError,
+    ServerError,
+    UnprocessableError,
+    error_from_envelope,
+)
+from .errors import NotImplementedError  # noqa: A004  (contract alias, spec section 6.5)
+from .pagination import Page
+
+__all__ = [
+    "DataClient",
+    "Page",
+    "error_from_envelope",
+    "ArkleonAPIError",
+    "AuthError",
+    "ScopeError",
+    "RequestError",
+    "NotFoundError",
+    "ConflictError",
+    "UnprocessableError",
+    "RateLimitError",
+    "NotServedError",
+    "ServerError",
+    # Alias exported per spec section 6.5; primary name is NotServedError.
+    "NotImplementedError",
+]

arkleon-0.1.0/src/arkleon/api/auth.py

@@ -0,0 +1,58 @@
+"""The paid gate: ak_ Bearer key resolution.
+
+The key is read from an explicit argument or, failing that, the
+``ARKLEON_API_KEY`` environment variable (contract section 6.2). The client
+refuses to operate without an ak_-prefixed key, raising locally before any
+network contact so an unauthenticated request is never sent. Keys are
+presented, never stored or logged: nothing here writes the key to a file, a
+log line, or an exception message.
+"""
+
+from __future__ import annotations
+
+import os
+
+from .errors import AuthError
+
+__all__ = ["resolve_api_key", "optional_api_key", "API_KEY_ENV_VAR", "API_KEY_PREFIX"]
+
+API_KEY_ENV_VAR = "ARKLEON_API_KEY"
+API_KEY_PREFIX = "ak_"
+
+
+def resolve_api_key(explicit: str | None) -> str:
+    """Return an ak_-prefixed key or raise AuthError locally.
+
+    Resolution order: the explicit argument, then ``ARKLEON_API_KEY``. The key
+    is required and validated for the ak_ prefix here, before any request, so
+    the client fails closed rather than issuing a silent unauthenticated call
+    (contract section 6.2). The raised message never contains the key value.
+    """
+    key = explicit if explicit is not None else os.environ.get(API_KEY_ENV_VAR)
+    if not isinstance(key, str) or not key.strip():
+        raise AuthError(
+            "An Arkleon /v1 API key is required. Pass api_key=... or set the "
+            f"{API_KEY_ENV_VAR} environment variable to an {API_KEY_PREFIX}-prefixed key.",
+            error="unauthorized",
+        )
+    key = key.strip()
+    if not key.startswith(API_KEY_PREFIX):
+        raise AuthError(
+            f"Arkleon /v1 API keys must be {API_KEY_PREFIX}-prefixed. The supplied "
+            "value is not a valid key.",
+            error="unauthorized",
+        )
+    return key
+
+
+def optional_api_key(explicit: str | None) -> str | None:
+    """Return a resolvable ak_ key, or None when none is available.
+
+    A soft companion to resolve_api_key for callers that must not raise when no
+    key is present, such as the MCP server deciding whether to register the paid
+    tools (spec section 7.1). It never raises and never logs the key.
+    """
+    try:
+        return resolve_api_key(explicit)
+    except AuthError:
+        return None