refactor (#12)

- factor out runner for aocr to use
- more logging
- change tmpdir to tmp_path
- update CI matrix

Author: wimglenn

.travis.yml

@@ -4,21 +4,13 @@ sudo: false
 
 python:
   - "2.7"
-  - "3.5"
   - "3.6"
+  - "3.7"
+  - "3.8"
   - "pypy"
-  - "pypy3.5"
+  - "pypy3"
   - "nightly"
 
-matrix:
-  fast_finish: true
-  allow_failures:
-  - python: "nightly"
-  include:
-    - python: 3.7
-      dist: xenial
-      sudo: true
-
 install:
   - pip install --upgrade pytest setuptools
   - pip install --editable .

aocd/__init__.py

@@ -7,16 +7,22 @@
 import sys
 from functools import partial
 
-from .get import get_data
-from .get import get_day_and_year
+from . import cli
+from . import exceptions
+from . import get
+from . import models
+from . import post
+from . import runner
+from . import utils
+from . import version
 from .exceptions import AocdError
 from .exceptions import PuzzleUnsolvedError
+from .get import get_data
+from .get import get_day_and_year
 from .post import submit
 from .utils import AOC_TZ
 from .version import __version__
 
-from . import cli, exceptions, get, models, post, runner, utils, version
-
 
 __all__ = [
     "cli",

aocd/models.py

@@ -63,6 +63,8 @@ def default_user():
         You can find it in your browser cookies after login.
             1) Save the cookie into a text file {}, or
             2) Export the cookie in environment variable AOC_SESSION
+
+        See https://github.com/wimglenn/advent-of-code-wim/issues/1 for more info.
         """
     )
     cprint(msg.format(AOCD_DIR + "/token"), color="red", file=sys.stderr)
@@ -98,6 +100,10 @@ def user(self):
 
     @property
     def input_data(self):
+        if self.user.token == ".aocr":
+            with open("input.txt") as f:
+                return f.read()
+        sanitized = "..." + self.user.token[-4:]
         try:
             # use previously received data, if any existing
             with io.open(self.input_data_fname, encoding="utf-8") as f:
@@ -106,22 +112,21 @@ def input_data(self):
             if err.errno != errno.ENOENT:
                 raise
         else:
-            sanitized = self.user.token[:4] + "..." + self.user.token[-4:]
             sanitized_path = self.input_data_fname.replace(self.user.token, sanitized)
-            log.info("reusing existing data %s", sanitized_path)
+            log.debug("reusing existing data %s", sanitized_path)
             return data.rstrip("\r\n")
-        log.info("getting data year=%s day=%s", self.year, self.day)
+        log.info("getting data year=%s day=%s token=%s", self.year, self.day, sanitized)
         response = requests.get(
             url=self.input_data_url, cookies=self._cookies, headers=self._headers
         )
         if not response.ok:
-            log.error("got %s status code", response.status_code)
+            log.error("got %s status code token=%s", response.status_code, sanitized)
             log.error(response.text)
             raise AocdError("Unexpected response")
         data = response.text
         _ensure_intermediate_dirs(self.input_data_fname)
         with open(self.input_data_fname, "w") as f:
-            log.info("saving the puzzle input")
+            log.info("saving the puzzle input token=%s", sanitized)
             f.write(data)
         return data.rstrip("\r\n")
 
@@ -200,7 +205,8 @@ def _submit(self, value, part, reopen=True, quiet=False):
                 cprint(bad_guesses[str(value)], "red")
             return
         url = self.submit_url
-        log.info("posting %r to %s (part %s)", value, url, part)
+        sanitized = "..." + self.user.token[-4:]
+        log.info("posting %r to %s (part %s) token=%s", value, url, part, sanitized)
         level = {"a": 1, "b": 2}[part]
         response = requests.post(
             url=url,
@@ -285,6 +291,8 @@ def _get_answer(self, part):
         Note: Answers are only revealed after a correct submission. If you've
         have not already solved the puzzle, AocdError will be raised.
         """
+        if part == "b" and self.day == 25:
+            return None
         answer_fname = getattr(self, "answer_{}_fname".format(part))
         if os.path.isfile(answer_fname):
             with open(answer_fname) as f:

