Exemplo n.º 1
0
 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
Exemplo n.º 2
0
    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
Exemplo n.º 3
0
    def commit_transaction(self, transaction, is_replay=False):
        if not is_replay:
            transaction.save(self.data_path)

        h = transaction.hashed_data()

        if transaction.path() in self.transactions:
            return

        if not is_replay:
            self.commit_log("begin_transaction", transaction.revision, h)

        key_cache = {}

        for i in transaction.statements:
            rev_key = "%s_%s" % (i.target_key, i.target_hash)
            if rev_key in key_cache:
                prev = key_cache[rev_key]
            else:
                prev = self.get_revision(i.target_key, i.target_hash)

            if prev == None:
                if rev_key in key_cache:
                    prev = key_cache[rev_key]
                else:
                    prev = Row(i.target_key)

            new = prev.apply_statement(i)
            new.result_of = transaction.path()

            new.save_to(self.data_path)
            key_cache[rev_key] = new

            if not is_replay:
                self.commit_log( [i.target_key, prev.hashed_data(), new.hashed_data()] )

        if not is_replay:
            self.commit_log("end_transaction", transaction.revision, h)
        
        for i in key_cache:
            obj = key_cache[i]
            if obj.data:
                self.save_doc(obj)
            else:
                hk = self.gen_key(i.split('_')[0])
                rev = i.split('_')[1]
                drops = []
                for i in self.objects[hk]:
                    if i.hashed_data() == rev:
                        drops.append(i)
                for i in drops:
                    self.objects[hk].remove(i)
                if len(self.objects[hk]) == 0:
                    self.objects.pop( hk )
        
        self.transactions.append(transaction.path())
        return key_cache
Exemplo n.º 4
0
 def test_put(self):
     self.init()
     x = self.connect()
     t = x.transaction()
     r = Row('test')
     t.add( r.statement('update', {'one':1}) )
     x.commit_transaction(t)
 
     rows = x.get_rows('test')
     
     self.assertEqual([i.data for i in rows], [{'one':1}])
Exemplo n.º 5
0
 def __init__(self, *args, **kwargs):
     if 'id' in kwargs.keys():
         unique_id = kwargs['id']
     else:
         unique_id = self.id
     try:
         Row.__init__(self, unique_id, *args, **kwargs)
     except KeyError as k:
         print "KeyError: Column", k, "does not exist."
     finally:
         return
Exemplo n.º 6
0
 def __init__(self, *args, **kwargs):
     if 'id' in kwargs.keys():
         unique_id = kwargs['id']
     else:
         unique_id = self.id
     try:
         Row.__init__(self, unique_id, *args, **kwargs)
     except KeyError as k:
         print "KeyError: Column", k, "does not exist."
     finally:
         return
Exemplo n.º 7
0
 def get_revision(self, key, revision):
     hk = self.gen_key(key)
     if hk in self.objects:
         for i in self.objects[hk]:
             if i.hashed_data() == revision:
                 return i
         if Row.exists(self.data_path, key, revision):
             row = Row.load_from(self.data_path, key, revision)
             return row
         return None
     else:
         return None
Exemplo n.º 8
0
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
Exemplo n.º 9
0
    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 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
Exemplo n.º 11
0
    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)
Exemplo n.º 12
0
 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]]))
Exemplo n.º 13
0
 def addText(self, stringList, col=(255,255,255)):
     if isinstance(stringList, str):
         temp = stringList
         stringList = []
         stringList.append(temp)
     
     for string in stringList:
         thisRow = Row(string, self.theFont, self.cursorY, self.imgFolder, self.mode)
         rowImage = thisRow.getImage()
         self.allElements.append(thisRow)
     
         self.checkResize(self.cursorY + rowImage.get_height())
         self.image.blit(rowImage, (0, self.cursorY))
         self.cursorY += rowImage.get_height() + self.CURSOR_BORDER_INCREMENT        
