vanda-api 1.0.2__tar.gz → 1.1.0__tar.gz

vanda_api-1.1.0/CHANGELOG.md

@@ -0,0 +1,118 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.0] - 2026-09-23
+
+### Added
+- `client.positioning` / `AsyncVandaClient.positioning` - Positioning API support
+- `client.flow` / `AsyncVandaClient.flow` - Flow API support
+- Both expose `get_timeseries()`, `get_latest()`, `export_timeseries()` and `list_catalog()`; flow adds the two forecast methods below
+- `series_ids`, `metrics` and `frequency` accept a sequence as well as a comma-separated string
+- `normalize_result()` accepts `preserve` so responses can keep envelope keys such as `pagination` and `count`
+- Flow's `unresolved` list is preserved, so identifiers that matched nothing are visible to the caller
+- `normalisation` / `normalisation_period` on `positioning.get_timeseries()`, including the positioning-only `"none"` that opts out of the service's default
+- `flow.get_forecast_runs()` - the run dates, horizons, components and scenario tokens a forecast series publishes
+- `flow.get_forecast()` - one scenario of the forecast cube, grouped one object per (series, component, horizon)
+- `dimensions` on `flow.get_timeseries()`, to pin one cell of a dimensioned dataset; accepts a dict and sends it as JSON
+- `sdk_key=` on `VandaClient` / `AsyncVandaClient`, and the `VANDA_SDK_KEY` environment variable - the user API key generated at https://www.vanda-analytics.com/tools/api-keys, sent as the `x-api-key` header
+- Unit tests and examples for both services
+
+### Fixed
+- A failed transformation no longer discards the response. positioning and flow serve the untransformed rows under the upstream's status code; `get_timeseries()` now returns those rows with `transformation.status` reporting `"Failure"` instead of raising `ServerError`
+- Such responses are no longer retried - they are deterministic, and retrying only added latency
+
+### Notes
+- `transformation` requires `window`, and vice versa
+- Positioning normalises by default (`zscore` over `All`), so omitting both params is not the same as raw data; pass `normalisation="none"` for that. Flow's normalisation is opt-in and pairs its two params
+- `data` always holds the raw stored series; transformed and normalised values arrive under `transformation`
+- `flow.get_forecast()` takes neither a transformation nor a normalisation. Horizon 0 is the run date, so on the z-score axis it exists only for the `"All"` scenario, and omitting `horizons` returns every one the series publishes
+- The forecast scenario axis is named per component - `zscore` for `cta`, `rp` and `vt`, `ret` for `gamma` - so read `scenario_key` from `get_forecast_runs()` rather than assuming
+- `dimensions` is matched by JSON containment, so the value types are load-bearing: `{"projection": "10"}` matches nothing where `{"projection": 10}` matches
+- Flow's `unresolved` list only appears when at least one identifier resolved; a request where none do raises `NotFoundError`
+- An SDK key resolves to its owner, so that user's entitlement and tier limits apply; it needs no token exchange and nothing is cached on disk. It authenticates all four services, but does not widen entitlement - a full-history export without Data Licence access still raises `RateLimitError`
+- When several credentials are supplied, `sdk_key` wins, then `token`, then email/password
+- Intraday flow series are capped at 31 days per request, an undated request returns the latest 31 days, and transformations on them are refused by the service
+
+
+## [1.0.1] - 2026-06-03
+
+### Changed
+- `get_timeseries()` now returns `dict[str, Any]`
+- `get_timeseries_many()` now returns `dict[str, Any]`
+- `get_leaderboard()` now returns `dict[str, Any]`
+- `list_securities()` now returns `dict[str, Any]`
+- `get_constituents()` now returns `dict[str, Any]`
+- `bulk_securities()` now returns `Union[str, dict[str, Any]]`
+- `get_daily_snapshot()` now returns `Union[str, dict[str, Any]]`
+
+### Added
+- Support for transformations (`rolling_sum`, `moving_avg`)
+- Support for normalisation (`zscore`, `percentile_rank`)
+- Support for configurable rolling windows
+- Support for configurable normalisation periods
+- Support for `is_full_history`
+
+
+## [1.0.0] - 2026-03-26
+
+### Added
+
+- Moved API methods under namespaces: 
+    - client.get_timeseries() to client.series.get_timeseries()
+    - client.get_timeseries_many to client.series.get_timeseries_many()
+    - client.get_leaderboard to client.series.get_leaderboard()
+    - client.create_bulk_securities_job to client.series.create_bulk_securities_job()
+    - client.bulk_securities to client.series.bulk_securities()
+    - client.get_daily_snapshot to client.series.get_daily_snapshot()
+    - client.get_job to client.series.get_job()
+    - client.get_job_status to client.series.get_job_status()
+    - client.poll_job to client.series.poll_job()
+    - client.wait_for_job to client.series.wait_for_job()
+    - client.export_job_result to client.series.export_job_result()
+    - client.stream_job_result to client.series.stream_job_result()
+    - client.export_timeseries to client.series.export_timeseries()
+    - client.list_fields to client.series.list_fields()
+    - client.list_intervals to client.series.list_intervals()
+    - client.list_securities to client.series.list_securities()
+- Old methods still work but are deprecated.
+- Added new endpoints for aggregates timeseries and constituents
+- Refactored code to make use of common functions in series and aggregates endpoints
+- Updated unit test cases with new changes for calling the endpoints
+- Updated examples file to use series and aggregates endpoints
+
+
+## [0.1.1] - 2026-02-20
+
+### Added
+
+- Email/password authentication support with automatic token caching
+- Token cache with expiration management in `~/.vanda/token_cache.json`
+- Entitlement validation on authentication
+- Support for `VANDA_LOGIN_EMAIL` and `VANDA_PASSWORD` environment variables
+- Async authentication methods in `AsyncAuth` class
+
+### Fixed
+
+- Fixed `asset_class` parameter format in bulk operations (now sent as list)
+- Fixed async authentication to include entitlement check
+
+## [0.1.0] - 2024-02-06
+
+### Added
+
+- Initial release
+- Synchronous VandaClient
+- Asynchronous AsyncVandaClient
+- All 12 API endpoints implemented
+- Retry logic with exponential backoff
+- Comprehensive error handling
+- Job polling utilities
+- CSV/JSONL export support
+- Optional pandas support
+- Type hints throughout
+- Full test coverage
+- CI/CD with GitHub Actions

