Updated README.md

Added example_async_gather.py with Asyncio Gather method
Added example_async_simple.py with simple async method

Author: wasin-waeosri

.gitignore

@@ -177,3 +177,5 @@ pyrightconfig.json
 
 # Virtual environment
 .venv/
+
+src/example_async_taskgroup.py

README.md

@@ -1,26 +1,79 @@
-# RDP_HTTPX
+# Data Platform APIs HTTP REST Application using HTTPX
 
-Small Python examples that use [`httpx`](https://www.python-httpx.org/) to authenticate with [LSEG Data Platform APIs](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis) (RDP, also known as Delivery Platform)  using OAuth2 Password Grant, then call sample REST endpoints.
+- Version: 1.0
+- Last update: Mar 2026
+- Environment: Python + JupyterLab + Data Platform Account
+- Prerequisite: Data Platform access/entitlements
+
+Python examples that use [`httpx`](https://www.python-httpx.org/) to authenticate with [LSEG Data Platform APIs](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis) (RDP, also known as Delivery Platform) using OAuth 2.0 Password Grant, then call sample REST endpoints — covering both synchronous and asynchronous patterns.
+
+## Project Structure
+
+```
+├── requirements.txt             # Pinned dependencies
+src/
+├── .env.example                 # Environment variable template
+├── example_sync_httpx.py        # Synchronous — direct httpx module calls (no shared client)
+├── example_client.py            # Synchronous — shared httpx.Client
+├── example_async_simple.py      # Async — sequential awaits in a loop
+├── example_async_gather.py      # Async — asyncio.gather() with Semaphore
+└── async_learn.py               # Learning script — ExceptionGroup / except*
+```
 
 ## Included Scripts
 
-- `src/example_sync_httpx.py`
-  - Synchronous (blocking) requests with direct `httpx` calls.
-  - Demonstrates:
-    - `POST /auth/oauth2/v1/token`
-    - `GET /data/pricing/chains/v1/`
-    - `POST /data/historical-pricing/v1/views/events`
-    - Refresh token flow (`grant_type=refresh_token`)
-    - `POST /auth/oauth2/v1/revoke`
+### `src/example_sync_httpx.py` — Synchronous, direct `httpx` calls
+
+Simplest synchronous example. Each function calls `httpx.get()` / `httpx.post()` directly — no shared client or connection pool. Good as a minimal reference or quick script.
+
+Demonstrates:
+- `POST /auth/oauth2/v1/token` — OAuth 2.0 Password Grant authentication
+- `GET /data/pricing/chains/v1/` — chain constituent lookup for a single RIC
+- `POST /data/historical-pricing/v1/views/events` — historical trade events for multiple RICs
+- Refresh token flow (`grant_type=refresh_token`)
+- `POST /auth/oauth2/v1/revoke` — session revocation using HTTP Basic Auth
+- Per-call `verify=False` passed directly to each `httpx` function
+
+### `src/example_client.py` — Synchronous with shared client
+
+Synchronous (blocking) script using a single shared `httpx.Client` instance for connection pooling and consistent configuration across all requests.
+
+Demonstrates:
+- `POST /auth/oauth2/v1/token` — OAuth 2.0 Password Grant authentication
+- `GET /data/pricing/chains/v1/` — chain constituent lookup
+- `POST /data/historical-pricing/v1/views/events` — historical trade events for multiple RICs (commented out, ready to enable)
+- Refresh token flow (`grant_type=refresh_token`) — commented out, ready to enable
+- `POST /auth/oauth2/v1/revoke` — session revocation — commented out, ready to enable
+- Environment validation with a `_require_env()` helper that fails fast on missing credentials
+
+### `src/example_async_simple.py` — Async, sequential loop
+
+Async script using `httpx.AsyncClient`. Fetches interday-summaries for each RIC one after another inside a `for` loop. Simple starting point before introducing concurrency.
+
+Demonstrates:
+- `POST /auth/oauth2/v1/token` — async authentication
+- `GET /data/historical-pricing/v1/views/interday-summaries/{ric}` — daily OHLCV data with corporate-action adjustments
+- Sequential `await` per RIC — no concurrent requests
 
-- `src/example_client.py`
-  - Synchronous (blocking) script using one shared `httpx.Client` (connection pooling + shared config).
-  - Includes simple environment validation and reusable helper methods.
-  - Demonstrates the same endpoint flow as above.
+### `src/example_async_gather.py` — Async with `asyncio.gather()` and `Semaphore`
+
+Async script that fires all RIC requests concurrently via `asyncio.gather()`, with an `asyncio.Semaphore` to cap the number of in-flight requests and avoid hitting server rate limits.
+
+Demonstrates:
+- `POST /auth/oauth2/v1/token` — async authentication
+- `GET /data/historical-pricing/v1/views/interday-summaries/{ric}` — concurrent fetches for 10 RICs
+- `asyncio.Semaphore` — limits concurrent requests (default: 3)
+- `return_exceptions=True` — prevents one failure from cancelling the rest; each result is inspected individually
+- Per-result error handling: `httpx.HTTPStatusError`, `httpx.RequestError`, generic `Exception`
+
+
+### `src/async_learn.py` — `ExceptionGroup` and `except*` sandbox
+
+Standalone learning script demonstrating how `asyncio.gather(return_exceptions=True)` results can be re-raised as an `ExceptionGroup`, and how `except*` dispatches individual exception types from the group.
 
 ## Prerequisites
 
-- Python 3.10+
+- Python 3.11+ (required for `asyncio.TaskGroup` and `except*`)
 - LSEG RDP credentials:
   - Machine ID
   - Password
@@ -43,9 +96,7 @@ python -m venv .venv
 pip install -r requirements.txt
 ```
 
-3. Create your environment file.
-
-Copy `src/.env.example` to `src/.env` and fill in values:
+3. Create your environment file by creating `src/.env` with the following content:
 
 ```dotenv
 RDP_BASE_URL=https://api.refinitiv.com
@@ -58,27 +109,33 @@ APPKEY_RDP=<RDP AppKey>
 ## Run
 
 ```powershell
-python .\src\example_sync_httpx.py
-```
-
-```powershell
+# Synchronous
 python .\src\example_client.py
+
+# Async — sequential loop
+python .\src\example_async_simple.py
+
+# Async — concurrent via asyncio.gather()
+python .\src\example_async_gather.py
+
+# Async — concurrent via asyncio.TaskGroup
+python .\src\example_async_taskgroup.py
 ```
 
-For demo purposes, scripts print token/output payloads and endpoint responses.
+Each script prints the authenticated request URLs and JSON responses. Timing is printed on exit for the async scripts.
 
 ## Security Notes
 
-- The examples currently use `verify=False`, which disables TLS certificate verification.
-- This is not safe for production. Remove `verify=False` (or provide a proper CA bundle) for real usage.
-- Avoid printing access tokens in production applications/logs.
+- All examples use `verify=False` to disable TLS certificate verification. This is intended for local/dev environments only (e.g. where a TLS-inspecting proxy such as ZScaler is in use). Remove `verify=False` or supply a proper CA bundle for production use.
+- Do not log or print access tokens in production applications.
 
 ## License
 
 Apache 2.0. See [LICENSE.md](LICENSE.md).
 
-## Reference
+## References
 
 - https://realpython.com/async-io-python/
 - https://www.twilio.com/en-us/blog/asynchronous-http-requests-in-python-with-httpx-and-asyncio
+- https://docs.python.org/3/library/asyncio-task.html#task-groups
 

src/async_learn.py

@@ -1,104 +1,30 @@
 import asyncio
 import time
 
+async def coro_a():
+    await asyncio.sleep(1)
+    raise ValueError("Error in coro A")
 
-async def task_function(name, duration, fail=False):
-    print(f"  Task {name}: Starting (will sleep for {duration}s)")
-    await asyncio.sleep(duration)
-    if fail:
-        raise ValueError(f"Task {name} failed!")
-    print(f"  Task {name}: Finished")
-    return f"Result of {name}"
+async def coro_b():
+    await asyncio.sleep(1)
+    raise TypeError("Error in coro B")
 
-
-# ─────────────────────────────────────────────
-# asyncio.gather
-# ─────────────────────────────────────────────
-# • Available since Python 3.4
-# • Accepts coroutines or Tasks
-# • Returns a list of results in the same order as inputs
-# • Error behaviour (default): if one task raises, the exception is
-#   propagated immediately to the caller, but the OTHER tasks keep
-#   running in the background (they are NOT cancelled).
-# • return_exceptions=True: exceptions are returned as result values
-#   instead of being raised, so all tasks always run to completion.
-# • Good for fire-and-forget fan-out or when you need return_exceptions.
-
-async def demo_gather():
-    print("\n=== asyncio.gather (no failures) ===")
-    start = time.perf_counter()
-    results = await asyncio.gather(
-        task_function("A", 3),
-        task_function("B", 1),
-        task_function("C", 2),
-    )
-    print(f"  Done in {time.perf_counter() - start:.2f}s | Results: {results}")
-
-    print("\n=== asyncio.gather with return_exceptions=True ===")
-    start = time.perf_counter()
-    results = await asyncio.gather(
-        task_function("A", 1),
-        task_function("B", 0.5, fail=True),   # will raise
-        task_function("C", 1),
-        return_exceptions=True,                # exceptions become values
-    )
-    print(f"  Done in {time.perf_counter() - start:.2f}s | Results: {results}")
-
-
-# ─────────────────────────────────────────────
-# asyncio.TaskGroup  (Python 3.11+)
-# ─────────────────────────────────────────────
-# • Context-manager-based structured concurrency.
-# • Tasks are created with tg.create_task() inside the `async with` block.
-# • When the block exits all tasks are AWAITED automatically.
-# • Error behaviour: if ANY task raises, ALL remaining tasks are
-#   cancelled immediately, then the exception is re-raised.
-#   Multiple simultaneous exceptions are collected into an ExceptionGroup.
-# • Cleaner resource management; preferred for structured concurrency.
-
-async def demo_task_group():
-    print("\n=== asyncio.TaskGroup (no failures) ===")
-    start = time.perf_counter()
-    results = []
-    async with asyncio.TaskGroup() as tg:
-        t1 = tg.create_task(task_function("A", 3))
-        t2 = tg.create_task(task_function("B", 1))
-        t3 = tg.create_task(task_function("C", 2))
-    # All tasks are guaranteed finished here
-    results = [t1.result(), t2.result(), t3.result()]
-    print(f"  Done in {time.perf_counter() - start:.2f}s | Results: {results}")
-
-    print("\n=== asyncio.TaskGroup with a failing task ===")
-    try:
-        async with asyncio.TaskGroup() as tg:
-            tg.create_task(task_function("A", 1))
-            tg.create_task(task_function("B", 0.1, fail=True))  # raises quickly
-            tg.create_task(task_function("C", 1))               # will be cancelled
-    except* ValueError as eg:
-        print(f"  Caught ExceptionGroup errors: {eg}")
-
-
-# ─────────────────────────────────────────────
-# Summary
-# ─────────────────────────────────────────────
-# | Feature                  | gather                  | TaskGroup (3.11+)       |
-# |--------------------------|-------------------------|-------------------------|
-# | API style                | function call           | async context manager   |
-# | Task creation            | pass coroutines/tasks   | tg.create_task()        |
-# | On first exception       | others keep running *   | others are cancelled    |
-# | Multiple exceptions      | only first propagated   | ExceptionGroup          |
-# | return_exceptions        | yes                     | no (use try/except)     |
-# | Structured concurrency   | no                      | yes                     |
-# | Python version           | 3.4+                    | 3.11+                   |
-#
-# * Unless return_exceptions=False (default) and you shield tasks.
+async def coro_c():
+    await asyncio.sleep(1)
+    raise IndexError("Error in coro C")
 
 async def main():
-    await demo_gather()
-    await demo_task_group()
-
-
+    results = await asyncio.gather(coro_a(), coro_b(), coro_c(), return_exceptions=True)
+    exceptions = [e for e in results if isinstance(e, Exception)]
+    if exceptions:
+        raise ExceptionGroup("Multiple exceptions occurred", exceptions)
+    
 if __name__ == "__main__":
-    asyncio.run(main())
-
-
+    try:
+        asyncio.run(main())
+    except* ValueError as ve_group:
+        print(f"[ValueError handled] {ve_group.exceptions}")
+    except* TypeError as te_group:
+        print(f"[TypeError handled] {te_group.exceptions}")
+    except* IndexError as ie_group:
+        print(f"[IndexError handled] {ie_group.exceptions}")