def __init__(self):
Observable.__init__(self)
self.options = ProcessingOptions(0, ProcessingArea(246, 266, 200, 300),
5, 4, 1)
self.folder_path = None
self.log = None
self.p = Processor()
def __init__(self,
fh,
map=None,
maxdata=None,
ignore_broken_pipe=False,
logger=None,
**obsopt):
"""Wrap a dispatcher around the passed filehandle.
If `ignore_broken_pipe` is `True`, an `EPIPE` or `EBADF` error will
call `handle_close()` instead of `handle_expt()`. Useful when broken
pipes should be handled quietly.
`logger` is a logger which will be used to log unusual exceptions;
otherwise, they will be printed to stderr.
"""
self.maxdata = maxdata if maxdata else self.pipe_maxdata
self.__logger = logger
if ignore_broken_pipe:
self.__ignore_errno = [EPIPE, EBADF]
else:
self.__ignore_errno = []
self.__filehandle = fh
# Check for overduplication of the file descriptor and close the extra
fddup = os.dup(fh.fileno())
file_dispatcher.__init__(self, fddup, map=map)
if (self._fileno != fddup): os.close(fddup)
Observable.__init__(self, **obsopt)
def __init__(self, argv, map=None, timeout=None, close_when_done=True,
stdin=PIPE, stdout=PIPE, stderr=PIPE, preexec_fn=None, bufsize=0, **popen_keyw):
"""Accepts all the same arguments and keywords as `subprocess.Popen`.
Input or outputs specified as `PIPE` (now the default) for are wrapped
in an asynchronous pipe dispatcher.
The timeout is used to create an alarm, which can be cancelled by
calling `cancel_timeout()`, `communicate()`, `wait()` or `kill()`.
"""
Observable.__init__(self)
self._map = map
# Create the subprocess itself, wrapping preexec_fn in the clear_signals call
Popen.__init__(self, argv, preexec_fn=lambda: self.clear_signals(preexec_fn),
stdin=stdin, stdout=stdout, stderr=stderr, **popen_keyw)
# Set the timeout on the subprocess. If it fails, ignore the failure.
try:
fto = float(timeout)
self._alarmobj = alarm.alarm(fto, self.kill) if fto > 0 else None
except:
self._alarmobj = None
# Wrap the pipe I/O. Sets the Popen and pipe buffer sizes the same; perhaps not optimal.
if stdout == PIPE:
self.stdout = OutputPipeDispatcher(self.stdout, map=map, ignore_broken_pipe=True,
universal_newlines=self.universal_newlines, maxdata=bufsize)
self.stdout.obs_add(self._pipe_event)
if stderr == PIPE:
self.stderr = OutputPipeDispatcher(self.stderr, map=map, ignore_broken_pipe=True,
universal_newlines=self.universal_newlines, maxdata=bufsize)
self.stderr.obs_add(self._pipe_event)
if stdin == PIPE:
self.stdin = InputPipeDispatcher(self.stdin, map=map, ignore_broken_pipe=True,
close_when_done=close_when_done, maxdata=bufsize)
self.stdin.obs_add(self._pipe_event)
def __init__(self,board,players=(),fixed_handicap=0,komi=0,custom_handicap=0,ruleset=None):
Observable.__init__(self)
self._board = board
self._testboard = None
if ruleset:
self.ruleset = ruleset
else:
self.ruleset = rules.AGARules()
self.history = [] # the board at all times in the past
self.moves = [] # the list of moves
if not players:
black_player = player.PlayerSettings('black','Black')
white_player = player.PlayerSettings('black','Black',komi=komi)
players = [player.Player(p, self) for p in (black_player, white_player)]
else:
for p in players:
p.game = self
self.players = players
self.next_player = self.players[0]
self.winner = None
self.state = PLACE_HANDICAP
# Handle handicap, komi etc
self.ruleset.setup(self)
# If manual handicap stones need to be placed, change to that team;
# otherwise, begin the game
if not self.skip_completed_handicap():
self.start()
def __init__(self): Observable.__init__(self) self.local_players = [] self.remote_players = [] self.accept_local_moves = False self.game = None self.confirmed_dead_stones_remote = set() self.confirmed_dead_stones = False
def __init__(self,
argv,
map=None,
timeout=None,
close_when_done=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
preexec_fn=None,
bufsize=0,
**popen_keyw):
"""Accepts all the same arguments and keywords as `subprocess.Popen`.
Input or outputs specified as `PIPE` (now the default) for are wrapped
in an asynchronous pipe dispatcher.
The timeout is used to create an alarm, which can be cancelled by
calling `cancel_timeout()`, `communicate()`, `wait()` or `kill()`.
"""
Observable.__init__(self)
self._map = map
# Create the subprocess itself, wrapping preexec_fn in the clear_signals call
Popen.__init__(self,
argv,
preexec_fn=lambda: self.clear_signals(preexec_fn),
stdin=stdin,
stdout=stdout,
stderr=stderr,
**popen_keyw)
# Set the timeout on the subprocess. If it fails, ignore the failure.
try:
fto = float(timeout)
self._alarmobj = alarm.alarm(fto, self.kill) if fto > 0 else None
except:
self._alarmobj = None
# Wrap the pipe I/O. Sets the Popen and pipe buffer sizes the same; perhaps not optimal.
if stdout == PIPE:
self.stdout = OutputPipeDispatcher(
self.stdout,
map=map,
ignore_broken_pipe=True,
universal_newlines=self.universal_newlines,
maxdata=bufsize)
self.stdout.obs_add(self._pipe_event)
if stderr == PIPE:
self.stderr = OutputPipeDispatcher(
self.stderr,
map=map,
ignore_broken_pipe=True,
universal_newlines=self.universal_newlines,
maxdata=bufsize)
self.stderr.obs_add(self._pipe_event)
if stdin == PIPE:
self.stdin = InputPipeDispatcher(self.stdin,
map=map,
ignore_broken_pipe=True,
close_when_done=close_when_done,
maxdata=bufsize)
self.stdin.obs_add(self._pipe_event)
def __init__(self, master, width, *args, **kwargs):
tk.Canvas.__init__(self,
master,
width=width,
height=width / 7 * 6,
*args,
**kwargs)
Observable.__init__(self)
self._width = width
self._shape_ids = Matrix(7, 6)
self._init_ui()
self.bind('<Button-1>', self._on_click)
def __init__(self, ag_voc_params, id):
Observable.__init__(self)
seed()
self.id = id
n_ag = len(ag_voc_params)
self.ag_voc_param = ag_voc_params[id]
self.feat_extractor = FeatureExtraction()
self.identificator = AgentIndentification(ag_voc_params)
self.pres_estimator = PresenceEstimation(n_ag)
self.val_estimator = ValueEstimation(n_ag, lr=0.05, discount=0.9)
self.decision_maker = ActionSelection(n_ag, lr=0.05)
self.reflex = Reflex()
self.motor = MotorExecution(self.ag_voc_param)
self.amp = 0
self.adapt = True
def __init__(self, size, grid=None):
# do need option to pass in grid ? RE FACTOR - probably don't need this
Observable.__init__(self)
self._colOrdStart = ord('a')
self._colOrdEnd = self._colOrdStart + size - 1
self._grid = grid if grid else [[None for c in range(size)]
for r in range(size)]
self.size = size
# create regular expression to match moves. Do it here so only done once.
r = r'[a-' + chr(self._colOrdEnd) + 'A-' + chr(
self._colOrdEnd).upper() + ']'
# add number range.
r += '[1-' + str(size) + ']'
self._movePattern = r
def __init__(self, size, root, testMode=False):
Observable.__init__(self)
self.pawnPromoted = False
self._highlightMoves = tkinter.IntVar()
self._highlightMoves.set(1)
self._mouseOverGridRef = None
self._mouseOverMoveGridRefs = []
self._selectedGridRef = None
self._selectedMoveGridRefs = []
self._player1Type = tkinter.StringVar()
self._player1Type.set(ChessPlayers.HUMAN)
self._player2Type = tkinter.StringVar()
self._player2Type.set(ChessPlayers.COMPUTER_LEVEL0)
self.pWhiteDropDown = None
self.pBlackDropDown = None
middleColumn = tkinter.Frame(root)
middleColumn.grid(row=0, column=1)
self.playerLabel = tkinter.Label(middleColumn)
self.playerLabel.grid(row=0, sticky='nsew')
self.feedbackLabel = tkinter.Label(middleColumn)
self.feedbackLabel.grid(row=1, sticky='nsew')
self.boardCanvas = BoardCanvas(middleColumn, 8)
self.boardCanvas.grid(row=2, sticky='nsew')
self.addObserver(self.boardCanvas)
self._moveText = tkinter.Text(root,
width=20,
state='disabled',
wrap=tkinter.WORD,
background=self.boardCanvas.colours[1])
self._moveText.grid(row=0, column=0, sticky='nsew')
helpFrame = self._createHelpFrame(root)
helpFrame.grid(row=0, column=2, sticky='nsew')
# follow movements of the mouse
self.boardCanvas.bind('<Motion>', self.mouseMovement)
self.boardCanvas.bind('<Button-1>', self.selectSquare)
def __init__(self, serial, callback, do_timestamp=True):
"""
:param serial: A Serial object for communicating with a serial port. It needs to have
a read timeout set. Otherwise, this class object might hang forever if
a end line character is never received.
http://pyserial.readthedocs.io/en/latest/shortintro.html#readline
:type Serial
:param callback: A callback method for calling back to owner when error occurs.
:param do_timestamp: Add a timestamp to each line intercepted from the serial port.
"""
Thread.__init__(self, name=self.__class__.__name__)
Observable.__init__(self)
self.setDaemon(True)
self._stop = Event()
self._do_timestamp = do_timestamp
self._port = serial
self.logger = logging.getLogger(self.__class__.__name__)
self._start_time = None # Is set when first log line arrives from serial port.
self._callback = callback
codecs.register_error('backslashreplace', self.backslash_replace)
def __init__(self, fh, map=None, maxdata=None, ignore_broken_pipe=False, logger=None, **obsopt):
"""Wrap a dispatcher around the passed filehandle.
If `ignore_broken_pipe` is `True`, an `EPIPE` or `EBADF` error will
call `handle_close()` instead of `handle_expt()`. Useful when broken
pipes should be handled quietly.
`logger` is a logger which will be used to log unusual exceptions;
otherwise, they will be printed to stderr.
"""
self.maxdata = maxdata if maxdata else self.pipe_maxdata
self.__logger = logger
if ignore_broken_pipe:
self.__ignore_errno = [EPIPE, EBADF]
else:
self.__ignore_errno = []
self.__filehandle = fh
# Check for overduplication of the file descriptor and close the extra
fddup = os.dup(fh.fileno())
file_dispatcher.__init__(self, fddup, map=map)
if (self._fileno != fddup): os.close (fddup)
Observable.__init__(self, **obsopt)
def __init__(self, lattice, basis, connections, default_value=None):
"""Store points and connections"""
Observable.__init__(self)
self.points = {}
self.connections = {}
self.xmax = -1000
self.ymax = -1000
self.xmin = 1000
self.ymin = 1000
for lx, ly in lattice.items():
# Add the points by superimposing the basis onto each lattice point
for b in basis:
bx, by = b
self.points[(lx + bx, ly + by)] = default_value
self.connections[(lx + bx, ly + by)] = []
self.xmin = min(self.xmin, lx + bx)
self.ymin = min(self.ymin, ly + by)
self.ymax = max(self.ymax, ly + by)
self.xmax = max(self.xmax, lx + bx)
# Now connect the points
for lx, ly in lattice.items():
try:
for c in connections:
cx1, cy1, cx2, cy2 = c
a = (lx + cx1, ly + cy1)
b = (lx + cx2, ly + cy2)
if a in self.points and b in self.points:
self.connections[a].append(b)
self.connections[b].append(a)
except KeyError:
raise Exception("Invalid connections")
def __init__(self):
Observable.__init__(self)
self._game = Game()
def __init__(self, entries, destiny, use_common_path=True):
threading.Thread.__init__(self)
Observable.__init__(self)
self.entries = entries[:]
self.destiny = destiny.replace(' ', '\\ ')
self.use_common_path = use_common_path
def __init__(self,grid):
Observable.__init__(self)
self.grid = grid
self.territory = {}
def __init__(self, category, drawCallback=None):
SimObject.__init__(self, category, drawCallback)
Observable.__init__(self)
self.gid = entityManager.nextGID(self)
def __init__(self, entries, destiny, use_common_path=True):
threading.Thread.__init__(self)
Observable.__init__(self)
self.entries = entries[:]
self.destiny = destiny.replace(' ', '\\ ')
self.use_common_path = use_common_path
