Get answer (#9)

* add get_answer func
* improve auto-submission
* save bad answers too

Author: wimglenn

aocd.py

@@ -20,7 +20,12 @@
 from termcolor import cprint
 
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
+__all__ = [
+    "data", "get_data", "get_answer", "main", "submit", "__version__",
+    "AocdError", "PuzzleUnsolvedError", "AOC_TZ", "current_day",
+    "most_recent_year", "get_cookie",
+]
 
 
 log = getLogger(__name__)
@@ -38,6 +43,10 @@ class AocdError(Exception):
     pass
 
 
+class PuzzleUnsolvedError(AocdError):
+    pass
+
+
 def get_data(session=None, day=None, year=None):
     """
     Get data for day (1-25) and year (>= 2015)
@@ -61,7 +70,7 @@ def get_data(session=None, day=None, year=None):
         if err.errno != errno.ENOENT:
             raise
     else:
-        log.info("reusing existing data %s", memo_fname)
+        log.info("reusing existing data %s", memo_fname.replace(session, "<token>"))
         return data.rstrip("\r\n")
     log.info("getting data year=%s day=%s", year, day)
     t = time.time()
@@ -88,6 +97,45 @@ def get_data(session=None, day=None, year=None):
     return data.rstrip("\r\n")
 
 
+def get_answer(day, year, session=None, level=1):
+    """
+    Get correct answer for day (1-25), year (>= 2015), and level (1 or 2)
+    User's session cookie is needed (puzzle answers differ by user)
+    Note: Answers are only revealed after a correct submission. If you
+    have not already solved the puzzle, this AocdError will be raised.
+    """
+    if session is None:
+        session = get_cookie()
+    memo_fname = MEMO_FNAME.format(session=session, year=year, day=day)
+    part = {1: "a", 2: "b"}[int(level)]
+    answer_fname = memo_fname.replace(".txt", "{}_answer.txt".format(part))
+    if os.path.isfile(answer_fname):
+        with open(answer_fname) as f:
+            return f.read().strip()
+    # check question page for already solved answers
+    uri = URI.format(year=year, day=day)
+    response = requests.get(
+        uri,
+        cookies={"session": session},
+        headers={"User-Agent": USER_AGENT},
+    )
+    soup = bs4.BeautifulSoup(response.text, "html.parser")
+    response.raise_for_status()
+    paras = [p for p in soup.find_all('p') if p.text.startswith("Your puzzle answer was")]
+    if paras:
+        parta_correct_answer = paras[0].code.text
+        save_correct_answer(answer=parta_correct_answer, day=day, year=year, level=1, session=session)
+        if len(paras) > 1:
+            _p1, p2 = paras
+            partb_correct_answer = p2.code.text
+            save_correct_answer(answer=partb_correct_answer, day=day, year=year, level=2, session=session)
+    if os.path.isfile(answer_fname):
+        with open(answer_fname) as f:
+            return f.read().strip()
+    msg = "Answer {}-{}{} is not available".format(year, day, part)
+    raise PuzzleUnsolvedError(msg)
+
+
 def most_recent_year():
     """
     This year, if it's December.
@@ -231,32 +279,6 @@ def get_day_and_year():
     raise AocdError("Failed introspection of day")
 
 
-def user_has_completed_part_a(day, year, session):
-    memo_fname = MEMO_FNAME.format(session=session, year=year, day=day)
-    part_a_answer_fname = memo_fname.replace(".txt", "a_answer.txt")
-    if os.path.isfile(part_a_answer_fname):
-        return True
-    # check question page for already solved answer
-    uri = URI.format(year=year, day=day)
-    response = requests.get(
-        uri,
-        cookies={"session": session},
-        headers={"User-Agent": USER_AGENT},
-    )
-    soup = bs4.BeautifulSoup(response.text, "html.parser")
-    response.raise_for_status()
-    paras = [p for p in soup.find_all('p') if p.text.startswith("Your puzzle answer was")]
-    if paras:
-        parta_correct_answer = paras[0].code.text
-        save_correct_answer(answer=parta_correct_answer, day=day, year=year, level=1, session=session)
-        if len(paras) > 1:
-            _p1, p2 = paras
-            partb_correct_answer = p2.code.text
-            save_correct_answer(answer=partb_correct_answer, day=day, year=year, level=2, session=session)
-        return True
-    return False
-
-
 def save_correct_answer(answer, day, year, level, session):
     memo_fname = MEMO_FNAME.format(session=session, year=year, day=day)
     part = {"1": "a", "2": "b"}[str(level)]
@@ -267,7 +289,30 @@ def save_correct_answer(answer, day, year, level, session):
         f.write(str(answer).strip())
 
 
-def submit(answer, level=None, day=None, year=None, session=None, reopen=True):
+def save_incorrect_answer(answer, day, year, level, session, extra):
+    memo_fname = MEMO_FNAME.format(session=session, year=year, day=day)
+    part = {"1": "a", "2": "b"}[str(level)]
+    answer_fname = memo_fname.replace(".txt", "{}_bad_answers.txt".format(part))
+    _ensure_intermediate_dirs(answer_fname)
+    with open(answer_fname, "a") as f:
+        log.info("caching this data")
+        f.write(str(answer).strip() + " " + extra.replace("\n", " ") + "\n")
+
+
+def get_incorrect_answers(day, year, level, session):
+    memo_fname = MEMO_FNAME.format(session=session, year=year, day=day)
+    part = {"1": "a", "2": "b"}[str(level)]
+    answer_fname = memo_fname.replace(".txt", "{}_bad_answers.txt".format(part))
+    result = {}
+    if os.path.isfile(answer_fname):
+        with open(answer_fname) as f:
+            for line in f:
+                answer, _sep, extra = line.strip().partition(" ")
+                result[answer] = extra
+    return result
+
+
+def submit(answer, level=None, day=None, year=None, session=None, reopen=True, quiet=False):
     if level not in {1, 2, "1", "2", None}:
         raise AocdError("level must be 1 or 2")
     if session is None:
@@ -277,13 +322,22 @@ def submit(answer, level=None, day=None, year=None, session=None, reopen=True):
     if year is None:
         year = most_recent_year()
     if level is None:
-        # figure out if user is submitting for part a or part b
-        if user_has_completed_part_a(day, year, session):
-            log.debug("you already completed part a, submitting for part b")
-            level = 2
-        else:
+        # guess if user is submitting for part a or part b
+        try:
+            get_answer(day=day, year=year, session=session, level=1)
+        except PuzzleUnsolvedError:
             log.debug("submitting for part a")
             level = 1
+        else:
+            log.debug("submitting for part b (part a is already completed)")
+            level = 2
+    bad_guesses = get_incorrect_answers(day=day, year=year, level=level, session=session)
+    if str(answer) in bad_guesses:
+        if not quiet:
+            msg = "aocd will not submit that answer again. You've previously guessed {} and the server responded:"
+            print(msg.format(answer))
+            cprint(bad_guesses[str(answer)], "red")
+        return
     uri = URI.format(year=year, day=day) + "/answer"
     log.info("posting to %s", uri)
     response = requests.post(
@@ -309,10 +363,24 @@ def submit(answer, level=None, day=None, year=None, session=None, reopen=True):
     elif "That's not the right answer" in message:
         color = "red"
         you_guessed = soup.article.span.code.text
-        log.debug("wrong answer %s", you_guessed)
+        log.warning("wrong answer %s", you_guessed)
+        save_incorrect_answer(answer=answer, day=day, year=year, level=level, session=session, extra=soup.article.text)
     elif "You gave an answer too recently" in message:
-        color = "red"
-    cprint(soup.article.text, color=color)
+        wait_pattern = r"You have (?:(\d+)m )?(\d+)s left to wait"
+        try:
+            [(minutes, seconds)] = re.findall(wait_pattern, message)
+        except ValueError:
+            log.warning(message)
+            color = "red"
+        else:
+            wait_time = int(seconds)
+            if minutes:
+                wait_time += 60 * int(minutes)
+            log.info("Waiting %d seconds to autoretry", wait_time)
+            time.sleep(wait_time)
+            return submit(answer=answer, level=level, day=day, year=year, session=session, reopen=reopen, quiet=quiet)
+    if not quiet:
+        cprint(message, color=color)
     return response
 
 
@@ -324,14 +392,14 @@ def main():
         nargs="?",
         type=int,
         choices=range(1,26),
-        default=min(aoc_now.day, 25),
+        default=min(aoc_now.day, 25) if aoc_now.month == 12 else 1,
         help="1-25 (default: %(default)s)",
     )
     parser.add_argument(
         "year",
         nargs="?",
         type=int,
-        choices=range(2015, aoc_now.year + 1),
+        choices=range(2015, aoc_now.year + int(aoc_now.month == 12)),
         default=most_recent_year(),
         help=">= 2015 (default: %(default)s)",
     )
@@ -344,10 +412,7 @@ class Aocd(object):
     _module = sys.modules[__name__]
 
     def __dir__(self):
-        return [
-            "data", "get_data", "main", "submit", "get_day_and_year", "get_cookie",
-            "AocdError", "__version__", "current_day", "most_recent_year",
-        ]
+        return __all__
 
     def __getattr__(self, name):
         if name == "data":

tests/conftest.py

@@ -1,6 +1,12 @@
 import pytest
 
 
+@pytest.fixture(autouse=True)
+def mocked_sleep(mocker):
+    no_sleep_till_brooklyn = mocker.patch("aocd._module.time.sleep")
+    return no_sleep_till_brooklyn
+
+
 @pytest.fixture(autouse=True)
 def remove_user_env(tmpdir, monkeypatch):
     token_file = tmpdir / ".config/aocd/token"

tests/test_get_answer.py

@@ -0,0 +1,9 @@
+import aocd
+
+
+def test_get_answer(tmpdir):
+    saved = tmpdir / ".config/aocd/thetesttoken/2017/13b_answer.txt"
+    saved.ensure(file=True)
+    saved.write("the answer")
+    answer = aocd.get_answer(day=13, year=2017, level=2)
+    assert answer == "the answer"

tests/test_get_data.py

@@ -6,12 +6,6 @@
 from aocd import AocdError
 
 
-@pytest.fixture(autouse=True)
-def mocked_sleep(mocker):
-    no_sleep_till_brooklyn = mocker.patch("aocd._module.time.sleep")
-    return no_sleep_till_brooklyn
-
-
 def test_get_from_server(requests_mock):
     mock = requests_mock.get(
         url="https://adventofcode.com/2018/day/1/input",
@@ -77,7 +71,7 @@ def test_aocd_user_agent_in_req_headers(requests_mock):
     aocd.get_data(year=2018, day=1)
     assert mock.call_count == 1
     headers = mock.last_request._request.headers
-    assert headers["User-Agent"] == "aocd.py/v0.6.0"
+    assert headers["User-Agent"] == "aocd.py/v{}".format(aocd.__version__)
 
 
 def test_data_is_cached_from_successful_request(tmpdir, requests_mock):

tests/test_submit.py

@@ -63,15 +63,43 @@ def test_submit_when_already_solved(requests_mock, capsys):
     assert msg in out
 
 
-def test_submit_when_submitted_too_recently(requests_mock, capsys):
-    html = '''<article><p>You gave an answer too recently; you have to wait after submitting an answer before trying again.  You have 30s left to wait. <a href="/2015/day/25">[Return to Day 25]</a></p></article>'''
+def test_submit_when_submitted_too_recently_and_autoretry(requests_mock, capsys, mocked_sleep):
+    html1 = '''<article><p>You gave an answer too recently; you have to wait after submitting an answer before trying again.  You have 30s left to wait. <a href="/2015/day/25">[Return to Day 25]</a></p></article>'''
+    html2 = "<article>That's the right answer. Yeah!!</article>"
+    requests_mock.post(
+        "https://adventofcode.com/2015/day/25/answer",
+        [{"text": html1}, {"text": html2}],
+    )
+    submit(1234, level=1, year=2015, day=25, reopen=False)
+    mocked_sleep.assert_called_once_with(30)
+    out, err = capsys.readouterr()
+    msg = "That's the right answer. Yeah!!"
+    msg = colored(msg, "green")
+    assert msg in out
+
+
+def test_submit_when_submitted_too_recently_and_autoretry_and_quiet(requests_mock, capsys, mocked_sleep):
+    html1 = '''<article><p>You gave an answer too recently; you have to wait after submitting an answer before trying again.  You have 3m 30s left to wait. <a href="/2015/day/25">[Return to Day 25]</a></p></article>'''
+    html2 = "<article>That's the right answer. Yeah!!</article>"
+    requests_mock.post(
+        "https://adventofcode.com/2015/day/25/answer",
+        [{"text": html1}, {"text": html2}],
+    )
+    submit(1234, level=1, year=2015, day=25, reopen=False, quiet=True)
+    mocked_sleep.assert_called_once_with(3*60 + 30)
+    out, err = capsys.readouterr()
+    assert out == err == ""
+
+
+def test_submit_when_submitted_too_recently_no_autoretry(requests_mock, capsys):
+    html = '''<article><p>You gave an answer too recently</p></article>'''
     requests_mock.post(
         url="https://adventofcode.com/2015/day/25/answer",
         text=html,
     )
     submit(1234, level=1, year=2015, day=25, reopen=False)
     out, err = capsys.readouterr()
-    msg = "You gave an answer too recently; you have to wait after submitting an answer before trying again.  You have 30s left to wait. [Return to Day 25]"
+    msg = "You gave an answer too recently"
     msg = colored(msg, "red")
     assert msg in out
 
@@ -203,3 +231,16 @@ def test_failure_to_create_dirs_unhandled(mocker):
     err.errno = errno.EEXIST
     mocker.patch("aocd._module.os.makedirs", side_effect=[TypeError, err])
     aocd._module._ensure_intermediate_dirs("/")
+
+
+def test_cannot_submit_same_bad_answer_twice(requests_mock, capsys):
+    mock = requests_mock.post(
+        url="https://adventofcode.com/2015/day/1/answer",
+        text="<article><p>That's not the right answer. (You guessed <span><code>69</code>.)</span></a></p></article>",
+    )
+    submit(year=2015, day=1, level=1, answer=69)
+    submit(year=2015, day=1, level=1, answer=69)
+    submit(year=2015, day=1, level=1, answer=69, quiet=True)
+    assert mock.call_count == 1
+    out, err = capsys.readouterr()
+    assert "aocd will not submit that answer again" in out