Deleted async_learn.py

Deleted example_async_simple.py
Updated async_call_nb.ipynb to add more details.
Updated sync_call_nb.ipynb to add more details.
Updated example_async_gather.py code flow.
Updated example_client.py code flow.
Updated example_sync_httpx.py code flow.

Author: wasin-waeosri

README.md

@@ -7,25 +7,94 @@
 
 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.
 
+## What is Data Platform APIs?
+
+[LSEG Data Platform](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis) (RDP APIs, also known as Delivery Platform in LSEG Real-Time) provides simple web based API access to a broad range of LSEG content.
+
+RDP APIs give developers seamless and holistic access to all of the LSEG content such as Historical Pricing, Environmental Social and Governance (ESG), News, Research, etc, and commingled with their content, enriching, integrating, and distributing the data through a single interface, delivered wherever they need it.  The RDP APIs delivery mechanisms are the following:
+* Request - Response: RESTful web service (HTTP GET, POST, PUT or DELETE) 
+* Alert: delivery is a mechanism to receive asynchronous updates (alerts) to a subscription. 
+* Bulks:  deliver substantial payloads, like the end-of-day pricing data for the whole venue. 
+* Streaming: deliver real-time delivery of messages.
+
+This example project is focusing on the Request-Response: RESTful web service delivery method only.  
+
+For more detail regarding the Data Platform, please see the following APIs resources: 
+- [Quick Start](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis/quick-start) page.
+- [Tutorials](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis/tutorials) page.
+- [RDP APIs: Introduction to the Request-Response API](https://developers.lseg.com/en/api-catalog/refinitiv-data-platform/refinitiv-data-platform-apis/tutorials#introduction-to-the-request-response-api) page.
+
+## What is HTTPX?
+
+[HTTPX](https://www.python-httpx.org/) is a full featured modern HTTP client for Python 3. It provides a set of synchronous and modern asynchronous APIs with [HTTP/2](https://httpwg.org/specs/rfc7540.html) supported. Any Python developers who are using the [Requests](https://requests.readthedocs.io/en/latest/) library can migrate to the HTTPX library easily with their [requests-compatibility API interfaces](https://www.python-httpx.org/compatibility/) like the following examples:
+
+**HTTP GET**
+
+```python
+import httpx
+
+params = {'key1': 'value1', 'key2': 'value2'}
+r = httpx.get('https://httpbin.org/get', params=params)
+r.raise_for_status()
+print(r.json())
+```
+
+**HTTP POST**
+
+```python
+import httpx
+
+data = {'integer': 123, 'boolean': True, 'list': ['a', 'b', 'c']}
+r = httpx.post('https://httpbin.org/post', json=data)
+r.raise_for_status()
+print(r.json())
+```
+
+HTTPX also provides [`httpx.Client`](https://www.python-httpx.org/advanced/clients/) object (equivalent to [`requests.Session()`](https://requests.readthedocs.io/en/latest/user/advanced/#session-objects) object in the [Requests library](https://requests.readthedocs.io/en/latest/)) as synchronous HTTP client for developers. 
+
+Example:
+
+```python
+import httpx
+
+with httpx.Client(base_url='http://httpbin.org') as client:
+  r = client.get('/get')
+  r.raise_for_status()
+  print(r.status_code)
+```
+
+The asynchronous execute model examples, the library offers [`httpx.AsyncClient`](https://www.python-httpx.org/api/#asyncclient) as an asynchronous HTTP client to use with Python asynchronous library such as a [built-in asyncio](https://docs.python.org/3/library/asyncio.html), [Trio](https://trio.readthedocs.io/en/stable/), and [AnyIO](https://anyio.readthedocs.io/en/stable/) libraries. I am demonstrating with asyncio in this project.
+
+Example:
+
+```python
+import asyncio
+import httpx
+
+async def main():
+    async with httpx.AsyncClient() as client:
+        response = await client.get('https://www.example.com/')
+        print(response)
+
+asyncio.run(main())
+```
+
 ## Project Structure
 
 ```
 ├── requirements.txt             # Pinned dependencies
 src/
 ├── .env.example                 # Environment variable template
-├── simple_call_nb.ipynb         # Jupyter notebook — synchronous, shared httpx.Client
+├── sync_call_nb.ipynb         # Jupyter notebook — synchronous, shared httpx.Client
 ├── async_call_nb.ipynb          # Jupyter notebook — async, asyncio.gather() with Semaphore
 ├── 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
-├── example_async_taskgroup.py   # Async — asyncio.TaskGroup with Semaphore
-└── async_learn.py               # Learning script — ExceptionGroup / except*
+└── example_async_gather.py      # Async — asyncio.gather() with Semaphore
 ```
 
 ## Included Notebook
 
-### `src/simple_call_nb.ipynb` — Synchronous, step-by-step Jupyter notebook
+### `src/sync_call_nb.ipynb` — Synchronous, step-by-step Jupyter notebook
 
 Interactive notebook version of the synchronous workflow. Each logical step is a separate cell with a markdown explanation above it, making it easy to run and inspect results incrementally.
 
@@ -67,17 +136,16 @@ Notebook structure:
 
 ## Included Scripts
 
-### `src/example_sync_httpx.py` — Synchronous, direct `httpx` calls
+### `src/example_async_gather.py` — Async with `asyncio.gather()` and `Semaphore`
 
-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.
+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` — 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
+- `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/example_client.py` — Synchronous with shared client
 
@@ -91,30 +159,17 @@ Demonstrates:
 - `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_async_gather.py` — Async with `asyncio.gather()` and `Semaphore`
+### `src/example_sync_httpx.py` — Synchronous, direct `httpx` calls
 
-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.
+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` — 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.
+- `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
 
 ## Prerequisites
 
@@ -163,14 +218,8 @@ jupyter lab src/async_call_nb.ipynb
 # 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
 ```
 
 Each script prints the authenticated request URLs and JSON responses. Timing is printed on exit for the async scripts.