class TestDigger(unittest.TestCase):
def setUp(self):
digging_strategy = DiggingStrategy(1)
self.digger = Digger(digging_strategy)
self.terminal_pattern = generate_terminal_pattern()
def test_dig_cells_finds_a_valid_solution(self):
partial_board = self.digger.dig_cells(self.terminal_pattern)
self.assertIsNotNone(partial_board)
self.assertTrue(partial_board.is_valid())
def test_dig_cells_finds_a_unique_solution(self):
partial_board = self.digger.dig_cells(self.terminal_pattern)
self.assertIsNotNone(partial_board)
# For each empty cell in partial_board, try to fill it with a value
# different than the one from terminal_pattern. No solutions should
# yield from this. If any do, then this is not a unique solution.
for i in xrange(9):
for j in xrange(9):
if partial_board.get(i, j) != 0:
# Not an empty cell, move on.
continue
possibilities = partial_board.get_possibilities(i, j)
possibilities.remove(self.terminal_pattern.get(i, j))
for value in possibilities:
partial_board.fill(i, j, value)
self.assertIsNone(solve(partial_board))
# Discard changes.
partial_board.clear(i, j)
def generate_sudoku_with_unique_solution(difficulty):
"""Generates a partially completed sudoku with a unique solution, of the
given difficulty (1 through 5)."""
# Generate a terminal pattern (fully completed sudoku)
terminal_pattern = generate_terminal_pattern()
# Instantiate a Digger instance for the selected difficulty.
digging_strategy = DiggingStrategy(difficulty)
digger = Digger(digging_strategy)
sudoku = digger.dig_cells(terminal_pattern)
return sudoku
import RPi.GPIO as GPIO
import os
from digger import Digger
from http.server import BaseHTTPRequestHandler, HTTPServer
host_name = '' # Host on all available IP addresses
host_port = 8000
d = Digger()
class DiggerServer(BaseHTTPRequestHandler):
def do_HEAD(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def _redirect(self, path):
self.send_response(303)
self.send_header('Content-type', 'text/html')
self.send_header('Location', path)
self.end_headers()
def do_GET(self):
with open("server.html") as file:
html = file.read()
temp = os.popen("/opt/vc/bin/vcgencmd measure_temp").read()
self.do_HEAD()
self.wfile.write(html.format(temp[5:]).encode("utf-8"))
def do_POST(self):
def main():
address = getenv('ADDRESS')
port = getenv('Port')
sheme = getenv('Schema')
digger = Digger(url=f'{sheme}://{address}:{port}')
digger.get_license()
from multiprocessing import Process, Pool
from digger import Digger
import time
digger = Digger(8, 0.8)
digger.gCorpus("middel")
digger.prepare("data/query")
def digger_process(step, start):
res = []
try:
for corp in digger.corps[start:min(start+step, len(digger.corps)+1)]:
for que in digger.querys:
if digger.bf.contains(corp):
break
if digger.similarity(que, corp):
res.append((corp, que))
digger.bf.add(corp)
except Exception as err:
print(err)
return res
def main():
results = []
now = time.time()
step_len = len(digger.corps) // digger.pro_num + 1
pool = Pool(digger.pro_num)
import os
try:
from flask import Flask, render_template, request, jsonify
except ImportError as exc:
raise ImportError('Digger webserver requires "flask" installed') from exc
from digger import Digger
app = Flask(__name__,
template_folder=os.path.join(os.path.dirname(__file__),
'templates'))
@app.route('/')
def index():
return render_template("index.html")
digger = Digger()
@app.route('/api/result', methods=['post'])
def result():
urls = request.form.getlist('url')
return jsonify(digger(urls, merge_result=True))
if __name__ == '__main__':
app.run(debug=True)
def setUp(self):
digging_strategy = DiggingStrategy(1)
self.digger = Digger(digging_strategy)
self.terminal_pattern = generate_terminal_pattern()