Exemplo n.º 14
0
 def execute(self, key, action, args):
     rows = self.get_rows(key)
     if len(rows) == 0:
         row = Row(key)
         t = self.transaction()
         t.add( row.statement(action, args) )
         self.commit_transaction(t)
     elif len(rows) == 1:
         row = rows[0]
         t = self.transaction()
         t.add( row.statement(action, args) )
         self.commit_transaction(t)
     else:
         raise Exception("too many docs!!!")                   
Exemplo n.º 15
0
    def addGroceryList(self, groceryList, col=(255,255,255)):
        if isinstance(groceryList, Ingredient):
            temp = groceryList
            groceryList = []
            groceryList.append(temp)

        for ingredient in groceryList:
            thisRow = Row(ingredient.getReadableName(),
                          self.theFont, self.cursorY, self.imgFolder, self.mode, ingredient)
            rowImage = thisRow.getImage()
            self.allElements.append(thisRow)
        
            self.checkResize(self.cursorY + rowImage.get_height())
            self.image.blit(rowImage, (0, self.cursorY))
            self.cursorY += rowImage.get_height() + self.CURSOR_BORDER_INCREMENT
Exemplo n.º 16
0
Arquivo: rows.py Projeto: se4ai/code
 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
Exemplo n.º 17
0
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
Exemplo n.º 18
0
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
Exemplo n.º 19
0
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)
Exemplo n.º 20
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
Exemplo n.º 21
0
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)
Exemplo n.º 22
0
    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)
Exemplo n.º 23
0
    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
Exemplo n.º 25
0
 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
Exemplo n.º 26
0
 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)
Exemplo n.º 27
0
    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))
Exemplo n.º 28
0
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))
Exemplo n.º 29
0
 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)
Exemplo n.º 30
0
def execute_select(table):
    # type: (Table) -> ExecuteStatementResult
    cursor = Cursor.table_start(table)

    while not cursor.is_at_end_of_table:
        page, offset = cursor.location()
        row = Row.deserialize_from(page, offset)
        print(row)
        cursor.advance()
    return ExecuteStatementResult.SUCCESS
Exemplo n.º 31
0
    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 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
Exemplo n.º 33
0
    def load_file(self, stream, skip_balance_check=False):
        """Given an open file handle, read Row lines into this RowSet
        """
        if isinstance(stream, str):
            filename = stream
            stream = open(filename, 'r')
        else:
            filename = '(stream)'
        line_number = 0

        need_balance = True

        # TODO
        # - if we are loading just one file from a whole dir, its opening
        #   balance will need to be added to any calculated balance to avoid
        #   errors

        if skip_balance_check:
            need_balance = False

        last_error = None
        for row in stream.readlines():
            row = row.rstrip('\n')
            line_number += 1

            try:
                obj = Row.fromTxt(row)
            except Exception as e:
                print("{}:{} Syntax error".format(filename, line_number),
                      file=sys.stderr)
                last_error = e

            if isinstance(obj, RowPragmaBalance):
                # TODO - move more of the pragma logic in to the pragma class

                if obj.balance != self.balance:
                    raise ValueError(
                        '{}:{} Failed to balance - expected {} but calcul'
                        'ated {}'.format(filename, line_number, obj.balance,
                                         self.balance))

                need_balance = False

            if isinstance(obj, RowData) and need_balance:
                raise ValueError(
                    '{}: trying to load a file that does not start with a'
                    ' balance pragma'.format(filename))

            self.append(obj)

        if last_error is not None:
            print("Error: at least one syntax error. Trace is from last",
                  file=sys.stderr)
            raise last_error
Exemplo n.º 34
0
 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
Exemplo n.º 35
0
 def get(self):
   rows = Row.all()
   logging.info('Found %d rows',rows.count())
 
   template_vars = {
     'rows': rows,
     'rowcount': rows.count(),
     'sep': cgi.escape(self.request.get("sep")) or ','
   }
   path = os.path.join(os.path.dirname(__file__),"index.html")
   self.response.out.write(template.render(path,template_vars))
