Outlook × Python── Microsoft Graph でメールと予定を読み、集計する

"""Sign in with the device code flow and read your own profile (User.Read)."""
import asyncio
import os

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.user_item_request_builder import UserItemRequestBuilder

SCOPES = ["User.Read"]


def make_client(scopes):
    # Public client app registration; IDs come from environment variables
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    return GraphServiceClient(credentials=cred, scopes=scopes)


async def main():
    client = make_client(SCOPES)
    query = UserItemRequestBuilder.UserItemRequestBuilderGetQueryParameters(
        select=["displayName", "mail", "userPrincipalName"])
    me = await client.me.get(request_configuration=RequestConfiguration(query_parameters=query))
    print("signed in as:", me.display_name, "/", me.mail or me.user_principal_name)


if __name__ == "__main__":
    asyncio.run(main())

"""Count unread Inbox messages per sender using $select, $filter and $top (Mail.ReadBasic)."""
import asyncio
import os
from collections import Counter

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.mail_folders.item.messages.messages_request_builder import (
    MessagesRequestBuilder,
)

SCOPES = ["Mail.ReadBasic"]  # subject, sender, dates; no body


def to_row(m):
    sender = m.from_.email_address.address if m.from_ and m.from_.email_address else ""
    return {"from": sender, "subject": m.subject or "", "received": m.received_date_time}


def count_by_sender(rows):
    return Counter(r["from"] for r in rows)


async def main():
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    query = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters(
        select=["subject", "from", "receivedDateTime"],
        filter="isRead eq false",
        top=50,
    )
    page = await client.me.mail_folders.by_mail_folder_id("inbox").messages.get(
        request_configuration=RequestConfiguration(query_parameters=query))
    rows = [to_row(m) for m in page.value or []]
    print("unread on the first page:", len(rows))
    for sender, n in count_by_sender(rows).most_common(10):
        print(n, sender)


if __name__ == "__main__":
    asyncio.run(main())

"""Fetch every Inbox page via @odata.nextLink and group messages by the request ID in the subject."""
import asyncio
import csv
import os
import re
from collections import defaultdict

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.mail_folders.item.messages.messages_request_builder import (
    MessagesRequestBuilder,
)

SCOPES = ["Mail.ReadBasic"]
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))
REQUEST_ID = re.compile(r"R-\d{4}-\d{3}")


def to_row(m):
    return {"subject": m.subject or "", "received": str(m.received_date_time or "")}


def group_by_request(rows):
    groups = defaultdict(list)
    for r in rows:
        hit = REQUEST_ID.search(r["subject"])
        groups[hit.group(0) if hit else "(none)"].append(r)
    out = []
    for rid, items in sorted(groups.items()):
        replies = sum(1 for r in items if r["subject"].lower().startswith("re:"))
        out.append({"request_id": rid, "messages": len(items), "replies": replies,
                    "latest": max(r["received"] for r in items)})
    return out


async def fetch_all(client):
    builder = client.me.mail_folders.by_mail_folder_id("inbox").messages
    query = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters(
        select=["subject", "receivedDateTime"], top=100)
    page = await builder.get(request_configuration=RequestConfiguration(query_parameters=query))
    rows, pages = [], 0
    while page:
        rows += [to_row(m) for m in page.value or []]
        pages += 1
        if not page.odata_next_link or pages >= MAX_PAGES:
            break
        # Use the whole nextLink as-is; it already carries $select and $top
        page = await builder.with_url(page.odata_next_link).get()
    return rows, pages


def write_csv(summary, path="out_requests.csv"):
    with open(path, "w", encoding="utf-8-sig", newline="") as f:
        w = csv.DictWriter(f, fieldnames=["request_id", "messages", "replies", "latest"])
        w.writeheader()
        w.writerows(summary)


async def main():
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    rows, pages = await fetch_all(client)
    summary = group_by_request(rows)
    write_csv(summary)
    print("pages:", pages, "messages:", len(rows), "request IDs:", len(summary))


if __name__ == "__main__":
    asyncio.run(main())

"""Count Inbox mail per local day for a receivedDateTime range ($filter ge/lt with $orderby)."""
import asyncio
import os
from collections import Counter
from datetime import date, datetime, time, timedelta, timezone

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.mail_folders.item.messages.messages_request_builder import (
    MessagesRequestBuilder,
)

SCOPES = ["Mail.ReadBasic"]
TZ = timezone(timedelta(hours=float(os.environ.get("UTC_OFFSET_HOURS", "9"))))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))


