File: client-py.lp

package info (click to toggle)
gringo 4.4.0-1
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 8,260 kB
  • ctags: 10,755
  • sloc: cpp: 55,049; python: 629; yacc: 569; sh: 124; makefile: 23
file content (71 lines) | stat: -rw-r--r-- 2,368 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#script (python) 

import socket
import os
import errno
from gringo import Fun, SolveResult

class Receiver:
    def __init__(self, conn):
        self.conn = conn
        self.data = bytearray()
    def readline(self):
        pos = self.data.find("\n")
        while pos < 0:
            while True:
                try: self.data.extend(self.conn.recv(4096))
                except socket.error as (code, msg):
                    if code != errno.EINTR: raise
                else: break
            pos = self. data.find("\n")
        msg = self.data[:pos]
        self.data = self.data[pos+1:]
        return msg

class States:
    SOLVE = 1
    IDLE  = 2

def main(prg):
    with open(".controller.PORT", "r") as f:
        p = int(f.read())
    os.remove(".controller.PORT")
    conn = socket.create_connection(("127.0.0.1", p))
    try:
        recv  = Receiver(conn)
        state = States.IDLE
        k     = 0
        prg.ground([("pigeon", []), ("sleep",  [k])])
        prg.assign_external(Fun("sleep", [k]), True)
        while True:
            if state == States.SOLVE:
                f = prg.solve_async(
                    on_model  = lambda model:            conn.sendall("Answer: " + str(model) + "\n"),
                    on_finish = lambda ret, interrupted: conn.sendall("finish:" + str(ret) + (":INTERRUPTED" if interrupted else "") + "\n"))
            msg = recv.readline()
            if state == States.SOLVE:
                f.interrupt()
                ret = f.get()
            else:
                ret = SolveResult.UNKNOWN
            if msg == "interrupt":
                state = States.IDLE
            elif msg == "exit":
                return
            elif msg == "less_pigeon_please":
                prg.assign_external(Fun("p"), False)
                state = States.IDLE
            elif msg == "more_pigeon_please":
                prg.assign_external(Fun("p"), True)
                state = States.IDLE
            elif msg == "solve":
                state = States.SOLVE
            else: raise(RuntimeError("unexpected message: " + msg))
            if ret != SolveResult.UNKNOWN:
                k = k + 1
                prg.ground([("sleep", [k])])
                prg.release_external(Fun("sleep", [k-1]))
                prg.assign_external(Fun("sleep", [k]), True)
    finally:
        conn.close()
#end.