{vanda_api-1.0.2 → vanda_api-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vanda-api
-Version: 1.0.2
+Version: 1.1.0
 Summary: Official Python SDK for Vanda Analytics Data API
 Project-URL: Homepage, https://gitlab.com/yourusername/vanda-api
 Project-URL: Documentation, https://gitlab.com/yourusername/vanda-api#readme
@@ -218,6 +218,34 @@ export VANDA_PASSWORD="your_password"
 
 ## Authentication
 
+### SDK API key
+
+Generate a key in the Vanda frontend at
+[www.vanda-analytics.com/tools/api-keys](https://www.vanda-analytics.com/tools/api-keys),
+then pass it to the client:
+
+```python
+client = VandaClient(sdk_key="your_key_here")
+```
+
+or set it in the environment:
+
+```bash
+export VANDA_SDK_KEY="your_key_here"
+```
+
+A key belongs to your user, so your own entitlement and tier limits apply to
+every request made with it. It is sent as a header and needs no token exchange,
+so there is nothing to refresh and nothing cached on disk. Keep it secret and
+revoke it from the same page if it leaks.
+
+An SDK key authenticates every service the client covers - `series`,
+`aggregates`, `positioning` and `flow`. What it does not do is widen your
+entitlement: a full-history export, for example, still needs approved Data
+Licence access and is otherwise refused with `RateLimitError`.
+
+### Token, or email and password
+
 Set your API token via environment variable:
 
 ```bash
@@ -243,6 +271,9 @@ or
 client = VandaClient(email="your_email@example.com", password="your_password")
 ```
 
+If more than one credential is supplied, `sdk_key` wins, then `token`, then
+email and password.
+
 ## Features
 
 - Sync and async clients with consistent interfaces
@@ -316,9 +347,28 @@ Responses keep their envelope: alongside `data` you get `count`, `metric`,
 `revision`, `series_ids`, `version` and `pagination`. Use `pagination` to page -
 `records_per_page` defaults to 2000 and is capped by your access tier.
 
-Unlike aggregates, positioning does not accept `normalisation` /
-`normalisation_period`; its values are already z-scores. `transformation` and
-`window` must be passed together.
+`transformation` and `window` must be passed together, and a transformation has
+to resolve to exactly one series.
+
+Positioning normalises by default: omitting `normalisation` /
+`normalisation_period` is the same as asking for `zscore` over `All`. Neither
+needs its partner, since the service defaults both. Pass `normalisation="none"`
+for the raw stored values.
+
+```python
+    raw = client.positioning.get_timeseries(series_ids=series_label, normalisation="none")
+    ranked = client.positioning.get_timeseries(
+        series_ids=series_label,
+        normalisation="percentile_rank",
+        normalisation_period="1y",
+    )
+```
+
+Note that `data` always holds the raw stored series - transformed and normalised
+values arrive under `transformation["results"]["data"]`. Asking for more than one
+series skips the normalisation rather than failing, reporting
+`transformation.status` as `"skipped"`. `normalisation_period` is a calendar
+lookback (`3m` to `All`), where `window` counts observations.
 
 ### Flow Data
 
@@ -328,6 +378,8 @@ Accessed via `client.flow`.
 - `get_latest()` - Get the latest observation per series
 - `export_timeseries()` - Export flow timeseries to file
 - `list_catalog()` - Search the catalog and filter by dimension
+- `get_forecast_runs()` - List the runs, horizons and scenarios a forecast series publishes
+- `get_forecast()` - Get one scenario of the forecast cube
 
 ```python
 from vanda import VandaClient
@@ -352,11 +404,64 @@ with VandaClient(token="YOUR_TOKEN_HERE") as client:
 `series_ids`, `metrics` and `frequency` accept either a comma-separated string
 or a sequence. Identifiers that matched nothing are reported in `unresolved`
 rather than failing the request, so check it before treating a short result as
-complete.
+complete. That holds as long as *something* resolved - a request where no
+identifier matches is a 404 and raises `NotFoundError`.
+
+Some flow datasets are published as a cube rather than a flat series, with a
+value per combination of dimensions. Pass `dimensions` to pin one cell:
+
+```python
+data = client.flow.get_timeseries(
+    series_ids=slug, dimensions={"projection": 10, "zscore": "All"}
+)
+```
+
+It is sent as JSON because the types decide what matches - `projection` is
+stored as a number and `zscore` as a string, so `{"projection": "10"}` matches
+nothing at all.
+
+Intraday series (FX options) are capped at 31 days per request. A request with
+no dates returns the most recent 31 days rather than the full history, a longer
+span is refused, and transformations are not available on them yet.
+
+Flow normalisation is opt-in, where positioning's is on by default, and flow
+pairs its params: `normalisation` / `normalisation_period` must be passed
+together, as must `transformation` / `window`. A transformation has to resolve to
+exactly one series, and flow has no `none` value - simply omit them for raw
+values.
+
+#### Forecasts
+
+Some flow datasets publish a forecast **cube**: every combination of a horizon
+and a scenario, for each run date. Ask what a series publishes before reading
+it - the scenario axis is named per component, `zscore` for `cta`, `rp` and
+`vt`, `ret` for `gamma`:
+
+```python
+with VandaClient(token="YOUR_TOKEN_HERE") as client:
+    axes = client.flow.get_forecast_runs(series_ids="AUFXFUTUAUDMIXINSSPECTA")
+    series = axes["data"][0]
+    print(series["components"], series["scenario_key"], series["horizons"])
+
+    forecast = client.flow.get_forecast(
+        series_ids="AUFXFUTUAUDMIXINSSPECTA",
+        scenario="All",
+        horizons=[1, 5, 10],
+    )
+    print(forecast["run_date"], forecast["scenario"])
+    for group in forecast["data"]:
+        print(group["horizon"], group["component"], group["metrics"])
+```
+
+Rows come back as one group per (series, component, horizon), with every metric
+nested inside - a forecast is read as a point on a path. Horizon 0 is the run
+date itself, so on the z-score axis it exists only for the unconditional
+scenario (`"All"`). There is no `forecast_date`: pair `run_date` with `horizon`.
+Omitting `horizons` returns every horizon the series publishes, which is the
+largest response this endpoint produces - name the ones you need, or page.
 
-Unlike positioning, flow accepts `normalisation` / `normalisation_period` - each
-must be passed with its partner, as must `transformation` / `window`. A
-transformation has to resolve to exactly one series.
+Neither method takes a transformation or a normalisation; a projection is not a
+series to roll up or re-standardise.
 
 For both services, if the transformation service is unavailable the
 untransformed rows are returned with `transformation.status` set to `"Failure"`
@@ -634,6 +739,7 @@ Supported values:
 ```python
 normalisation="zscore"
 normalisation="percentile_rank"
+normalisation="none"          # positioning only - opts out of its default
 ```
 
 ### Supported Normalisation Periods

{vanda_api-1.0.2 → vanda_api-1.1.0}/README.md

@@ -180,6 +180,34 @@ export VANDA_PASSWORD="your_password"
 
 ## Authentication
 
+### SDK API key
+
+Generate a key in the Vanda frontend at
+[www.vanda-analytics.com/tools/api-keys](https://www.vanda-analytics.com/tools/api-keys),
+then pass it to the client:
+
+```python
+client = VandaClient(sdk_key="your_key_here")
+```
+
+or set it in the environment:
+
+```bash
+export VANDA_SDK_KEY="your_key_here"
+```
+
+A key belongs to your user, so your own entitlement and tier limits apply to
+every request made with it. It is sent as a header and needs no token exchange,
+so there is nothing to refresh and nothing cached on disk. Keep it secret and
+revoke it from the same page if it leaks.
+
+An SDK key authenticates every service the client covers - `series`,
+`aggregates`, `positioning` and `flow`. What it does not do is widen your
+entitlement: a full-history export, for example, still needs approved Data
+Licence access and is otherwise refused with `RateLimitError`.
+
+### Token, or email and password
+
 Set your API token via environment variable:
 
 ```bash
@@ -205,6 +233,9 @@ or
 client = VandaClient(email="your_email@example.com", password="your_password")
 ```
 
+If more than one credential is supplied, `sdk_key` wins, then `token`, then
+email and password.
+
 ## Features
 
 - Sync and async clients with consistent interfaces
@@ -278,9 +309,28 @@ Responses keep their envelope: alongside `data` you get `count`, `metric`,
 `revision`, `series_ids`, `version` and `pagination`. Use `pagination` to page -
 `records_per_page` defaults to 2000 and is capped by your access tier.
 
-Unlike aggregates, positioning does not accept `normalisation` /
-`normalisation_period`; its values are already z-scores. `transformation` and
-`window` must be passed together.
+`transformation` and `window` must be passed together, and a transformation has
+to resolve to exactly one series.
+
+Positioning normalises by default: omitting `normalisation` /
+`normalisation_period` is the same as asking for `zscore` over `All`. Neither
+needs its partner, since the service defaults both. Pass `normalisation="none"`
+for the raw stored values.
+
+```python
+    raw = client.positioning.get_timeseries(series_ids=series_label, normalisation="none")
+    ranked = client.positioning.get_timeseries(
+        series_ids=series_label,
+        normalisation="percentile_rank",
+        normalisation_period="1y",
+    )
+```
+
+Note that `data` always holds the raw stored series - transformed and normalised
+values arrive under `transformation["results"]["data"]`. Asking for more than one
+series skips the normalisation rather than failing, reporting
+`transformation.status` as `"skipped"`. `normalisation_period` is a calendar
+lookback (`3m` to `All`), where `window` counts observations.
 
 ### Flow Data
 
@@ -290,6 +340,8 @@ Accessed via `client.flow`.
 - `get_latest()` - Get the latest observation per series
 - `export_timeseries()` - Export flow timeseries to file
 - `list_catalog()` - Search the catalog and filter by dimension
+- `get_forecast_runs()` - List the runs, horizons and scenarios a forecast series publishes
+- `get_forecast()` - Get one scenario of the forecast cube
 
 ```python
 from vanda import VandaClient
@@ -314,11 +366,64 @@ with VandaClient(token="YOUR_TOKEN_HERE") as client:
 `series_ids`, `metrics` and `frequency` accept either a comma-separated string
 or a sequence. Identifiers that matched nothing are reported in `unresolved`
 rather than failing the request, so check it before treating a short result as
-complete.
+complete. That holds as long as *something* resolved - a request where no
+identifier matches is a 404 and raises `NotFoundError`.
+
+Some flow datasets are published as a cube rather than a flat series, with a
+value per combination of dimensions. Pass `dimensions` to pin one cell:
+
+```python
+data = client.flow.get_timeseries(
+    series_ids=slug, dimensions={"projection": 10, "zscore": "All"}
+)
+```
+
+It is sent as JSON because the types decide what matches - `projection` is
+stored as a number and `zscore` as a string, so `{"projection": "10"}` matches
+nothing at all.
+
+Intraday series (FX options) are capped at 31 days per request. A request with
+no dates returns the most recent 31 days rather than the full history, a longer
+span is refused, and transformations are not available on them yet.
+
+Flow normalisation is opt-in, where positioning's is on by default, and flow
+pairs its params: `normalisation` / `normalisation_period` must be passed
+together, as must `transformation` / `window`. A transformation has to resolve to
+exactly one series, and flow has no `none` value - simply omit them for raw
+values.
+
+#### Forecasts
+
+Some flow datasets publish a forecast **cube**: every combination of a horizon
+and a scenario, for each run date. Ask what a series publishes before reading
+it - the scenario axis is named per component, `zscore` for `cta`, `rp` and
+`vt`, `ret` for `gamma`:
+
+```python
+with VandaClient(token="YOUR_TOKEN_HERE") as client:
+    axes = client.flow.get_forecast_runs(series_ids="AUFXFUTUAUDMIXINSSPECTA")
+    series = axes["data"][0]
+    print(series["components"], series["scenario_key"], series["horizons"])
+
+    forecast = client.flow.get_forecast(
+        series_ids="AUFXFUTUAUDMIXINSSPECTA",
+        scenario="All",
+        horizons=[1, 5, 10],
+    )
+    print(forecast["run_date"], forecast["scenario"])
+    for group in forecast["data"]:
+        print(group["horizon"], group["component"], group["metrics"])
+```
+
+Rows come back as one group per (series, component, horizon), with every metric
+nested inside - a forecast is read as a point on a path. Horizon 0 is the run
+date itself, so on the z-score axis it exists only for the unconditional
+scenario (`"All"`). There is no `forecast_date`: pair `run_date` with `horizon`.
+Omitting `horizons` returns every horizon the series publishes, which is the
+largest response this endpoint produces - name the ones you need, or page.
 
-Unlike positioning, flow accepts `normalisation` / `normalisation_period` - each
-must be passed with its partner, as must `transformation` / `window`. A
-transformation has to resolve to exactly one series.
+Neither method takes a transformation or a normalisation; a projection is not a
+series to roll up or re-standardise.
 
 For both services, if the transformation service is unavailable the
 untransformed rows are returned with `transformation.status` set to `"Failure"`
@@ -596,6 +701,7 @@ Supported values:
 ```python
 normalisation="zscore"
 normalisation="percentile_rank"
+normalisation="none"          # positioning only - opts out of its default
 ```
 
 ### Supported Normalisation Periods

{vanda_api-1.0.2 → vanda_api-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vanda-api"
-version = "1.0.2"
+version = "1.1.0"
 description = "Official Python SDK for Vanda Analytics Data API"
 readme = "README.md"
 requires-python = ">=3.9"

{vanda_api-1.0.2 → vanda_api-1.1.0}/src/vanda/__init__.py

@@ -10,7 +10,7 @@ from vanda.errors import (
     VandaError,
 )
 
-__version__ = "0.1.0"
+__version__ = "1.1.0"
 
 __all__ = [
     "VandaClient",

{vanda_api-1.0.2 → vanda_api-1.1.0}/src/vanda/_base/async_base_client.py

@@ -28,6 +28,7 @@ class AsyncBaseClient:
         timeout: float = 600.0,
         max_retries: int = 3,
         cache_file: Optional[str] = None,
+        sdk_key: Optional[str] = None,
     ):
         """
         Initialize async base client.
@@ -40,13 +41,19 @@ class AsyncBaseClient:
             timeout: Request timeout in seconds.
             max_retries: Maximum retry attempts.
             cache_file: Path to token cache file.
+            sdk_key: SDK API key. If None, reads from VANDA_SDK_KEY environment variable.
 
         Raises:
-            AuthError: If token is not provided.
+            AuthError: If no credential is provided.
         """
 
         self.auth = AsyncAuth(
-            token=token, email=email, password=password, base_url=base_url, cache_file=cache_file
+            token=token,
+            email=email,
+            password=password,
+            base_url=base_url,
+            cache_file=cache_file,
+            sdk_key=sdk_key,
         )
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
@@ -85,10 +92,16 @@ class AsyncBaseClient:
 
         return self._client
     async def _refresh_client_headers(self) -> None:
-        """Refresh client headers with updated token."""
-        if self._client:
-            token = await self.auth.get_token_async()
-            self._client.headers.update({"Authorization": f"Bearer {token}"})
+        """Refresh client headers with updated credentials."""
+        if not self._client:
+            return
+
+        if self.auth._auth_mode == "sdk_key":
+            self._client.headers.update(self.auth.get_headers())
+            return
+
+        token = await self.auth.get_token_async()
+        self._client.headers.update({"Authorization": f"Bearer {token}"})
 
     async def _request(
         self,

{vanda_api-1.0.2 → vanda_api-1.1.0}/src/vanda/_base/base_client.py

@@ -29,6 +29,7 @@ class BaseClient:
         timeout: float,
         max_retries: int,
         cache_file: Optional[str],
+        sdk_key: Optional[str] = None,
     ):
         """
         Initialize Base client.
@@ -41,9 +42,10 @@ class BaseClient:
             timeout: Request timeout in seconds.
             max_retries: Maximum retry attempts.
             cache_file: Path to token cache file.
+            sdk_key: SDK API key. If None, reads from VANDA_SDK_KEY environment variable.
 
         Raises:
-            AuthError: If token is not provided.
+            AuthError: If no credential is provided.
         """
 
         self.auth = Auth(
@@ -52,6 +54,7 @@ class BaseClient:
             password=password,
             base_url=base_url,
             cache_file=cache_file,
+            sdk_key=sdk_key,
         )
 
         self.base_url = base_url.rstrip("/")

{vanda_api-1.0.2 → vanda_api-1.1.0}/src/vanda/async_auth.py

@@ -80,7 +80,13 @@ class AsyncAuth(Auth):
 
         Returns:
             Valid access token.
+
+        Raises:
+            AuthError: In SDK key mode, where there is no bearer token.
         """
+        if self._auth_mode == "sdk_key":
+            raise AuthError("No bearer token in SDK key mode; the key is sent as a header.")
+
         if self._auth_mode == "basic":
             cached_token = self._token_cache.load()
             if cached_token:

{vanda_api-1.0.2 → vanda_api-1.1.0}/src/vanda/async_client.py

@@ -2,6 +2,8 @@ from typing import Optional
 
 from vanda._base.async_base_client import AsyncBaseClient
 from vanda.services.async_aggregates import AsyncAggregatesAPI
+from vanda.services.async_flow import AsyncFlowAPI
+from vanda.services.async_positioning import AsyncPositioningAPI
 from vanda.services.async_series import AsyncSeriesAPI
 from vanda.utils.deprecation import deprecated
 
@@ -17,6 +19,7 @@ class AsyncVandaClient(AsyncBaseClient):
         timeout: float = 600.0,
         max_retries: int = 3,
         cache_file: Optional[str] = None,
+        sdk_key: Optional[str] = None,
     ):
 
         super().__init__(
@@ -27,10 +30,13 @@ class AsyncVandaClient(AsyncBaseClient):
             timeout,
             max_retries,
             cache_file,
+            sdk_key=sdk_key,
         )
 
         self.series = AsyncSeriesAPI(self)
         self.aggregates = AsyncAggregatesAPI(self)
+        self.positioning = AsyncPositioningAPI(self)
+        self.flow = AsyncFlowAPI(self)
 
     async def get_timeseries(self, *args, **kwargs):
         deprecated("client.get_timeseries", "client.series.get_timeseries")