How do I pull send data using the API?

import os
import json
import argparse
import datetime as dt
import requests
import logging
import time

def iso(s: str) -> str:
    return dt.datetime.fromisoformat(s).isoformat()

def build_base(host: str) -> str:
    host = host.strip()
    host = host.replace("https://", "").replace("http://", "")
    return f"https://{host}/api/odata"

def odata_get(session: requests.Session, url: str, params: dict) -> dict:
    logging.info("Starting HTTP GET %s", url)
    logging.debug("Params: %s", params)
    start = time.time()
    try:
        r = session.get(url, params=params, timeout=30)
    except requests.exceptions.RequestException:
        logging.exception("Request failed for %s", url)
        raise
    elapsed = time.time() - start
    logging.info("HTTP %s %s in %.2fs", r.status_code, url, elapsed)
    if not r.ok:
        logging.error("Response body: %s", r.text)
        raise RuntimeError(f"HTTP {r.status_code}: {r.text}")
    try:
        return r.json()
    except ValueError:
        logging.exception("Failed to decode JSON from %s", url)
        raise

def fetch_sentmessages(base: str, session: requests.Session, since: str | None, until: str | None, top: int, max_requests: int = 1000) -> list[dict]:
    url = f"{base}/SentMessages"
    select_fields = ",".join([
        "ID","Subject","SentDate","OwnerID","RecipientCount",
        "OpenCount","ClickCount","ReadCount","EngagementRate",
        "AvgReadTime","MostRecentOpenDate"
    ])
    filters = []
    if since:
        filters.append(f"SentDate ge {iso(since)}")
    if until:
        filters.append(f"SentDate lt {iso(until)}")
    params = {
        "$select": select_fields,
        "$orderby": "SentDate desc",
        "$top": top
    }
    if filters:
        params["$filter"] = " and ".join(filters)

    out = []
    skip = 0
    max_pages = int(os.getenv("POLITEMAIL_MAX_PAGES", "1000"))
    page_count = 0
    request_count = 0
    while True:
        page_count += 1
        if page_count > max_pages:
            logging.warning("Reached max_pages=%s, stopping to avoid infinite loop", max_pages)
            break
        params["$skip"] = skip
        logging.info("Fetching page skip=%s top=%s", skip, top)
        if request_count >= max_requests:
            logging.info("Reached max_requests=%s, stopping further requests", max_requests)
            break
        data = odata_get(session, url, params)
        request_count += 1
        rows = data.get("value", [])
        logging.info("Received %d rows", len(rows))
        out.extend(rows)
        if len(rows) < top:
            break
        skip += top
    return out

def main():
    p = argparse.ArgumentParser()
    p.add_argument("--host", default=os.getenv("POLITEMAIL_HOST"))
    p.add_argument("--pat", default=os.getenv("POLITEMAIL_PAT"))
    p.add_argument("--since", default=None)
    p.add_argument("--until", default=None)
    p.add_argument("--top", type=int, default=1)
    p.add_argument("--max-requests", type=int, default=int(os.getenv("POLITEMAIL_MAX_REQUESTS", "1")),
                   help="Maximum number of HTTP requests to make (default 1 or POLITEMAIL_MAX_REQUESTS)")
    args = p.parse_args()

    if not args.host or not args.pat:
        raise SystemExit("Set POLITEMAIL_HOST and POLITEMAIL_PAT, or pass --host and --pat")

    base = build_base(args.host)

    # configure logging: send logs to stderr so stdout remains usable for JSON
    log_level = logging.DEBUG if os.getenv("POLITEMAIL_DEBUG") else logging.INFO
    logging.basicConfig(level=log_level, format="%(asctime)s %(levelname)s %(message)s")
    logging.info("Using base URL: %s", base)

    s = requests.Session()
    s.auth = ("pat", args.pat)
    s.headers.update({"Accept": "application/json"})
    logging.info("Starting fetch_sentmessages (top=%s since=%s until=%s max_requests=%s)", args.top, args.since, args.until, args.max_requests)
    rows = fetch_sentmessages(base, s, args.since, args.until, args.top, args.max_requests)
    # print JSON to stdout and flush immediately
    print(json.dumps(rows, indent=2, default=str), flush=True)

if __name__ == "__main__":
    main()