def utc_range(start, end):
    """Local dates [start, end) -> UTC strings for $filter."""
    lo = datetime.combine(start, time.min, TZ).astimezone(timezone.utc)
    hi = datetime.combine(end, time.min, TZ).astimezone(timezone.utc)
    return lo.strftime("%Y-%m-%dT%H:%M:%SZ"), hi.strftime("%Y-%m-%dT%H:%M:%SZ")


def per_local_day(received):
    counts = Counter()
    for v in received:
        if isinstance(v, str):
            v = datetime.fromisoformat(v.replace("Z", "+00:00"))
        counts[v.astimezone(TZ).date().isoformat()] += 1
    return dict(sorted(counts.items()))


def period():
    end = date.fromisoformat(os.environ["END_DATE"]) if os.environ.get("END_DATE") else date.today() + timedelta(days=1)
    start = date.fromisoformat(os.environ["START_DATE"]) if os.environ.get("START_DATE") else end - timedelta(days=7)
    return start, end


async def main():
    lo, hi = utc_range(*period())
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    builder = client.me.mail_folders.by_mail_folder_id("inbox").messages
    query = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters(
        select=["receivedDateTime"],
        filter="receivedDateTime ge %s and receivedDateTime lt %s" % (lo, hi),
        orderby=["receivedDateTime desc"],  # same property as in $filter
        top=100,
    )
    page = await builder.get(request_configuration=RequestConfiguration(query_parameters=query))
    received, pages = [], 0
    while page:
        received += [m.received_date_time for m in page.value or []]
        pages += 1
        if not page.odata_next_link or pages >= MAX_PAGES:
            break
        page = await builder.with_url(page.odata_next_link).get()
    print("period (UTC):", lo, "to", hi, "messages:", len(received))
    for day, n in per_local_day(received).items():
        print(day, n)


if __name__ == "__main__":
    asyncio.run(main())

"""Total meeting hours per local day for one week from calendarView (Calendars.ReadBasic)."""
import asyncio
import os
from collections import defaultdict
from datetime import date, datetime, time, timedelta, timezone

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.calendar_view.calendar_view_request_builder import (
    CalendarViewRequestBuilder,
)

SCOPES = ["Calendars.ReadBasic"]
TZ = timezone(timedelta(hours=float(os.environ.get("UTC_OFFSET_HOURS", "9"))))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))


def week_range(first_day):
    """Local midnight of first_day plus 7 days, as UTC values without an offset."""
    lo = datetime.combine(first_day, time.min, TZ).astimezone(timezone.utc)
    hi = lo + timedelta(days=7)
    return lo.strftime("%Y-%m-%dT%H:%M:%S"), hi.strftime("%Y-%m-%dT%H:%M:%S")


def to_row(e):
    return {"subject": e.subject or "", "start": e.start.date_time, "end": e.end.date_time,
            "all_day": bool(e.is_all_day), "cancelled": bool(e.is_cancelled)}


def parse_utc(s):
    # e.g. 2026-09-14T00:30:00.0000000 (UTC when no Prefer header is sent)
    return datetime.fromisoformat(s[:19]).replace(tzinfo=timezone.utc)


def hours_per_day(rows):
    hours = defaultdict(float)
    for r in rows:
        if r["all_day"] or r["cancelled"]:
            continue
        start, end = parse_utc(r["start"]).astimezone(TZ), parse_utc(r["end"]).astimezone(TZ)
        hours[start.date().isoformat()] += (end - start).total_seconds() / 3600
    return {d: round(h, 2) for d, h in sorted(hours.items())}


async def main():
    first = date.fromisoformat(os.environ.get("START_DATE", date.today().isoformat()))
    lo, hi = week_range(first)
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    builder = client.me.calendar_view
    query = CalendarViewRequestBuilder.CalendarViewRequestBuilderGetQueryParameters(
        start_date_time=lo, end_date_time=hi,
        select=["subject", "start", "end", "isAllDay", "isCancelled"], top=100)
    page = await builder.get(request_configuration=RequestConfiguration(query_parameters=query))
    rows, pages = [], 0
    while page:
        rows += [to_row(e) for e in page.value or []]
        pages += 1
        if not page.odata_next_link or pages >= MAX_PAGES:
            break
        page = await builder.with_url(page.odata_next_link).get()
    print("events:", len(rows))
    for day, h in hours_per_day(rows).items():
        print(day, h, "h")


if __name__ == "__main__":
    asyncio.run(main())

"""Incremental Inbox sync with messages/delta; the deltaLink is kept in a local state file."""
import asyncio
import json
import os
from pathlib import Path

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.users.item.mail_folders.item.messages.delta.delta_request_builder import (
    DeltaRequestBuilder,
)

