指示からコードへ── Copilot と GitHub Copilot にコードを書かせる指示の型

"""Skeleton given to Copilot (imports, signature, docstring examples); body kept after review."""
import re
import unicodedata

PATTERN = re.compile(r"R-?(\d{4})-(\d{1,3})")


def normalize_request_id(text: str) -> str | None:
    """Return a request ID as R-YYYY-NNN, or None when the text contains no ID.

    >>> normalize_request_id("r-2026-5")
    'R-2026-005'
    >>> normalize_request_id("\uff32\uff0d\uff12\uff10\uff12\uff16\uff0d\uff10\uff14\uff12 proposal")
    'R-2026-042'
    >>> normalize_request_id("see R2026-7 for details")
    'R-2026-007'
    >>> normalize_request_id("no id here") is None
    True
    """
    t = unicodedata.normalize("NFKC", text or "").upper()
    m = PATTERN.search(t)
    if not m:
        return None
    return "R-%s-%03d" % (m.group(1), int(m.group(2)))


if __name__ == "__main__":
    import doctest

    print("doctest:", doctest.testmod())

"""Tests written first; the function was then generated from them and kept after review."""
import re
from datetime import date

TESTS = [
    ("2026-09-12", date(2026, 9, 12)),
    ("2026/9/1", date(2026, 9, 1)),
    ("2026\u5e749\u670812\u65e5", date(2026, 9, 12)),  # 2026 nen 9 gatsu 12 nichi
    (" 2026.09.12 ", date(2026, 9, 12)),
    ("9/12", None),          # no year: do not guess
    ("2026-02-30", None),    # not a real date
    ("", None),
]


def parse_date(text):
    m = re.fullmatch(r"\s*(\d{4})[-/.\u5e74](\d{1,2})[-/.\u6708](\d{1,2})\u65e5?\s*", text or "")
    if not m:
        return None
    try:
        return date(*map(int, m.groups()))
    except ValueError:
        return None


def test_parse_date():
    for text, want in TESTS:
        got = parse_date(text)
        assert got == want, (text, got, want)


if __name__ == "__main__":
    test_parse_date()
    print("all", len(TESTS), "tests passed")

"""Request-ledger report built from small functions, each written from its own prompt."""
import csv
from collections import Counter

STATUS, DEPT, DONE = "\u72b6\u614b", "\u4f9d\u983c\u90e8\u7f72", "\u5b8c\u4e86"  # column names / done value


def load_rows(path):  # prompt 1
    with open(path, encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f))


def open_items(rows):  # prompt 2
    return [r for r in rows if r[STATUS] != DONE]


def count_by(rows, column):  # prompt 3
    return Counter(r[column] for r in rows)


def write_report(counter, path):  # prompt 4
    with open(path, "w", encoding="utf-8-sig", newline="") as f:
        w = csv.writer(f)
        w.writerow(["key", "count"])
        w.writerows(counter.most_common())


def main():  # last prompt: use the previous functions
    rows = load_rows("samples/ledger.csv")
    assert rows and STATUS in rows[0] and DEPT in rows[0], "unexpected columns"
    todo = open_items(rows)
    assert all(r[STATUS] != DONE for r in todo)
    by_dept = count_by(todo, DEPT)
    assert sum(by_dept.values()) == len(todo)
    write_report(by_dept, "out_open_by_dept.csv")
    print("rows:", len(rows), "open:", len(todo))
    for dept, n in by_dept.most_common():
        print(dept, n)


if __name__ == "__main__":
    main()

# Project overview
Python scripts that read Microsoft 365 data through the Microsoft Graph SDK for Python and write reports to CSV files.

## Security rules
- Read the tenant ID, client ID and all other IDs from environment variables (os.environ). Never write IDs, secrets, tokens or webhook URLs in code.
- For app-only access use a certificate or a managed identity (azure-identity), never a client secret.
- Request the least privileged Graph permission shown on the API page. Read-only scripts must not request ReadWrite permissions.
- Use $select so that only the fields the script needs are fetched.
- Never print or log access tokens, message bodies or e-mail addresses.

## Writes
- Code that sends, updates or uploads anything must define DRY_RUN = os.environ.get("DRY_RUN", "1") != "0" and, when DRY_RUN is true, only print what it would do.
- Do not write code that deletes data.

## Style and tests
- Keep comments short and in English.
- Put logic in small functions and add an assert-based test for each. Tests must run without signing in or using the network.
- On HTTP 429, wait for the Retry-After seconds before retrying.

---
applyTo: "scripts/graph/**/*.py,tests/graph/**/*.py"
---
# Graph scripts
- Build credentials with azure-identity: DeviceCodeCredential for delegated scripts, CertificateCredential or ManagedIdentityCredential for app-only jobs.
- Declare the permissions the script needs in a SCOPES constant at the top of the file, using the least privileged one listed on the API page.
- Pass $select with only the properties used later in the script.
- Keep API calls in one async function; keep filtering and counting in plain functions that take lists of dicts, so tests can feed them sample JSON.
- Tests under tests/graph must not sign in or use the network; load the JSON files in tests/graph/samples instead.

"""Screen generated Python for risky patterns before a human review (ast only; nothing is run)."""
import ast
import sys

RISKY_CALLS = {"eval", "exec", "compile"}
HTTP_VERBS = {"get", "post", "put", "patch", "delete", "request"}
SECRET_WORDS = ("secret", "password", "passwd", "token", "api_key", "apikey")


def findings(source, name="<generated>"):
    out = []
    for node in ast.walk(ast.parse(source, name)):
        if isinstance(node, ast.Call):
            f = node.func
            if isinstance(f, ast.Name) and f.id in RISKY_CALLS:
                out.append((node.lineno, "call to %s()" % f.id))
            if (isinstance(f, ast.Attribute) and f.attr in HTTP_VERBS
                    and isinstance(f.value, ast.Name) and f.value.id == "requests"
                    and not any(k.arg == "timeout" for k in node.keywords)):
                out.append((node.lineno, "requests.%s without timeout" % f.attr))
        if (isinstance(node, ast.Assign) and isinstance(node.value, ast.Constant)
                and isinstance(node.value.value, str) and len(node.value.value) >= 8):
            for t in node.targets:
                if isinstance(t, ast.Name) and any(w in t.id.lower() for w in SECRET_WORDS):
                    out.append((node.lineno, "string literal assigned to %s" % t.id))
    return sorted(out)


def main(path):
    with open(path, encoding="utf-8") as f:
        found = findings(f.read(), path)
    for line, msg in found:
        print("line %d: %s" % (line, msg))
    print("findings:", len(found))


if __name__ == "__main__":
    main(sys.argv[1] if len(sys.argv) > 1 else "samples/security_generated_snippet.txt")