def buildRequestTable(self, state, callbacks): """ Builds the request list on the results page on the right. """ splitpane = JSplitPane() splitpane.setDividerLocation(1000) endpointTable = Table(state.endpointTableModel) endpointTable.setDefaultRenderer(Class.forName('java.lang.Object'), CellHighlighterRenderer(state)) endpointTable.getColumnModel().getColumn(0).setPreferredWidth(15) endpointTable.getColumnModel().getColumn(1).setPreferredWidth(500) endpointTable.setAutoCreateRowSorter(True) endpointTable.addMouseListener(TableMouseAdapter()) endpointView = JScrollPane(endpointTable) callbacks.customizeUiComponent(endpointTable) callbacks.customizeUiComponent(endpointView) requestTable = Table(state.requestTableModel) requestTable.getColumnModel().getColumn(0).setPreferredWidth(500) requestView = JScrollPane(requestTable) callbacks.customizeUiComponent(requestTable) callbacks.customizeUiComponent(requestView) splitpane.setLeftComponent(endpointView) splitpane.setRightComponent(requestView) return splitpane
def test_nested_table_in_cell(self): """Test nested table in cell""" inner_table = Table([['1', '2', '3']]) cell = TableCell(inner_table) self.html += ' <h2>Table nested in Cell</h2>\n' body = (' <tbody>\n' ' <tr>\n' ' <td><table class="table table-striped condensed">\n' ' <tbody>\n' ' <tr>\n' ' <td>1</td>\n' ' <td>2</td>\n' ' <td>3</td>\n' ' </tr>\n' ' </tbody>\n' '</table></td>\n' ' </tr>\n' ' </tbody>\n') expected_result = ('%s%s%s' % (self.html_table_start, body, self.html_table_end)) actual_result = Table([[cell]]) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) self.html += str(actual_result) self.writeHtml('table_nested_in_cell') assert expected_result.strip() == str(actual_result).strip(), message
def test__len__(self): # expect = fill expect = [ (None, 13), ([], 13), ([''], 18), ('hey', 15), ('', 13), ([None], 24), ([''] * 4, 54), ([''] * 10, 126), ('helloworld', 36), (['\n'], 24), ('\n', 13), (['\n\n\n'], 36), ('\n\n\n\n\n', 13), ] for (data, length) in expect: T = Table(rows=3, columns=3, fill=data) self.assertEqual(len(T), length, msg=f'fill={data}') # Small dimension check. for x in range(1, 12): for y in range(1, 12): T = Table(rows=x, columns=y) length = 5 * y - 2 self.assertEqual(len(T), length, msg=f'rows={x},columns={y}')
def test_table_caption(self): """Test table caption""" self.html += ' <h2>Caption Top</h2>\n' expected_result = ('%s%s%s%s' % (self.html_table_start, self.html_caption, self.html_body, self.html_table_end)) actual_result = Table(self.table_data, caption=self.table_caption) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) #also test bottom caption self.html += ' <h2>Caption Bottom</h2>\n' expected_result = ('%s%s%s%s' % (self.html_table_start, self.html_bottom_caption, self.html_body, self.html_table_end)) actual_result = Table(self.table_data, caption=self.table_caption, caption_at_bottom=True) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) self.html += str(actual_result) self.writeHtml('table_caption') assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result)
def test__init__(self): # data for k, v in self.types.items(): if k != 'double_iter' and k != 'str': for x in v: with self.assertRaises((TypeError, KeyError), msg=f'data={x}'): Table(data=x) for x in self.types['double_iter'] + self.types['str']: self.assertIsInstance(Table(data=x), Table, msg=f'data={x}') # rows for k, v in self.types.items(): if k != 'positive_int': for x in v: with self.assertRaises((ValueError, TypeError, KeyError), msg=f'rows={x}'): Table(rows=x) for x in self.types['positive_int']: self.assertIsInstance(Table(rows=x), Table, msg=f'rows={x}') # columns for k, v in self.types.items(): if k != 'positive_int': for x in v: with self.assertRaises((ValueError, TypeError, KeyError), msg=f'columns={x}'): Table(rows=1, columns=x) for x in self.types['positive_int']: self.assertIsInstance(Table(columns=x), Table, msg=f'columns={x}') # col_sep for k, v in self.types.items(): for x in v: if k != 'str' or (k == 'str' and len(x) > 1): with self.assertRaises((ValueError, TypeError, KeyError), msg=f'col_sep={x}'): Table(col_sep=x) for x in self.types['str']: if len(x) < 2: self.assertIsInstance(Table(col_sep=x), Table, msg=f'col_sep={x}') # head_sep for k, v in self.types.items(): for x in v: if k != 'str' or (k == 'str' and len(x) > 2): with self.assertRaises((ValueError, TypeError, KeyError), msg=f'head_sep={x}'): Table(head_sep=x) for x in self.types['str']: if len(x) < 3: self.assertIsInstance(Table(head_sep=x), Table, msg=f'head_sep={x}')
def test_row_span(self): """Testing row spanning""" table_cell_aa = TableCell('aa spanned', row_span=2) table_row1 = TableRow([table_cell_aa, self.table_cell_b, self.table_cell_c, self.table_cell_d]) table_row2 = TableRow([self.table_cell_b, self.table_cell_c, self.table_cell_d]) self.html += ' <h2>Spanning Table Columns</h2>\n' body = (' <tbody>\n' ' <tr>\n' ' <td rowspan="2">aa spanned</td>\n' ' <td>b</td>\n' ' <td>c</td>\n' ' <td>d</td>\n' ' </tr>\n' ' <tr>\n' ' <td>b</td>\n' ' <td>c</td>\n' ' <td>d</td>\n' ' </tr>\n' ' </tbody>\n') expected_result = ('%s%s%s' % (self.html_table_start, body, self.html_table_end)) actual_result = Table([table_row1, table_row2]) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('table_rowspanning')
def test_row_from_string(self): """Test row from string - it should span to the table width too""" table_row1 = TableRow([self.table_cell_a, self.table_cell_b, self.table_cell_c, self.table_cell_d]) self.html += ' <h2>Table row from string</h2>\n' body = (' <tbody>\n' ' <tr>\n' ' <td>a</td>\n' ' <td>b</td>\n' ' <td>c</td>\n' ' <td>d</td>\n' ' </tr>\n' ' <tr>\n' ' <td colspan="100%">foobar</td>\n' ' </tr>\n' ' <tr>\n' ' <td colspan="100%">Piet Pompies</td>\n' ' </tr>\n' ' </tbody>\n') expected_result = ('%s%s%s' % (self.html_table_start, body, self.html_table_end)) actual_result = Table([table_row1, 'foobar', 'Piet Pompies']) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) self.html += str(actual_result) self.writeHtml('table_row_from_string') assert expected_result.strip() == str(actual_result).strip(), message
def build_shift_comparison_table(year): header = [ 'year', 'shift', 'minimal investment', 'raw profit, uah', 'profit, %', ] data = [] for s in range(0, 31): shift = s + 1 stats = launch_trading( year=year, shift=shift, starting_amount_uah=0, verbose=False, ) min_investment = -stats['debt'] row = [ year, shift, '{:.2f}'.format(min_investment), '{:.2f}'.format(stats['end_amount']), '{:.2f}'.format(stats['end_amount'] / min_investment * 100), ] data.append(row) t = Table(header=header, data=data) t.print()
def getvalue(self, value): print(value) print(type(value)) if value == 1: pass elif value == 2: self.hide() view = Employee(self) elif value == 3: self.hide() view = Table(self) elif value == 4: self.hide() view = Reservations(self) elif value == 5: self.hide() view = Category(self) elif value == 6: self.hide() view = Settings(self) elif value == 7: self.hide() view = Orders(self) elif value == 8: self.hide() view = Menu(self) elif value == 9: self.hide() view = Bill(self)
def load(self, filepath): self._sections = list() with open(filepath, 'r') as f: data = json.load(f) for head in data: section = SectionHeading() section.style_name = head['style_name'] section.section_number = head['section_number'] section.title = head['title'] section.section_points = head['section_points'] for content in head['contents']: if isinstance(content, int): section.contents.append(content) elif isinstance(content, dict): table = Table() table.heading = content.get('heading') table.doc_table_number = content.get( 'doc_table_number') table.table_number = content.get('table_number') table.num_columns = content.get('num_columns') table.full_title = content.get('full_title') table.short_title = content.get('short_title') if isinstance(content.get('rows'), list): for row in content['rows']: table.rows.append(row) section.contents.append(table) else: print('Unknown type: {}'.format(type(content))) self._sections.append(section)
def test_max_width(self): # Blowing up... expect = [ ((None, 26), 13), (([], 15), 13), (([''], 79), 18), (('hey', 30), 15), (('', 21), 13), (([None], 121), 24), (([''] * 4, 200), 54), (([''] * 10, 1337), 126), (('helloworld', 72), 36), ((['\n'], 25), 24), (('\n', 13), 13), ((['\n\n\n'], 37), 36), (('\n\n\n\n\n', 13), 13), ] for ((data, max_width), length) in expect: T = Table(rows=3, columns=3, fill=data) T.max_width = max_width self.assertEqual(len(T), length, msg=f'max_width={max_width},fill={data}') # Shrinking... # Small values can't be shrinkend (next test) expect = [ ([''], 15), ('hey', 13), ([None], 21), ([''] * 4, 13), ([''] * 10, 100), ('helloworld', 30), (['\n'], 21), (['\n\n\n'], 35), ] for (data, max_width) in expect: T = Table(rows=3, columns=3, fill=data) T.max_width = max_width self.assertEqual(len(T), max_width, msg=f'max_width={max_width},fill={data}') expect = [((None, 10), 13), (([], 11), 13), (('', 12), 13), (('\n', 10), 13), (('\n\n\n\n\n', 12), 13)] for ((data, max_width), length) in expect: T = Table(rows=3, columns=3, fill=data) with self.assertRaises(ValueError, msg=f'fill={data}'): T.max_width = max_width
def test_remove_column(self): # TODO: Make sure the proper column is removed! # Starting with three rows and three columns removehead_expect = [(None, (3, 2, 3)), (0, (3, 2, 3)), (1, (3, 2, 3)), (range(2), (3, 1, 3)), ([0, 2], (3, 1, 3)), ([0, 0], (3, 2, 3)), ([0, 0, 1, 1], (3, 1, 3))] for (data, (rows, columns, lines)) in removehead_expect: T = Table(rows=3, columns=3) # No row sep for testing T.row_sep = '' T.remove_column(index=data, removehead=True) msg = (f'Not {rows} rows, with ' f'remove_column(index={data},removehead=True)') self.assertEqual(T.row_count, rows, msg=msg) msg = (f'Not {columns} columns, with ' f'remove_column(index={data},removehead=True)') self.assertEqual(T.column_count, columns, msg=msg) msg = (f'Not {lines} lines in table, with ' f'remove_column(index={data},removehead=True)') self.assertEqual(len(str(T).splitlines()), lines, msg=msg) # TODO: Same as removehead=True?? expect = [(None, (3, 3, 3)), (0, (3, 3, 3)), (1, (3, 3, 3)), (range(2), (3, 3, 3)), ([0, 2], (3, 3, 3)), ([0, 0], (3, 3, 3)), ([0, 0, 1, 1], (3, 3, 3))] for (data, (rows, columns, lines)) in expect: T = Table(rows=3, columns=3) # No row sep for testing T.row_sep = '' T.remove_column(index=data, removehead=False) msg = (f'Not {rows} rows, with ' f'remove_column(index={data},removehead=False)') self.assertEqual(T.row_count, rows, msg=msg) msg = (f'Not {columns} columns, with ' f'remove_column(index={data},removehead=False)') self.assertEqual(T.column_count, columns, msg=msg) msg = (f'Not {lines} lines in table, with ' f'remove_column(index={data},removehead=False)') self.assertEqual(len(str(T).splitlines()), lines, msg=msg) for k, v in self.types.items(): for x in v: if k != 'positive_int' and k != 'single_iter'\ or (k == 'positive_int' and x > 2): T = Table(rows=3, columns=3) with self.assertRaises((ValueError, TypeError), msg='index={x}'): T.remove_column(index=x)
def test_add_head(self): # Starting with empty table (no head) expect = [(None, (0, 0)), ([], (0, 0)), ([''], (1, 2)), ('hey', (3, 2)), ('', (0, 0)), ([None], (1, 2)), ([''] * 4, (4, 2)), ([''] * 10, (10, 2)), ('helloworld', (10, 2)), (['\n'], (1, 3)), ('\n', (1, 3)), (['\n\n\n'], (1, 5)), ('\n\n\n\n\n', (5, 3))] for data, (columns, lines) in expect: T = Table() # No row sep for testing T.row_sep = '' T.add_head(data=data) msg = f'Not three rows, with add_head(data={data})' self.assertEqual(T.row_count, 0, msg=msg) msg = f'Not {columns} column, with add_head(data={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {columns} column head, with add_head(data={data})' self.assertEqual(len(T._head), columns, msg=msg) msg = f'Not {lines} lines in table, with add_head(data={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) # Starting with three columns and three rows (no head) expect = [(None, (3, 5)), ([], (3, 5)), ([''], (3, 5)), ('hey', (3, 5)), ('', (3, 5)), ([None], (3, 5)), ([''] * 4, (4, 5)), ([''] * 10, (10, 5)), ('helloworld', (10, 5)), (['\n'], (3, 6)), ('\n', (3, 6)), (['\n\n\n'], (3, 8)), ('\n\n\n\n\n', (5, 6))] for data, (columns, lines) in expect: T = Table(rows=3, columns=3) # No row sep for testing T.row_sep = '' T.add_head(data=data) msg = f'Not three rows, with add_head(data={data})' self.assertEqual(T.row_count, 3, msg=msg) msg = f'Not {columns} columns, with add_head(data={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {columns} column head, with add_head(data={data})' self.assertEqual(len(T._head), columns, msg=msg) msg = f'Not {lines} lines in table, with add_head(data={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) for k, v in self.types.items(): if k != 'single_iter' and k != 'double_iter' and k != 'str': for x in v: T = Table(rows=3, columns=3) with self.assertRaises((ValueError, TypeError, KeyError), msg=f'data={x}'): T.add_head(data=x)
def landingPage(): t = Table(table="Experiment") rows = t.rows eids = [] number_of_runs = [] experiment_names = [] for row in rows: experiment_names.append(row[1]) eids.append(row[0]) t_for_count = Table('Run', [Query('eid', '=', row[0])]) number_of_runs.append(len(t_for_count.rows)) template_args = { "experiment_names": experiment_names, "number_of_runs": number_of_runs, "eid": eids, } return render_template('landing.html', **template_args)
def test_add_row(self): # Starting with empty Table expect = [(None, (1, 1, 1)), ([], (1, 1, 1)), ([''], (1, 1, 1)), ('hey', (1, 3, 1)), ('', (1, 1, 1)), ([None], (1, 1, 1)), ([''] * 4, (1, 4, 1)), ([''] * 10, (1, 10, 1)), ('helloworld', (1, 10, 1)), (['\n'], (1, 1, 2)), ('\n', (1, 1, 2)), (['\n\n\n'], (1, 1, 4)), ('\n\n\n\n\n', (1, 5, 2))] for data, (rows, columns, lines) in expect: T = Table() # No row sep for testing T.row_sep = '' T.add_row(data=data) msg = f'Not {rows} rows, with add_row(data={data})' self.assertEqual(T.row_count, rows, msg=msg) msg = f'Not {columns} columns, with add_row(data={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {lines} lines in table, with add_row(data={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) # Starting with three rows and three columns expect = [(None, (4, 3, 4)), ([], (4, 3, 4)), ([''], (4, 3, 4)), ('hey', (4, 3, 4)), ('', (4, 3, 4)), ([None], (4, 3, 4)), ([''] * 4, (4, 4, 4)), ([''] * 10, (4, 10, 4)), ('helloworld', (4, 10, 4)), (['\n'], (4, 3, 5)), ('\n', (4, 3, 5)), (['\n\n\n'], (4, 3, 7)), ('\n\n\n\n\n', (4, 5, 5))] for data, (rows, columns, lines) in expect: T = Table(rows=3, columns=3) # No row sep for testing T.row_sep = '' T.add_row(data=data) msg = f'Not {rows} rows, with add_row(data={data})' self.assertEqual(T.row_count, rows, msg=msg) msg = f'Not {columns} columns, with add_row(data={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {lines} lines in table, with add_row(data={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) for k, v in self.types.items(): if k != 'single_iter' and k != 'double_iter' and k != 'str': for x in v: T = Table(rows=3, columns=3) with self.assertRaises((ValueError, TypeError, KeyError), msg=f'data={x}'): T.add_row(data=x)
def add_tables(): tables_to_add = int(input("How many tables to add? ")) counter = tables_to_add while counter > 0: pool_table = Table(counter, "unoccupied") pool_tables.append(pool_table.__dict__) counter = counter - 1
def test_simple_table(self): """Test simple table creation""" self.html += ' <h2>Simple Table</h2>\n' expected_result = ('%s%s%s' % (self.html_table_start, self.html_body, self.html_table_end)) actual_result = Table(self.table_data) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('simple_table')
def test_fill(self): expect = [(None, (3, 3, 3)), ([], (3, 3, 3)), ([''], (3, 3, 3)), ('hey', (3, 3, 3)), ('', (3, 3, 3)), ([None], (3, 3, 3)), ([''] * 4, (3, 3, 3)), ([''] * 10, (3, 3, 3)), ('helloworld', (3, 3, 3)), (' ', (3, 3, 3)), ('\n', (3, 3, 6)), (['\n'], (3, 3, 3)), ('\n\n\n', (3, 3, 12))] for (data, (rows, columns, lines)) in expect: T = Table(rows=3, columns=3, fill=data) # No row sep for testing T.row_sep = '' msg = f'Not {rows} rows, with Table(fill={data})' self.assertEqual(T.row_count, rows, msg=msg) msg = f'Not {columns} columns, with Table(fill={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {lines} lines in table, with Table(fill={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) for v in self.types.values(): for x in v: self.assertIsInstance(Table(fill=x), Table, msg=f'fill={x}')
def test_table_cells(self): """Test table from individual cells""" self.html += ' <h2>Using Table Cells</h2>\n' expected_result = ('%s%s%s' % (self.html_table_start, self.html_body, self.html_table_end)) actual_result = Table(self.table_cell_data) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('table_by_cell_objects')
def test_table_with_header(self): '''Test html render of a table with header row(s).''' self.html += ' <h2>Table with header</h2>\n' expected_result = ('%s%s%s%s' % (self.html_table_start, self.html_header, self.html_body, self.html_table_end)) actual_result = Table(self.table_data, header_row=self.table_header) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('table_with_header')
def make_example_table() -> Table: STRESS_START = 400 stress_end = 450 dilation_ratio = 0.008 prestrain_table = Table([ XY(0.0, 0.0), XY(STRESS_START, 0.0), XY(stress_end, -1*dilation_ratio), XY(stress_end+200, -1*dilation_ratio), ]) return prestrain_table
def test_remove_head(self): expect = [(None, (1, 5, 1)), (0, (1, 5, 3)), (1, (1, 5, 3)), (range(2), (1, 5, 3)), ([1, 3], (1, 5, 3)), ([0, 0], (1, 5, 3)), ([0, 0, 1, 1], (1, 5, 3))] for data, (rows, columns, lines) in expect: T = Table(columns=5, fill='test') T.add_head() T.remove_head(index=data) msg = f'Not {rows} rows, with remove_head(index={data})' self.assertEqual(T.row_count, rows, msg=msg) msg = f'Not {columns} columns, remove_head(index={data})' self.assertEqual(T.column_count, columns, msg=msg) msg = f'Not {lines} lines in table, with remove_head(index={data})' self.assertEqual(len(str(T).splitlines()), lines, msg=msg) for k, v in self.types.items(): for x in v: if k != 'positive_int' and k != 'single_iter'\ or (k == 'positive_int' and x > 5): T = Table(rows=1, columns=5, fill='test') T.add_head() with self.assertRaises((ValueError, TypeError), msg=f'index={x}'): T.remove_head(index=x)
def test_table_from_string(self): """Test table from string - should be a single cell in a single row""" self.html += ' <h2>Table from string</h2>\n' body = (' <tbody>\n' ' <tr>\n' ' <td colspan="100%">foobar</td>\n' ' </tr>\n' ' </tbody>\n') expected_result = ('%s%s%s' % (self.html_table_start, body, self.html_table_end)) actual_result = Table('foobar') message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('table_table_from_string')
def _parse(self): indices = [] text = self.text lines = text.split("\n") for line_num in range(len(lines)): l = lines[line_num] if re.search(_header_regex, l.strip(_trash)): indices.append(line_num) if len(indices) == 0: return None table_text = [] for i in range(len(indices) - 1): table_text.append("\n".join(lines[indices[i]:indices[i + 1]])) table_text.append("\n".join(lines[indices[-1]:])) self.tables = [Table(t) for t in table_text]
def buildReplacementRules(self, state, callbacks): """ Builds the replacement rules section in the configuration page """ rules = JPanel() rules.setLayout(None) rules.setMaximumSize(Dimension(self.CONFIG_PAGE_WIDTH, 300)) title = self.getTitle("Replacement Rules", 20, 10) add = self.getButton("Add", 20, 50) add.addActionListener(self.callbacks.addButtonClicked) edit = self.getButton("Edit", 20, 90) edit.addActionListener(self.callbacks.editButtonClicked) delete = self.getButton("Delete", 20, 130) delete.addActionListener(self.callbacks.deleteButtonClicked) table = Table(state.replacementRuleTableModel) tableView = JScrollPane(table) tableView.setBounds(180, 50, 800, 240) rules.add(title) rules.add(add) rules.add(edit) rules.add(delete) rules.add(tableView) try: storedReplacementRules = callbacks.loadExtensionSetting( "replacementRules") if storedReplacementRules: state.replacementRuleTableModel.importJsonRules( storedReplacementRules) else: log("No replacement rules stored.") except (ValueError, KeyError): log("Invalid replacement rules stored. Ignoring.") pass return rules
def test_column(self): """Test to retrieve all element in a column. """ table_body = [] header = TableRow(['header1', 'header2', 'header3', 'header4'], header=True) table_body.append(header) table_body.append(TableRow([1, 2, 3, 4])) table_body.append(TableRow(['a', 'b', 'c', 'd'])) table_body.append(TableRow(['x', 'y', 'z', 't'])) myTable = Table(table_body) expected_result1 = ['header1', 1, 'a', 'x'] expected_result2 = [2, 'b', 'y'] real_result1 = myTable.column(0, True) real_result2 = myTable.column(1) myMessage1 = "Expected %s but got %s" % (expected_result1, real_result1) myMessage2 = "Expected %s but got %s" % (expected_result2, real_result2) assert expected_result1 == real_result1, myMessage1 assert expected_result2 == real_result2, myMessage2
def test_copy(self): for v in self.types.values(): for x in v: T = Table(rows=2, columns=2, fill=x) for (col, row) in product([None, 0, 1], repeat=2): C = T.copy(rows=row, columns=col) self.assertIsNot(T, C, msg=f'Tables not a copy for fill={x}') if col is None: columns = 2 else: columns = 1 if row is None: rows = 2 else: rows = 1 msg = (f'Not {rows} rows, with ' f'copy(rows={row},columns={col})') self.assertEqual(C.row_count, rows, msg=msg) msg = (f'Not {columns} columns, with ' f'copy(rows={row},columns={col})') self.assertEqual(C.column_count, columns, msg=msg) for (t, c) in zip(T.cells, C.cells): self.assertIsNot( t, c, msg=f'Cells {t} and {c} not a copy for fill={x}') # Mutable objects # Shallow search # TODO deep search if not isinstance(t.value, (str, int, bool, float, tuple)): if not isinstance(c.value, (str, int, bool, float, tuple)): self.assertIsNot( t.value, c.value, msg=(f'Cellvalues {t} and {c}' f' not a copy for fill={x}'))
def test_cell_link(self): """Test cell links work""" table_cell_link = Link('InaSAFE', 'http://inasafe.org') table_row = TableRow([ TableCell(table_cell_link), self.table_cell_b, self.table_cell_c, self.table_cell_d ]) self.html += ' <h2>Link Cell Columns</h2>\n' body = (' <tbody>\n' ' <tr>\n' ' <td><a href="http://inasafe.org">InaSAFE</a></td>\n' ' <td>b</td>\n' ' <td>c</td>\n' ' <td>d</td>\n' ' </tr>\n' ' </tbody>\n') expected_result = ('%s%s%s' % (self.html_table_start, body, self.html_table_end)) actual_result = Table([table_row]) message = 'Expected: %s\n\nGot: %s' % (expected_result, actual_result) assert expected_result.strip() == str(actual_result).strip(), message self.html += str(actual_result) self.writeHtml('table_colspanning')
KX_unk = module.getOutput('KX_output') print "KX =", KX_unk[-1][1].getColumn(3)[0:30] T_unk = module.getOutput('T_output') print "tracor =", T_unk[-1][1].getColumn(3)[0:30] time = K_unk[-1][0] print "time = ", time KY = K_unk[-1][1] TY = T_unk[-1][1] XListe = KY.getColumn(0) dx0 = 0.04 / 100 dxListe = [dx0] * 100 from tables import Table tab1 = Table(name='KY') tab1.addColumn('X', XListe) tab1.addColumn('Y', KY.getColumn(1)) tab1.addColumn('K', KY.getColumn(3)) KY = tab1 tab2 = Table(name='KT') tab2.addColumn('X', XListe) tab2.addColumn('Y', TY.getColumn(1)) tab2.addColumn('K', TY.getColumn(3)) TY = tab2 from _erffunctions import * C0 = 1.0e-03 porosity = 1.0 darcy = 1.e-3 / 3600
### ID calculation and assignment phase ### Occupied IDs are determined and free IDs are assigned ### to new values min_free_ids = {} args = parse_args() all_cards = get_data_frames(args.inputs) # Obtain first free_id min_free_ids['card_id'] = get_free_min_id(args.cards_table, args.card_id_column) new_cards = [] physical_cards = [] color_table = [] current_artists = Table(args.artist_id_column, args.artists_table, columns=['artist']) current_types = Table(args.type_id_column, args.types_table, columns=['type']) current_physicals = Table(args.physical_card_id_column, args.physical_cards_table, columns=['gatherer_id']) current_sets = Table(args.set_id_column, args.sets_table, columns=['set']) joins_artists_table = [] joins_types_table = [] corrections = artists.load_artist_correction_dict(args.correction_file) # Begin to parse new cards to generate new database import tables for index, raw_card in all_cards.iterrows(): print 'Processing: %s' % raw_card['card_name'] new_card_id = index + min_free_ids['card_id'] new_card = generate_new_card(raw_card, new_card_id, args.card_id_column)