SCOPES = ["Mail.ReadBasic"]
STATE = Path(os.environ.get("DELTA_STATE", "out_delta_state.json"))


def to_row(m):
    if "@removed" in (m.additional_data or {}):
        return {"id": m.id, "removed": True}
    sender = m.from_.email_address.address if m.from_ and m.from_.email_address else ""
    return {"id": m.id, "subject": m.subject or "", "from": sender, "is_read": bool(m.is_read)}


def apply_changes(items, rows):
    added = updated = removed = 0
    for r in rows:
        if r.get("removed"):
            removed += 1 if items.pop(r["id"], None) is not None else 0
        elif r["id"] in items:
            items[r["id"]] = r
            updated += 1
        else:
            items[r["id"]] = r
            added += 1
    return {"added": added, "updated": updated, "removed": removed}


def load_state():
    if STATE.exists():
        return json.loads(STATE.read_text(encoding="utf-8"))
    return {"delta_link": None, "items": {}}


async def sync(client, state):
    builder = client.me.mail_folders.by_mail_folder_id("inbox").messages.delta
    if state["delta_link"]:
        page = await builder.with_url(state["delta_link"]).get()
    else:
        query = DeltaRequestBuilder.DeltaRequestBuilderGetQueryParameters(select=["subject", "from", "isRead"])
        config = RequestConfiguration(query_parameters=query)
        config.headers.add("Prefer", "odata.maxpagesize=50")
        page = await builder.get(request_configuration=config)
    rows = []
    while page:
        rows += [to_row(m) for m in page.value or []]
        if page.odata_next_link:
            page = await builder.with_url(page.odata_next_link).get()
            continue
        state["delta_link"] = page.odata_delta_link  # end of this round
        break
    return rows


async def main():
    state = load_state()
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    stats = apply_changes(state["items"], await sync(client, state))
    STATE.write_text(json.dumps(state, ensure_ascii=False), encoding="utf-8")
    print("changes:", stats, "items kept:", len(state["items"]))


if __name__ == "__main__":
    asyncio.run(main())

"""Mail yourself a summary of unread Inbox mail; DRY_RUN by default (Mail.ReadBasic + Mail.Send)."""
import asyncio
import os
from collections import Counter

from azure.identity import DeviceCodeCredential
from kiota_abstractions.base_request_configuration import RequestConfiguration
from msgraph import GraphServiceClient
from msgraph.generated.models.body_type import BodyType
from msgraph.generated.models.email_address import EmailAddress
from msgraph.generated.models.item_body import ItemBody
from msgraph.generated.models.message import Message
from msgraph.generated.models.recipient import Recipient
from msgraph.generated.users.item.mail_folders.item.messages.messages_request_builder import (
    MessagesRequestBuilder,
)
from msgraph.generated.users.item.send_mail.send_mail_post_request_body import SendMailPostRequestBody

SCOPES = ["Mail.ReadBasic", "Mail.Send"]
DRY_RUN = os.environ.get("DRY_RUN", "1") != "0"
REPORT_TO = os.environ.get("REPORT_TO", "")


def build_summary(rows):
    counts = Counter(r["from"] for r in rows)
    lines = ["Unread messages: %d" % len(rows), ""]
    lines += ["%3d  %s" % (n, sender) for sender, n in counts.most_common(10)]
    return "\n".join(lines)


async def main():
    cred = DeviceCodeCredential(client_id=os.environ["CLIENT_ID"], tenant_id=os.environ["TENANT_ID"])
    client = GraphServiceClient(credentials=cred, scopes=SCOPES)
    query = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters(
        select=["from"], filter="isRead eq false", top=100)
    page = await client.me.mail_folders.by_mail_folder_id("inbox").messages.get(
        request_configuration=RequestConfiguration(query_parameters=query))
    rows = [{"from": m.from_.email_address.address if m.from_ and m.from_.email_address else ""}
            for m in page.value or []]
    text = build_summary(rows)
    if DRY_RUN or not REPORT_TO:
        print("DRY_RUN: would send to", REPORT_TO or "(set REPORT_TO)")
        print(text)
        return
    body = SendMailPostRequestBody(
        message=Message(
            subject="Unread mail summary",
            body=ItemBody(content_type=BodyType.Text, content=text),
            to_recipients=[Recipient(email_address=EmailAddress(address=REPORT_TO))],
        ),
        save_to_sent_items=True,
    )
    await client.me.send_mail.post(body)  # 202 Accepted: queued, not yet delivered
    print("sent to", REPORT_TO)


if __name__ == "__main__":
    asyncio.run(main())