Exemplo n.º 36
0
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
Exemplo n.º 37
0
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))
Exemplo n.º 38
0
 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
Exemplo n.º 39
0
 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()
Exemplo n.º 40
0
 def get(self):
   rows = Row.all()
   logging.info('CSV requested. Found %d rows',rows.count())
   if rows.count() > 0:
     self.response.headers['Content-Type'] = "application/csv"
     writer = encoding.UnicodeWriter(self.response.out,delimiter=cgi.escape(self.request.get("sep").__str__()),quotechar='"')
     for row in rows:
       writer.writerow(row.cols)
   else:
     print "Content-Type: text/html"
     print
     print "<h1>No data to display ...</h1>"
Exemplo n.º 41
0
 def test_many_keys_single_transaction(self):
     bunch_o_keys = [(i, gen()) for i in range(20)]
     
     self.init()
     x = self.connect()
 
     value = {}
     
     t = x.transaction()
     
     for index, i in bunch_o_keys:
         r = Row('test')
         t.add( r.statement('update', {i:index}) )
         value.update({i:index})
 
     x.commit_transaction(t)
 
     data = x.get_rows('test')
     data = data[0].data
     
     self.assertEqual(data, value)
Exemplo n.º 42
0
    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))
Exemplo n.º 43
0
  def post(self):
    text = self.request.get('lines')
    sep = self.request.get('sep') or ','
    
    logging.info("line %s - sep %s",text,sep)
    
    rows = rows_from_string(text,sep)
    db.put(rows)
    
    all_rows = Row.all()

    template_vars = {
      'rows': all_rows,
      'rowcount': all_rows.count(),
      'sep': cgi.escape(sep)
    }
      
    path = os.path.join(os.path.dirname(__file__),"index.html")
    self.response.out.write(template.render(path,template_vars))
Exemplo n.º 44
0
class Placement(object):
    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 setRow(self, row="Bottom", cards=[]):
        """
        Sets a given row with cards provided
        :param cards: List of Card objects
        :return: None
        """
        assert isinstance(row, basestring)
        assert row.lower() in ["bottom", "middle", "top"]
        assert isinstance(cards, list)
        if row.lower() in ["bottom", "middle"]:
            assert len(cards) <= 5
        elif row.lower() == "top":
            assert len(cards) <= 3

        for i in range(1, len(cards) + 1):
            assert isinstance(cards[i - 1], Card)

            if row.lower() == "bottom":
                self.bottomRow.setPlacement(c=cards[i - 1], position=i)

            elif row.lower() == "middle":
                self.middleRow.setPlacement(c=cards[i - 1], position=i)

            else:
                self.topRow.setPlacement(c=cards[i - 1], position=i)
Exemplo n.º 45
0
 def create(self, key, value):
     row = Row(key)
     t = self.transaction()
     t.add( row.statement('set', value) )
     self.commit_transaction(t)
Exemplo n.º 46
0
import os
import sys

# Extension should have been built in parent directory.
sys.path.append(os.path.dirname('..'))

from row import Row


methods = [
    ('Slinky', Row('14523ET90786')),
    ('Top', Row('2134567890ET')),
    ('Up', Row('2134TE098765')),
    ('Strange', Row.reverse_rounds(12)),
    ('Down', Row('8765432190TE')),
    ('Charm', Row('6543217890TE')),
    ('Meson', Row('1287094365ET')),
    ('Gluon', Row('13527496E8T0')),
    ('Baryon', Row('E9T705836142')),
]


LEAD_LIMIT = 4


def condensed_output(lead_heads, method_names):
    print(', '.join(method_names))


def full_output(lead_heads, method_names):
    print('1234567890ET  ' + method_names[0])