aocd/post.py

@@ -6,9 +6,9 @@
 
 import logging
 
+from .exceptions import AocdError
 from .get import current_day
 from .get import most_recent_year
-from .exceptions import AocdError
 from .models import default_user
 from .models import Puzzle
 from .models import User

aocd/runner.py

@@ -8,14 +8,15 @@
 import json
 import logging
 import os
-import pkg_resources
 import sys
+import tempfile
 import time
 from argparse import ArgumentParser
 from collections import OrderedDict
 from datetime import datetime
 
 import pebble
+import pkg_resources
 from termcolor import colored
 
 from .models import default_user
@@ -81,17 +82,18 @@ def run_with_timeout(entry_point, timeout, progress, dt=0.1, **kwargs):
     # TODO : multi-process over the different tokens
     spinner = itertools.cycle(r"\|/-")
     pool = pebble.ProcessPool(max_workers=1)
-    line = walltime = format_time(0)
+    line = elapsed = format_time(0)
     with pool:
         t0 = time.time()
         func = entry_point.load()
         future = pool.schedule(func, kwargs=kwargs, timeout=timeout)
         while not future.done():
-            line = "\r" + walltime + "   " + progress + "   " + next(spinner)
-            sys.stderr.write(line)
-            sys.stderr.flush()
+            if progress is not None:
+                line = "\r" + elapsed + "   " + progress + "   " + next(spinner)
+                sys.stderr.write(line)
+                sys.stderr.flush()
             time.sleep(dt)
-            walltime = format_time(time.time() - t0)
+            elapsed = format_time(time.time() - t0, timeout)
         walltime = time.time() - t0
         try:
             a, b = future.result()
@@ -100,8 +102,12 @@ def run_with_timeout(entry_point, timeout, progress, dt=0.1, **kwargs):
             crashed = True
         else:
             crashed = False
-    sys.stderr.write("\r" + " " * len(line) + "\r")
-    sys.stderr.flush()
+            # longest correct answer seen so far has been 32 chars
+            a = str(a)[:50]
+            b = str(b)[:50]
+    if progress is not None:
+        sys.stderr.write("\r" + " " * len(line) + "\r")
+        sys.stderr.flush()
     return a, b, walltime, crashed
 
 
@@ -116,6 +122,29 @@ def format_time(t, timeout=DEFAULT_TIMEOUT):
     return runtime
 
 
+def run_one(year, day, input_data, entry_point, timeout=DEFAULT_TIMEOUT, progress=None):
+    prev = os.getcwd()
+    scratch = tempfile.mkdtemp(prefix="{}-{:02d}-".format(year, day))
+    os.chdir(scratch)
+    assert not os.path.exists("input.txt")
+    try:
+        with open("input.txt", "w") as f:
+            f.write(input_data)
+        a, b, walltime, crashed = run_with_timeout(
+            entry_point=entry_point,
+            timeout=timeout,
+            year=year,
+            day=day,
+            data=input_data,
+            progress=progress,
+        )
+    finally:
+        os.unlink("input.txt")
+        os.chdir(prev)
+        os.rmdir(scratch)
+    return a, b, walltime, crashed
+
+
 def run_for(plugins, years, days, datasets, timeout=DEFAULT_TIMEOUT, autosubmit=True):
     aoc_now = datetime.now(tz=AOC_TZ)
     all_entry_points = pkg_resources.iter_entry_points(group="adventofcode.user")
