eclass.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""eclass-cli — 한국 대학 이클래스(Canvas LMS) 과제를 터미널에서 제출하는 CLI.

Usage:
  python eclass.py init                  # 최초 설정: 학교 선택 + 토큰 + 기본 과목
  python eclass.py list                  # 과제 목록 (마감 임박순, D-day)
  python eclass.py link [URL]            # 현재 폴더를 과제에 바인딩
  python eclass.py push [FILE] [옵션]    # 과제 제출
  python eclass.py status                # 제출 상태 확인

Config:
  ~/.eclass/config.json  base_url
  ~/.eclass/token        Canvas 액세스 토큰
  ./.eclass              폴더별 바인딩 (course_id, assignment_id, file glob, as)

과목은 config에 고정하지 않고 매번 활성 과목 전체를 조회한다 —
학기 중 과목이 새로 생겨도 다음 실행부터 자동으로 나타난다.
"""
import argparse
import datetime
import getpass
import glob as globmod
import json
import os
import re
import sys

import requests

CFG_DIR = os.path.join(os.path.expanduser("~"), ".eclass")
LOCAL_CFG = ".eclass"

# 검증된 학교 프리셋. (이름, API base_url, 토큰 발급 페이지)
# 다른 LearningX/Canvas 학교는 PR로 추가해주세요.
SCHOOLS = [
    ("중앙대학교", "https://eclass3.cau.ac.kr", "https://eclass3.cau.ac.kr/profile/settings"),
]

KST = datetime.timezone(datetime.timedelta(hours=9))


def die(msg, code=1):
    print(f"오류: {msg}", file=sys.stderr)
    sys.exit(code)


def kst(iso):
    """Canvas UTC ISO 문자열 → 'YYYY-MM-DD HH:MM (KST)'"""
    if not iso:
        return None
    dt = datetime.datetime.fromisoformat(iso.replace("Z", "+00:00")).astimezone(KST)
    return dt.strftime("%Y-%m-%d %H:%M")


def dday(iso):
    if not iso:
        return ""
    due = datetime.datetime.fromisoformat(iso.replace("Z", "+00:00"))
    days = (due - datetime.datetime.now(datetime.timezone.utc)).days
    if days < 0:
        return "마감지남"
    return f"D-{days}" if days > 0 else "D-DAY"


# ---------------------------------------------------------------- config

def load_cfg(require=True):
    try:
        with open(os.path.join(CFG_DIR, "config.json"), encoding="utf-8") as f:
            cfg = json.load(f)
        with open(os.path.join(CFG_DIR, "token"), encoding="utf-8") as f:
            cfg["token"] = f.read().strip()
        return cfg
    except FileNotFoundError:
        if require:
            die("설정이 없습니다. 먼저 `eclass init`을 실행하세요.")
        return None


def save_cfg(cfg):
    data = {"base_url": cfg["base_url"]}
    if cfg.get("muted"):
        data["muted"] = sorted(cfg["muted"])
    with open(os.path.join(CFG_DIR, "config.json"), "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def load_local():
    try:
        with open(LOCAL_CFG, encoding="utf-8") as f:
            return json.load(f)
    except FileNotFoundError:
        return {}


def session(cfg):
    s = requests.Session()
    s.headers["Authorization"] = f"Bearer {cfg['token']}"
    return s


def api(cfg, s, method, path, **kw):
    r = s.request(method, f"{cfg['base_url']}/api/v1{path}", **kw)
    if r.status_code == 401:
        die("인증 실패(401). 토큰이 만료됐을 수 있습니다.\n"
            "  학교 이클래스 로그인 → 계정 → 설정 → '+ 새 액세스 토큰' 재발급 후\n"
            f"  {os.path.join(CFG_DIR, 'token')} 파일 내용을 교체하세요.")
    r.raise_for_status()
    return r.json()


def parse_url(url):
    """과제/과목 URL → (course_id, assignment_id|None)"""
    m = re.search(r"/courses/(\d+)(?:/assignments/(\d+))?", url)
    if not m:
        return None, None
    return int(m.group(1)), int(m.group(2)) if m.group(2) else None


def pick(items, label_fn, prompt):
    """번호 선택 프롬프트. items 비면 None."""
    if not items:
        return None
    for i, it in enumerate(items, 1):
        print(f"  [{i}] {label_fn(it)}")
    while True:
        raw = input(f"{prompt} (1-{len(items)}, q=취소): ").strip()
        if raw.lower() == "q":
            return None
        if raw.isdigit() and 1 <= int(raw) <= len(items):
            return items[int(raw) - 1]


# ---------------------------------------------------------------- init

def cmd_init(args):
    print("eclass-cli 초기 설정\n")
    print("학교를 선택하세요:")
    for i, (name, _, _) in enumerate(SCHOOLS, 1):
        print(f"  [{i}] {name}")
    print(f"  [{len(SCHOOLS) + 1}] 직접 입력 (다른 Canvas/LearningX 학교)")
    raw = input(f"선택 (1-{len(SCHOOLS) + 1}): ").strip()
    if raw.isdigit() and 1 <= int(raw) <= len(SCHOOLS):
        name, base_url, settings_url = SCHOOLS[int(raw) - 1]
    else:
        base_url = input("이클래스 주소 (예: https://eclass3.cau.ac.kr): ").strip().rstrip("/")
        settings_url = f"{base_url}/profile/settings"

    print(f"\n액세스 토큰 발급: 이클래스 로그인 후 아래 주소에서")
    print(f"  {settings_url}")
    print("  '+ 새 액세스 토큰' → 목적 입력, 만료일은 학기 말 추천 → 생성된 토큰 복사")
    # getpass는 Windows에서 콘솔 전용이라 파이프/Colab 등 비-tty에선 input()으로 폴백
    if sys.stdin.isatty():
        token = getpass.getpass("토큰 붙여넣기 (입력 안 보임): ").strip()
    else:
        token = input("토큰 붙여넣기: ").strip()
    if not token:
        die("토큰이 비어 있습니다.")

    cfg = {"base_url": base_url, "token": token}
    s = session(cfg)
    me = api(cfg, s, "GET", "/users/self")
    print(f"\n인증 성공: {me['name']}")
    courses = active_courses(cfg, s)
    print(f"수강 과목 {len(courses)}개: " + ", ".join(c["name"] for c in courses))

    os.makedirs(CFG_DIR, exist_ok=True)
    with open(os.path.join(CFG_DIR, "token"), "w", encoding="utf-8") as f:
        f.write(token)
    try:
        os.chmod(os.path.join(CFG_DIR, "token"), 0o600)
    except OSError:
        pass
    with open(os.path.join(CFG_DIR, "config.json"), "w", encoding="utf-8") as f:
        json.dump({"base_url": base_url}, f, ensure_ascii=False, indent=2)
    print(f"설정 저장 완료: {CFG_DIR}")
    print("이제 `eclass list`로 과제를 확인하세요.")


# ---------------------------------------------------------------- list

def active_courses(cfg, s):
    """활성 과목 전체. 과목은 학기 중에도 늘어나므로 config에 고정하지 않는다."""
    cs = api(cfg, s, "GET", "/courses",
             params={"enrollment_state": "active", "per_page": 100})
    return [c for c in cs if c.get("name")]


def fetch_assignments(cfg, s, course_id):
    return api(cfg, s, "GET", f"/courses/{course_id}/assignments",
               params={"per_page": 100, "include[]": "submission"})


def fetch_all(cfg, s, course_id=None):
    """[(course, assignment), ...] — course_id 지정 시 해당 과목만."""
    if course_id:
        courses = [api(cfg, s, "GET", f"/courses/{course_id}")]
    else:
        courses = active_courses(cfg, s)
    return [(c, a) for c in courses for a in fetch_assignments(cfg, s, c["id"])]


def find_course(cfg, s, assignment_id):
    """과제 ID만 알 때 활성 과목들에서 소속 과목을 찾는다."""
    for c in active_courses(cfg, s):
        r = s.get(f"{cfg['base_url']}/api/v1/courses/{c['id']}/assignments/{assignment_id}")
        if r.ok:
            return c["id"]
    die(f"활성 과목들에서 과제 {assignment_id}를 찾지 못했습니다.")


def sort_key(a):
    sub = a.get("submission") or {}
    submitted = sub.get("workflow_state") == "submitted"
    due = a.get("due_at") or "9999"
    return (submitted, due, a["created_at"])


def cmd_list(args):
    cfg = load_cfg()
    s = session(cfg)
    pairs = fetch_all(cfg, s, args.course)
    muted = set(cfg.get("muted", []))
    hidden = sum(1 for _, a in pairs if a["id"] in muted)
    if not args.all:
        pairs = [(c, a) for c, a in pairs if a["id"] not in muted]

    if args.json:
        out = [{
            "course_id": c["id"], "course": c["name"],
            "id": a["id"], "name": a["name"].strip(),
            "due_kst": kst(a.get("due_at")), "dday": dday(a.get("due_at")),
            "state": (a.get("submission") or {}).get("workflow_state"),
            "submitted_at_kst": kst((a.get("submission") or {}).get("submitted_at")),
            "attempt": (a.get("submission") or {}).get("attempt"),
            "muted": a["id"] in muted,
        } for c, a in sorted(pairs, key=lambda p: (p[0]["id"], sort_key(p[1])))]
        print(json.dumps(out, ensure_ascii=False, indent=1))
        return

    shown = False
    for c in {id(c): c for c, _ in pairs}.values():
        rows = sorted((a for cc, a in pairs if cc is c), key=sort_key)
        if not rows:
            continue
        shown = True
        print(f"\n📚 {c['name']}  [{c['id']}] — 과제 {len(rows)}개 (미제출·마감 임박순)")
        for a in rows:
            sub = a.get("submission") or {}
            mark = "🔇" if a["id"] in muted else \
                "✅" if sub.get("workflow_state") == "submitted" else "⬜"
            due = kst(a.get("due_at"))
            due_s = f"마감 {due} {dday(a.get('due_at'))}" if due else "마감 없음"
            print(f" {mark} [{a['id']}] {a['name'].strip()}  ({due_s})")
    if not shown:
        print("표시할 과제가 없습니다.")
    if hidden and not args.all:
        print(f"\n(숨김 {hidden}건 — `eclass list --all`로 표시, `eclass unmute <id>`로 해제)")


# ---------------------------------------------------------------- link

def cmd_link(args):
    cfg = load_cfg()
    s = session(cfg)
    course_id, assignment_id = (parse_url(args.url) if args.url else (None, None))
    if args.url and not course_id:
        die("URL에서 과목/과제 번호를 찾지 못했습니다. (…/courses/<id>/assignments/<id> 형태)")

    if not assignment_id:
        pairs = sorted(fetch_all(cfg, s, course_id), key=lambda p: sort_key(p[1]))
        chosen = pick(pairs, lambda p: f"[{p[0]['name']}] {p[1]['name'].strip()} "
                      f"({'제출됨' if (p[1].get('submission') or {}).get('workflow_state') == 'submitted' else '미제출'})",
                      "바인딩할 과제 선택")
        if not chosen:
            die("과제를 선택하지 않았습니다.")
        course_id, assignment_id = chosen[0]["id"], chosen[1]["id"]

    local = {"course_id": course_id, "assignment_id": assignment_id}
    if args.file:
        local["file"] = args.file
    if args.as_name:
        local["as"] = args.as_name
    with open(LOCAL_CFG, "w", encoding="utf-8") as f:
        json.dump(local, f, ensure_ascii=False, indent=2)
    print(f"바인딩 완료: {os.path.abspath(LOCAL_CFG)}")
    print(f"  과목 {course_id} / 과제 {assignment_id}"
          + (f" / 파일 패턴 {args.file}" if args.file else ""))
    print("이제 이 폴더에서 `eclass push`만 치면 됩니다.")


# ---------------------------------------------------------------- push

def newest(paths):
    paths = [p for p in paths if os.path.isfile(p)]
    return max(paths, key=os.path.getmtime) if paths else None


def resolve_file(args, local):
    """제출 파일 경로 리스트를 돌려준다."""
    if args.file:
        for f in args.file:
            if not os.path.isfile(f):
                die(f"파일이 없습니다: {f}")
        return list(args.file)
    if local.get("file"):
        f = newest(globmod.glob(local["file"]))
        if f:
            return [f]
        die(f"패턴에 맞는 파일이 없습니다: {local['file']}")
    if args.downloads:
        dl = os.path.join(os.path.expanduser("~"), "Downloads")
        f = newest(globmod.glob(os.path.join(dl, "*")))
        if not f:
            die("다운로드 폴더가 비어 있습니다.")
        return [f]
    # 폴백: 현재 폴더 최근 수정 파일 3개 중 선택
    cands = sorted((p for p in globmod.glob("*") if os.path.isfile(p) and p != LOCAL_CFG),
                   key=os.path.getmtime, reverse=True)[:3]
    if not cands:
        die("제출할 파일을 찾지 못했습니다. `eclass push <파일>`로 지정하세요.")
    return [pick(cands, lambda p: f"{p} ({kst(datetime.datetime.fromtimestamp(os.path.getmtime(p), tz=datetime.timezone.utc).isoformat())} 수정)",
                 "제출할 파일 선택")]


def resolve_assignment(cfg, s, args, local):
    if args.url:
        c, a = parse_url(args.url)
        if a:
            return c, a
        die("URL에 과제 번호가 없습니다.")
    if args.assignment:
        course_id = args.course or local.get("course_id") \
            or find_course(cfg, s, args.assignment)
        return course_id, args.assignment
    if local.get("assignment_id"):
        return local["course_id"], local["assignment_id"]
    muted = set(cfg.get("muted", []))
    pairs = [p for p in fetch_all(cfg, s, args.course) if p[1]["id"] not in muted]
    unsub = [p for p in pairs
             if (p[1].get("submission") or {}).get("workflow_state") != "submitted"]
    chosen = pick(sorted(unsub or pairs, key=lambda p: sort_key(p[1])),
                  lambda p: f"[{p[0]['name']}] {p[1]['name'].strip()}", "제출할 과제 선택")
    if not chosen:
        die("과제를 선택하지 않았습니다.")
    return chosen[0]["id"], chosen[1]["id"]


def cmd_push(args):
    cfg = load_cfg()
    s = session(cfg)
    local = load_local()

    course_id, assignment_id = resolve_assignment(cfg, s, args, local)
    paths = resolve_file(args, local)
    if not paths:
        die("파일을 선택하지 않았습니다.")
    as_name = args.as_name or local.get("as")
    if as_name and len(paths) > 1:
        die("--as는 파일이 하나일 때만 사용할 수 있습니다.")

    a = api(cfg, s, "GET", f"/courses/{course_id}/assignments/{assignment_id}",
            params={"include[]": "submission"})
    if "online_upload" not in (a.get("submission_types") or []):
        die(f"이 과제는 파일 업로드형이 아닙니다: {a.get('submission_types')}. 이클래스에서 직접 제출하세요.")
    sub = a.get("submission") or {}

    print(f"\n제출 내용 확인")
    print(f"  과제:   {a['name'].strip()}  [{assignment_id}]")
    for path in paths:
        print(f"  파일:   {os.path.abspath(path)} ({os.path.getsize(path):,} bytes)")
    if as_name and as_name != os.path.basename(paths[0]):
        print(f"  제출명: {as_name}  ← 제출 시 이 이름으로 표시")
    if a.get("due_at"):
        print(f"  마감:   {kst(a['due_at'])} (KST) {dday(a['due_at'])}")
    if sub.get("workflow_state") == "submitted":
        print(f"  ⚠️  이미 제출된 과제입니다 ({kst(sub.get('submitted_at'))} KST, attempt {sub.get('attempt')}).")
        print(f"      다시 제출하면 재제출(attempt {(sub.get('attempt') or 0) + 1})로 기록됩니다.")
    if not args.yes:
        if input("제출할까요? [y/N]: ").strip().lower() != "y":
            print("취소했습니다.")
            return

    # Canvas 3단계 업로드: 슬롯 요청 → 파일 POST → 확인 (파일별 업로드 후 한 번에 제출)
    file_ids = []
    for path in paths:
        upload_name = as_name or os.path.basename(path)
        slot = api(cfg, s, "POST",
                   f"/courses/{course_id}/assignments/{assignment_id}/submissions/self/files",
                   data={"name": upload_name, "size": os.path.getsize(path)})
        with open(path, "rb") as f:
            r = requests.post(slot["upload_url"], data=slot["upload_params"],
                              files={"file": (upload_name, f)}, allow_redirects=False)
        if r.status_code in (301, 302, 303):
            info = s.get(r.headers["Location"]).json()
        else:
            r.raise_for_status()
            info = r.json()
        file_ids.append(info["id"])

    api(cfg, s, "POST", f"/courses/{course_id}/assignments/{assignment_id}/submissions",
        data={"submission[submission_type]": "online_upload",
              "submission[file_ids][]": file_ids})

    v = api(cfg, s, "GET", f"/courses/{course_id}/assignments/{assignment_id}/submissions/self")
    ok = v.get("workflow_state") == "submitted"
    print(f"\n{'✅ 제출 완료' if ok else '⚠️ 상태 확인 필요'}: {kst(v.get('submitted_at'))} (KST)"
          f", attempt {v.get('attempt')}{', 지각 제출' if v.get('late') else ''}")
    for att in v.get("attachments") or []:
        print(f"   파일: {att.get('display_name')}")


# ---------------------------------------------------------------- mute

def cmd_mute(args, off=False):
    cfg = load_cfg()
    muted = set(cfg.get("muted", []))
    if off:
        if args.assignment not in muted:
            die(f"과제 {args.assignment}은(는) 숨김 상태가 아닙니다.")
        muted.discard(args.assignment)
    else:
        muted.add(args.assignment)
    cfg["muted"] = muted
    save_cfg(cfg)
    print(f"과제 {args.assignment} {'숨김 해제' if off else '숨김'} 완료"
          + ("" if off else " — `eclass list --all`에서 🔇로 표시됩니다"))


# ---------------------------------------------------------------- status

def cmd_status(args):
    cfg = load_cfg()
    s = session(cfg)
    local = load_local()
    assignment_id = args.assignment or local.get("assignment_id")
    if not assignment_id:
        die("확인할 과제가 없습니다. 이 폴더를 `eclass link`로 바인딩하거나 --assignment를 지정하세요.")
    course_id = args.course or local.get("course_id") \
        or find_course(cfg, s, assignment_id)
    a = api(cfg, s, "GET", f"/courses/{course_id}/assignments/{assignment_id}",
            params={"include[]": "submission"})
    sub = a.get("submission") or {}
    print(f"과제: {a['name'].strip()}  [{assignment_id}]")
    if sub.get("workflow_state") == "submitted":
        print(f"  ✅ 제출됨 — {kst(sub.get('submitted_at'))} (KST), attempt {sub.get('attempt')}")
    else:
        print(f"  ⬜ 미제출" + (f" — 마감 {kst(a.get('due_at'))} {dday(a.get('due_at'))}" if a.get("due_at") else ""))


# ---------------------------------------------------------------- main

def main():
    p = argparse.ArgumentParser(prog="eclass", description="한국 대학 이클래스(Canvas LMS) 과제 제출 CLI")
    sp = p.add_subparsers(dest="cmd", required=True)

    sp.add_parser("init", help="최초 설정 (학교·토큰·기본 과목)")

    pl = sp.add_parser("list", help="과제 목록 (미제출·마감 임박순)")
    pl.add_argument("--course", type=int, help="이 과목만 표시 (기본: 전체)")
    pl.add_argument("--all", action="store_true", help="숨긴(mute) 과제도 표시")
    pl.add_argument("--json", action="store_true", help="JSON 출력")

    pk = sp.add_parser("link", help="현재 폴더를 과제에 바인딩")
    pk.add_argument("url", nargs="?", help="과제 페이지 URL (없으면 대화형 선택)")
    pk.add_argument("--file", help="제출 파일 glob 패턴 (예: '*.ipynb')")
    pk.add_argument("--as", dest="as_name", help="제출 시 표시할 파일명")

    pp = sp.add_parser("push", help="과제 제출")
    pp.add_argument("file", nargs="*", help="제출 파일 (여러 개면 한 제출에 함께 첨부, 없으면 자동 탐색)")
    pp.add_argument("--url", help="과제 페이지 URL")
    pp.add_argument("--assignment", type=int, help="과제 ID")
    pp.add_argument("--course", type=int, help="과목 ID")
    pp.add_argument("--as", dest="as_name", help="제출 시 표시할 파일명 (로컬 파일명 그대로 유지)")
    pp.add_argument("--downloads", action="store_true", help="다운로드 폴더의 최신 파일 제출")
    pp.add_argument("--yes", action="store_true", help="확인 프롬프트 생략")

    ps = sp.add_parser("status", help="제출 상태 확인")
    ps.add_argument("--assignment", type=int)
    ps.add_argument("--course", type=int)

    pm = sp.add_parser("mute", help="과제를 목록에서 숨김 (제출 안 하는 과제)")
    pm.add_argument("assignment", type=int, help="과제 ID")
    pu = sp.add_parser("unmute", help="숨김 해제")
    pu.add_argument("assignment", type=int, help="과제 ID")

    args = p.parse_args()
    {"init": cmd_init, "list": cmd_list, "link": cmd_link,
     "push": cmd_push, "status": cmd_status,
     "mute": cmd_mute, "unmute": lambda a: cmd_mute(a, off=True)}[args.cmd](args)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n취소했습니다.")
        sys.exit(130)
    except requests.RequestException as e:
        die(f"네트워크/API 오류: {e}")