def updateBoard(self):
# update rows
for i in range(0, self.boardHeight):
if self.board[i].update():
# player moves with logs
if i == (self.height - 1 -
self.player.y) and self.board[i].getType() == "RIVER":
shift = 2 * (self.board[i].getDir() == DIR_RIGHT) - 1
self.player.x += shift * (
self.player.x + shift >= 0
and self.player.x + shift < self.width)
# handle board scrolling
if not self.buffer:
type = random.randint(0, len(self.rowOptions) - 1)
self.buffer.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval), self.rowOptions[type]))
self.buffer.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval), self.rowOptions[type]))
if self.count <= max(self.rowInterval, (self.updateInterval / max(
1, (self.score / 100)))) and self.forceUpdate == False:
self.count = self.count + 1
return
self.board.append(self.buffer.popleft())
self.player.y += 1
self.count = 0
self.forceUpdate = False
def judge(t,the,rules):
now=t
for n,(s,col) in enumerate(rules):
less = now.clone()
for x in selected(now.rows,*col): less.add(x)
if (len(less.rows) == len(now.rows)):
break
if Row(t,now.mid()) < Row(t,less.mid()):
break
if len(less.rows) < 10: break
shows(less.y() + [ f"round{n+1}", len(less.rows),col])
now=less
def __init__(self, type):
if type == "skills":
self.goals.append(Goal(["blue", "blue"]))
self.goals.append(Goal(["blue"]))
self.goals.append(Goal(["blue", "blue"]))
self.goals.append(Goal(["blue"]))
self.goals.append(Goal(["blue", "blue", "blue"]))
self.goals.append(Goal(["blue"]))
self.goals.append(Goal(["blue", "blue"]))
self.goals.append(Goal(["blue"]))
self.goals.append(Goal(["blue", "blue"]))
self.rows.append(Row([self.goals[0], self.goals[1],
self.goals[2]]))
self.rows.append(Row([self.goals[3], self.goals[4],
self.goals[5]]))
self.rows.append(Row([self.goals[6], self.goals[7],
self.goals[8]]))
self.rows.append(Row([self.goals[0], self.goals[3],
self.goals[6]]))
self.rows.append(Row([self.goals[1], self.goals[4],
self.goals[7]]))
self.rows.append(Row([self.goals[2], self.goals[5],
self.goals[8]]))
self.rows.append(Row([self.goals[0], self.goals[4],
self.goals[8]]))
self.rows.append(Row([self.goals[2], self.goals[4],
self.goals[6]]))
def __init__(self, cache_size, block_size, associativity, replacement):
self._size = cache_size
self._block_size = block_size
self._associativity = associativity
self._replacement = replacement
self._indices = int((self._size * pow(2, 10)) /
(self._block_size * self._associativity))
self._blocks = int(self._indices * self._associativity)
temp_rows = []
for i in range(self._indices):
rows = []
for a in range(associativity):
rows.append(Row())
temp_rows.append(rows)
self._rows = temp_rows
self._index_size = int(
math.log((self._size * pow(2, 10)), 2) -
(math.log(self._block_size, 2) + math.log(self._associativity, 2)))
self._offset = int(math.log(self._block_size, 2))
self._tag_size = 32 - self._index_size - self._offset
self._num_blocks = int(self._indices * self._associativity)
self._overhead_size = int(self._associativity * (1 + self._tag_size) *
(self._indices / 8))
self._total_size = int((self._size * pow(2, 10)) + self._overhead_size)
def prepare_insert(user_input):
# type: (Text) -> Tuple[Statement, PrepareStatementResult]
try:
_, str_id, username, email = user_input.split(" ")
except ValueError:
return Statement(
StatementType.UNKNOWN), PrepareStatementResult.SYNTAX_ERROR
if not all([str_id, username, email]):
return Statement(
StatementType.UNKNOWN), PrepareStatementResult.SYNTAX_ERROR
if len(username) > Row.MAX_USERNAME_LENGTH or len(
email) > Row.MAX_EMAIL_LENGTH:
return Statement(
StatementType.UNKNOWN), PrepareStatementResult.FIELD_TOO_LONG
try:
int_id = int(str_id)
except ValueError:
return Statement(
StatementType.UNKNOWN), PrepareStatementResult.INVALID_ID
else:
row = Row(int_id, username, email)
insert_statement = Statement(StatementType.INSERT, row)
return insert_statement, PrepareStatementResult.SUCCESS
def __add__(i, cells):
"add a row, update the column headers"
for col in i.cols:
col + cells[col.pos]
row = Row(cells)
i.all += [row]
return row
def row_object_from_csv(csv_row):
if 'work_add_lat' in csv_row:
work_add_lat = coord_from_csv(csv_row['work_add_lat'])
work_add_lon = coord_from_csv(csv_row['work_add_lon'])
home_add_lat = coord_from_csv(csv_row['home_add_lat'])
home_add_lon = coord_from_csv(csv_row['home_add_lon'])
else:
work_add_lat = None
work_add_lon = None
home_add_lat = None
home_add_lon = None
return Row(terminal_id=csv_row['terminal_id'],
customer_id=csv_row['customer_id'],
amount=amount_from_csv(csv_row['amount']),
city=csv_row['city'],
country=country_from_csv(csv_row['country']),
currency=country_from_csv(csv_row['currency']),
mcc=mcc_from_csv(csv_row['mcc']),
transaction_date=date_from_csv(csv_row['transaction_date']),
atm_address=None,
atm_address_lat=coord_from_csv(csv_row['atm_address_lat']),
atm_address_lon=coord_from_csv(csv_row['atm_address_lon']),
pos_address=None,
pos_address_lat=coord_from_csv(csv_row['pos_address_lat']),
pos_address_lon=coord_from_csv(csv_row['pos_address_lon']),
work_add_lat=work_add_lat,
work_add_lon=work_add_lon,
home_add_lat=home_add_lat,
home_add_lon=home_add_lon)
def read_csv(path):
rows = []
with open(path, newline='', encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile, delimiter=';')
for row in reader:
rows.append(Row(row[PLN], row[TYPE], row[PERSON]))
return rows
def __init__(self, playerNumber=1):
"""
Initialise placement - object with a top, middle and bottom row
:return: None
"""
assert isinstance(playerNumber, int)
assert 1 <= playerNumber <= 4
self.playerNumber = playerNumber
self.bottomRow = Row(size=5,
rowName='Bottom',
playerNumber=playerNumber)
self.middleRow = Row(size=5,
rowName='Middle',
playerNumber=playerNumber)
self.topRow = Row(size=3, rowName='Top', playerNumber=playerNumber)
def main(sidelen=4):
global alllen
global allones
global side
global comb
global gsl
global r
global combcomb
alllen = sidelen**2
allones = int(alllen / 2)
side = sidelen
if log and combcomb != sidelen:
print('creating log')
comb = [{} for i in range(sidelen + 1)]
combcomb = sidelen
print('done')
if gsl != sidelen:
r = []
print('generating rows:')
for i in tqdm(range(2**sidelen)):
num = f'{bin(i)[2:]:>{sidelen}}'.replace(' ', '0')
r.append(Row(num))
print('combinating rows:')
for item in tqdm(r):
for i in range(2**sidelen):
item.combine(r[i])
gsl = sidelen
#for i in r:
# print(i)
# print(i.poss())
print(f'solving {sidelen}*{sidelen}:')
for a in range(2**sidelen):
mainsolve(r[a], r[a].ones, 0)
def build_rows(nb_rows, unavailables_slots, nb_slots_per_row):
unavailables = defaultdict(list)
for (line, slot) in unavailables_slots:
unavailables[line].append(slot)
rows = [Row(i, nb_slots_per_row, unavailables[i]) for i in range(nb_rows)]
rows.sort(reverse=True, key=lambda r: r.getmax())
return rows
def get_row_from_insert_command(self):
if len(self.sql_string_array) != 4:
print(
"PREPARE_SYNTAX_ERROR: the insert command takes three arguments - insert 1 name [email protected]"
)
return False
## validate input ID
try:
user_id = int(self.sql_string_array[1])
if (user_id <= 0):
print("row ID must be positive")
return False
except ValueError:
print("Second argument must be an integer")
return False
## validate input name
name = self.sql_string_array[2]
if (len(name) > constants.NAME_FIELD_SIZE):
print("name too long: " + name)
return False
## validate input email
email = self.sql_string_array[3]
if (len(email) > constants.EMAIL_FIELD_SIZE):
print("email too long: " + email)
return False
row = Row(user_id, name, email)
row.serialize()
return row
def load_file(self, stream):
"""Given an open file handle, read Row lines into this RowSet
"""
if isinstance(stream, str):
filename = stream
stream = open(filename, 'r')
else:
filename = '(stream)'
if len(self) > 0:
raise ValueError(
'{}: can only load files into an empty RowSet'.format(filename)
)
opening_balance = 0
line_number = 0
for row in stream.readlines():
row = row.rstrip('\n')
line_number += 1
if not row:
# Skip blank lines
continue
if re.match(r'^#', row):
# TODO
# - add comments and pragmas into the rows array for 100%
# round-triping
match = re.match(r'^#balance ([-0-9.]+)', row)
if match:
given_balance = decimal.Decimal(match.group(1))
current_balance = opening_balance+self.balance
if len(self.rows) == 0:
# if the balance pragma is before any transaction
# data then it sets the opening balance for the set
opening_balance = given_balance
continue
elif given_balance != current_balance:
raise ValueError(
'{}:{} Failed to balance - expected {} but calcul'
'ated {}'.
format(
filename,
line_number,
given_balance,
current_balance
)
)
# - in future there might be additional meta/pragmas
# skip adding comment or meta lines
continue
try:
# TODO - the row class should handle fields inside the line
self.append(Row(*re.split(r'\s+', row, maxsplit=2)))
except: # noqa
print("{}:{} Syntax error".format(filename, line_number))
raise
def patternrows(patternlist):
"""
takes a list of strings(per row) and returns a list of rows
"""
for r in range(len(patternlist)):
string = patternlist[r]
patternlist[r] = Row(string)
return patternlist
def __init__(self):
filename = 'alunos.csv'
mode = 'r'
with open(filename, mode) as csv_file:
csv_reader = csv.DictReader(csv_file)
self.csv_list = []
for row in csv_reader:
self.csv_list.append(Row(row))
def read(i, src):
"Fo all rows in src, fill in the table."
for lst in cells(cols(rows(src))):
if i.cols:
lst = [col + x for col, x in zip(i.cols.all, lst)]
i.rows += [Row(lst)]
else:
i.cols = Cols(lst)
return i
def _get_fk_data(self, table_name, fk, fk_value):
reltable = Structure.get_fk_referenced_table(table_name, fk)
reltable_pk = Structure.get_primary_key(reltable)
if not self._cache.relation_exists(table_name, reltable):
sql = SQLBuilder(reltable)
sql.add_where_literal(Column(reltable, reltable_pk).in_(self._cache.get_all_keys(table_name, fk)))
data = Query().execute_and_fetch(**sql.build_select())
self._cache.save_relation(table_name, reltable, data)
return Row(self._cache.get_relation_row(reltable, reltable_pk, fk_value), reltable, self)
def twenty_fifteen(f):
soup = BeautifulSoup(open(os.path.join(folder, f)), "html.parser")
table = soup.findAll("table")[1]
rows = table.findChildren(['tr'])
for data in rows:
# skip table headers
if len(data.findChildren(["th"])) < 1:
csv_rows.append(Row("2015", data, 0, 1))
def startNewGame(self):
self.score = 0
self.count = 0
self.player.x = int(self.width / 2)
self.player.y = int(self.height - 1)
self.board = deque([], self.boardHeight)
self.buffer = deque([])
self.board.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval)))
self.board.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval)))
self.board.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval)))
self.board.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval)))
for i in range(4, self.boardHeight):
if i % 2 == 0:
type = random.choice(self.rowOptions)
self.board.append(
Row(
self.width,
random.randint(
max(1, self.rowInterval - int(self.score / 100)),
self.rowInterval), type))
def _make_derivative_rows(self) -> None:
# Add derivatives to the table ("bottom part" of table, ie. successors)
for state in self._rows:
for a in self._alphabet:
if not self[state.label + a]:
observations = tuple(
self._teacher.accepts(state.label + a + c)
for c in self._cols)
new_row = Row(state.label + a, self._cols, observations)
self._derivative_rows.append(new_row)
def read(i, src):
"Fo all rows in src, fill in the table."
for n, lst in enumerate(cells(cols(rows(src)))):
if n == 0:
i.header = lst
if i.cols:
lst = [col + x for col, x in zip(i.cols.all, lst)]
i.rows += [Row(lst)]
else:
i.cols = Cols(lst)
return i
def testAllElementsGenerator(self):
dashboard = SimpleDashboard()
dashboard.rows.append(Row())
dashboard.rows.append(Row())
dashboard.rows[0].panels.append(Panel())
dashboard.rows[0].panels.append(Panel())
dashboard.rows[1].panels.append(Panel())
dashboard.rows[0].panels[0].panelElements.append(1)
dashboard.rows[0].panels[0].panelElements.append(2)
dashboard.rows[0].panels[1].panelElements.append(3)
dashboard.rows[1].panels[0].panelElements.append(4)
result = []
for el in dashboard.all_elements():
result.append(el)
self.assertEquals(4, len(result))
self.assertTrue(1 in result)
self.assertTrue(2 in result)
self.assertTrue(3 in result)
self.assertTrue(4 in result)
def __init__(self, teacher: Teacher, alphabet: Tuple[str, ...]):
"""
:param teacher: Implements `accepts` and `counterexample` methods
:param alphabet: The alphabet of the target to be learned
"""
self._alphabet = alphabet
self._teacher = teacher
# we start with just the row & column for the empty word
self._cols = ('', )
self._rows = [Row('', self._cols, (teacher.accepts(''), ))]
self._derivative_rows = []
self._make_derivative_rows()
def process_counterexample(self, label: str, conjecture: DFA) -> bool:
"""Add counterexample and its prefixes to rows, and add derivative
rows"""
if conjecture.accepts(label) == self._teacher.accepts(label):
print("False counter example, already both reject or both accept.")
return False
new_row = Row(
label, self._cols,
tuple(self._teacher.accepts(label + c) for c in self._cols))
self._rows.append(new_row)
for i in range(len(label)):
prefix = label[:i]
if prefix not in list(map(lambda x: x.label, self._rows)):
self._rows.append(
Row(
prefix, self._cols,
tuple(
self._teacher.accepts(prefix + col)
for col in self._cols)))
self._make_derivative_rows()
return True
def dfs(root: Node, continues: Tuple[bool] = None):
if continues is None:
continues = tuple()
yield Row(root, continues)
if not root.children:
return
for child in root.children:
is_last = root.children[-1] == child
for grandchild in dfs(child, continues + (not is_last, )):
yield grandchild
def test_get_valid_row(self):
dictrow = dict()
dictrow['nome'] = 'Lucas Oliveira Barros'
dictrow['matricula'] = '100591'
dictrow['telefone'] = '99999-9980'
dictrow['email'] = "*****@*****.**"
dictrow['uffmail'] = ""
dictrow['status'] = "Ativo"
row = Row(dictrow)
self.assertEqual(row, self.database.getrow(self.validid))
def ninety_six(f):
"""
Straight forward parsing of 1995-1996.html file
"""
soup = BeautifulSoup(open(os.path.join(folder, f)), "html.parser")
table = soup.findAll("table")[1]
rows = table.findChildren(['tr'])
for data in rows:
# skip table headers
if len(data.findChildren(["th"])) < 1:
csv_rows.append(Row("1996", data, 0, 7))
def createRowFromXml(rowNode, sourceApp=None):
"""
Parses a row xml node
@param rowNode: Lxml representing a form or dashboard element
@return:
"""
logger.debug("parsing dashboard row node")
if rowNode.get('grouping'):
rowGroupings = map(
int,
rowNode.get('grouping').replace(' ', '').strip(',').split(','))
logger.debug("Found row grouping=%s" % rowGroupings)
else:
rowGroupings = None
row = Row(rowGroupings)
if len(rowNode) is 0:
logger.warn('Dashboard row is empty (line %d)', rowNode.sourceline)
else:
hasPanels = False
hasVisualizations = False
for panelElementNode in rowNode:
if panelElementNode.tag == "panel":
if hasVisualizations:
raise Exception(
_('Row, on line=%s, should not combine visualizations and panels. Panel, on line=%s'
) %
(rowNode.sourceline, panelElementNode.sourceline))
hasPanels = True
row.panels.append(
createPanelFromXML(panelElementNode, sourceApp))
elif panelElementNode.tag == et.Comment:
continue
else:
if hasPanels:
raise Exception(
_('Row, on line=%s, should not combine visualizations and panels. Visualization, on line=%s'
) %
(rowNode.sourceline, panelElementNode.sourceline))
hasVisualizations = True
try:
panelElement = createPanelElementFromXml(panelElementNode)
if panelElement:
row.appendPanelElement(panelElement)
except NotImplementedError:
raise Exception(
_('Row, on line=%s, conains unknown node=%s on line=%s.'
) % (rowNode.sourceline, panelElementNode.tag,
panelElementNode.sourceline))
return row
def drawboard(self):
'''Draws the peg board for the current game'''
### Choose secret code
self.pick_secretcode()
#print("secret_code:", self.secret_code)
### Initialize score
self.score = 0
### Show player info and options above the board
self.header = Frame(self.parentframe, pady=10)
self.header.pack()
Label(self.header, text="{} vs. Computer".format(self.player)).pack()
Label(self.header, text="{} rows, {}".format(self.numrows,
self.dups)).pack()
Label(self.header, text="Good Luck!").pack()
### Make board container
self.boardarea = Frame(self.parentframe,
bg="gray",
width=240,
borderwidth=5,
relief=RAISED)
self.boardarea.pack()
### Draw top row including secret pegs and "reveal" button
self.toprow = Frame(self.boardarea, height=40, width=240, bg="gray")
self.toprow.pack(side=TOP)
self.toprow.pack_propagate(0)
self.secretpegframe = Frame(self.toprow, width=160)
self.secretpegframe.pack(side=LEFT)
self.secretpegs = []
for secretdigit in self.secret_code:
self.secretpegs.append(SecretPeg(self.secretpegframe, secretdigit))
self.revealframe = Frame(self.toprow, height=40, width=80, bg="gray")
self.revealframe.pack(side=RIGHT)
self.revealframe.pack_propagate(0)
self.revealbutton = Button(self.revealframe,
borderwidth=0,
bg="gray",
text="Reveal",
command=self.forfeit)
self.revealbutton.pack(side=LEFT, fill=X, expand=1)
### Make the number of rows chosen by player
self.myrows = []
for i in range(self.numrows):
newrow = Row(self, self.boardarea, i)
self.myrows.append(newrow)
### Activate the first (=bottom) row
self.myrows[0].activate()
def parseCSV(self):
with open(self.data['retenciones'], 'r') as csvfile:
first = True
spamreader = csv.reader(csvfile, delimiter=',', quotechar='"')
for row in spamreader:
if first:
first = False
continue
r = Row()
r.setData(row)
self.rows.append(r)