@@ -130,17 +159,20 @@ def run_for(plugins, years, days, datasets, timeout=DEFAULT_TIMEOUT, autosubmit=
     for year, day, plugin, dataset in it:
         if year == aoc_now.year and day > aoc_now.day:
             continue
-        os.environ["AOC_SESSION"] = datasets[dataset]
+        token = datasets[dataset]
+        entry_point = entry_points[plugin]
+        os.environ["AOC_SESSION"] = token
         puzzle = Puzzle(year=year, day=day)
-        progress = "{0.year}/{0.day:<2d} - {0.title:<40}   {1:>%d}/{2:<%d}"
+        title = puzzle.title
+        progress = "{}/{:<2d} - {:<40}   {:>%d}/{:<%d}"
         progress %= (userpad, datasetpad)
-        progress = progress.format(puzzle, plugin, dataset)
-        a, b, walltime, crashed = run_with_timeout(
-            entry_point=entry_points[plugin],
+        progress = progress.format(year, day, title, plugin, dataset)
+        a, b, walltime, crashed = run_one(
+            year=year,
+            day=day,
+            input_data=puzzle.input_data,
+            entry_point=entry_point,
             timeout=timeout,
-            year=puzzle.year,
-            day=puzzle.day,
-            data=puzzle.input_data,
             progress=progress,
         )
         runtime = format_time(walltime, timeout)
@@ -162,6 +194,8 @@ def run_for(plugins, years, days, datasets, timeout=DEFAULT_TIMEOUT, autosubmit=
                     except AttributeError:
                         pass
             correct = str(expected) == answer
+            if crashed:
+                assert not correct
             icon = colored("✔", "green") if correct else colored("✖", "red")
             correction = ""
             if not correct:

setup.cfg

@@ -33,4 +33,5 @@
         "pebble",
         'colorama; platform_system == "Windows"',
     ],
+    options={"bdist_wheel": {"universal": "1"}},
 )

setup.py

@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import pytest
 
 
@@ -7,24 +9,24 @@ def mocked_sleep(mocker):
     return no_sleep_till_brooklyn
 
 
-@pytest.fixture(autouse=True)
-def remove_user_env(tmpdir, monkeypatch):
-    memo_dir = tmpdir / ".config/aocd"
-    monkeypatch.setattr("aocd.runner.AOCD_DIR", str(memo_dir))
-    monkeypatch.setattr("aocd.models.AOCD_DIR", str(memo_dir))
-    monkeypatch.delenv("AOC_SESSION", raising=False)
-
-
 @pytest.fixture
-def aocd_dir(tmpdir):
-    data_dir = tmpdir / ".config/aocd"
-    data_dir.ensure_dir()
+def aocd_dir(tmp_path):
+    data_dir = tmp_path / ".config" / "aocd"
+    data_dir.mkdir(parents=True)
     return data_dir
 
 
+@pytest.fixture(autouse=True)
+def remove_user_env(aocd_dir, monkeypatch):
+    monkeypatch.setattr("aocd.runner.AOCD_DIR", str(aocd_dir))
+    monkeypatch.setattr("aocd.models.AOCD_DIR", str(aocd_dir))
+    monkeypatch.delenv("AOC_SESSION", raising=False)
+
+
 @pytest.fixture(autouse=True)
 def test_token(aocd_dir):
     token_file = aocd_dir / "token"
-    token_file.ensure(file=True)
-    token_file.write("thetesttoken")
+    token_dir = aocd_dir / "thetesttoken"
+    token_dir.mkdir()
+    token_file.write_text("thetesttoken")
     return token_file

tests/conftest.py

@@ -1,11 +1,13 @@
+from __future__ import unicode_literals
+
 import pytest
 
 from aocd.exceptions import AocdError
 from aocd.models import default_user
 
 
 def test_no_session_id(test_token, capsys):
-    test_token.remove()
+    test_token.unlink()
     with pytest.raises(AocdError("Missing session ID")):
         default_user()
     out, err = capsys.readouterr()
@@ -20,7 +22,7 @@ def test_get_session_id_from_env(monkeypatch):
 
 
 def test_get_session_id_from_file(test_token):
-    test_token.write("tokenfromfile")
+    test_token.write_text("tokenfromfile")
     user = default_user()
     assert user.token == "tokenfromfile"
 
@@ -32,7 +34,7 @@ def test_env_takes_priority_over_file(monkeypatch, test_token):
 
 
 def test_problem_loading_session_id_is_left_unhandled(test_token):
-    test_token.remove()
-    test_token.ensure_dir()
+    test_token.unlink()
+    test_token.mkdir()
     with pytest.raises(IOError):
         default_user()

tests/test_auth.py

@@ -2,9 +2,9 @@
 
 import pytest
 
+from aocd.exceptions import AocdError
 from aocd.get import current_day
 from aocd.get import most_recent_year
-from aocd.exceptions import AocdError
 
 
 @pytest.mark.parametrize(