adalsteinn / heradsdomarar

heradsdomarar

Last run failed 2015-11-25 with status code 1.

Console output of last run

Injecting configuration and compiling... Injecting scraper and running... File "scraper.py", line 11 SyntaxError: Non-ASCII character '\xc3' in file scraper.py on line 11, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details

Data

Downloaded 1 time by

To download data sign in with GitHub

Download table (as CSV) Download SQLite database (24 MB) Use the API

rows 8 / 8

date	domstoll	payload
2013-01-01T22:51:41.787799	2	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