def display(self, prefix="", ostream=None): """ Print component state information This duplicates logic in Component.pprint() """ if not self.active: return if ostream is None: ostream = sys.stdout tab = " " ostream.write(prefix + self.local_name + " : ") ostream.write("Size=" + str(len(self))) ostream.write("\n") def _line_generator(k, v): for _k, _v in sorted(v.vars.items()): if _v is None: _val = '-' elif not hasattr(_v, 'is_indexed') or not _v.is_indexed(): _val = str(value(_v)) else: _val = "{%s}" % (', '.join('%r: %r' % (x, value(_v[x])) for x in sorted(_v._data)), ) yield _k, _val tabular_writer(ostream, prefix + tab, ((k, v) for k, v in self._data.items()), ("Name", "Value"), _line_generator)
def _pprint_base_impl(self, ostream, verbose, prefix, _name, _doc, _constructed, _attr, _data, _header, _fcn): if ostream is None: ostream = sys.stdout if prefix: ostream = StreamIndenter(ostream, prefix) # FIXME: HACK for backwards compatability with suppressing the # header for the top block if not _attr and self.parent_block() is None: _name = '' # We only indent everything if we printed the header if _attr or _name or _doc: ostream = StreamIndenter(ostream, self._PPRINT_INDENT) # The first line should be a hanging indent (i.e., not indented) ostream.newline = False if self.is_reference(): _attr = list(_attr) if _attr else [] _attr.append(('ReferenceTo', self.referent)) if _name: ostream.write(_name + " : ") if _doc: ostream.write(_doc + '\n') if _attr: ostream.write(", ".join("%s=%s" % (k, v) for k, v in _attr)) if _attr or _name or _doc: ostream.write("\n") if not _constructed: # HACK: for backwards compatability, Abstract blocks will # still print their assigned components. Should we instead # always pprint unconstructed components (possibly # suppressing the table header if the table is empty)? if self.parent_block() is not None: ostream.write("Not constructed\n") return if type(_fcn) is tuple: _fcn, _fcn2 = _fcn else: _fcn2 = None if _header is not None: if _fcn2 is not None: _data_dict = dict(_data) _data = _data_dict.items() tabular_writer(ostream, '', _data, _header, _fcn) if _fcn2 is not None: for _key in sorted_robust(_data_dict): _fcn2(ostream, _key, _data_dict[_key]) elif _fcn is not None: _data_dict = dict(_data) for _key in sorted_robust(_data_dict): _fcn(ostream, _key, _data_dict[_key]) elif _data is not None: ostream.write(_data)
def test_no_data(self): os = StringIO() data = {} tabular_writer(os, "", data.items(), ['s', 'val'], lambda k, v: v) ref = u""" Key : s : val """ self.assertEqual(ref.strip(), os.getvalue().strip())
def test_no_header(self): os = StringIO() data = {(2, ): (["a", 1], 1), (1, 3): ({1: 'a', 2: '2'}, '2')} tabular_writer(os, "", data.items(), [], lambda k, v: v) ref = u""" {1: 'a', 2: '2'} : 2 ['a', 1] : 1 """ self.assertEqual(ref.strip(), os.getvalue().strip())
def test_tuple_list_dict(self): os = StringIO() data = {(1, ): (["a", 1], 1), ('2', 3): ({1: 'a', 2: '2'}, '2')} tabular_writer(os, "", data.items(), ["s", "val"], lambda k, v: v) ref = u""" Key : s : val (1,) : ['a', 1] : 1 ('2', 3) : {1: 'a', 2: '2'} : 2 """ self.assertEqual(ref.strip(), os.getvalue().strip())
def test_unicode_table(self): # Test that an embedded unicode character does not foul up the # table alignment os = StringIO() data = {1: ("a", 1), (2, 3): ("∧", 2)} tabular_writer(os, "", data.items(), ["s", "val"], lambda k, v: v) ref = u""" Key : s : val 1 : a : 1 (2, 3) : ∧ : 2 """ self.assertEqual(ref.strip(), os.getvalue().strip())
def test_data_exception(self): os = StringIO() data = {'a': 0, 'b': 1, 'c': 3} def _data_gen(i, j): if i == 'b': raise ValueError("invalid") return (j, i * (j + 1)) tabular_writer(os, "", data.items(), ['i', 'j'], _data_gen) ref = u""" Key : i : j a : 0 : a b : None : None c : 3 : cccc """ self.assertEqual(ref.strip(), os.getvalue().strip())
def test_multiline_generator(self): os = StringIO() data = {'a': 0, 'b': 1, 'c': 3} def _data_gen(i, j): for n in range(j): yield (n, chr(ord('a') + n) * j) tabular_writer(os, "", data.items(), ['i', 'j'], _data_gen) ref = u""" Key : i : j a : None : None b : 0 : a c : 0 : aaa : 1 : bbb : 2 : ccc """ self.assertEqual(ref.strip(), os.getvalue().strip())
def display(self, prefix="", ostream=None): """TODO""" if not self.active: return if ostream is None: ostream = sys.stdout tab = " " ostream.write(prefix + self.local_name + " : ") ostream.write("Size=" + str(len(self))) ostream.write("\n") tabular_writer( ostream, prefix+tab, ((k,v) for k,v in self._data.items()), ( "Value", ), lambda k, v: \ ["Undefined" if v.expr is None else v()])
def display(self, prefix="", ostream=None): """ Print component state information This duplicates logic in Component.pprint() """ if not self.active: return if ostream is None: ostream = sys.stdout tab = " " ostream.write(prefix + self.local_name + " : ") ostream.write("Size=" + str(len(self))) ostream.write("\n") tabular_writer(ostream, prefix + tab, ((k, v) for k, v in self._data.items() if v.active), ("Body",), lambda k, v: [v.body(), ])
def display(self, prefix="", ostream=None): """Provide a verbose display of this object""" if not self.active: return tab = " " if ostream is None: ostream = sys.stdout ostream.write(prefix+self.local_name+" : ") ostream.write(", ".join("%s=%s" % (k,v) for k,v in [ ("Size", len(self)), ("Index", self._index_set if self.is_indexed() else None), ("Active", self.active), ] )) ostream.write("\n") tabular_writer( ostream, prefix+tab, ((k,v) for k,v in self._data.items() if v.active), ( "Active","Value" ), lambda k, v: [ v.active, value(v), ] )
def test_multiline_alignment(self): os = StringIO() data = {'a': 1, 'b': 2, 'c': 3} def _data_gen(i, j): for n in range(j): _str = chr(ord('a') + n) * (j + 1) if n % 2: _str = list(_str) _str[1] = ' ' _str = ''.join(_str) yield (n, _str) tabular_writer(os, "", data.items(), ['i', 'j'], _data_gen) ref = u""" Key : i : j a : 0 : aa b : 0 : aaa : 1 : b b c : 0 : aaaa : 1 : b bb : 2 : cccc """ self.assertEqual(ref.strip(), os.getvalue().strip())
def report(self, index=(0), true_state=False, dof=False, ostream=None, prefix=""): """ Default report method for StateBlocks. Returns a Block report populated with either the display or state variables defined in the StateBlockData class. Args: index : tuple of Block indices indicating which point in time (and space if applicable) to report state at. true_state : whether to report the display variables (False default) or the actual state variables (True) dof : whether to show local degrees of freedom in the report (default=False) ostream : output stream to write report to prefix : string to append to the beginning of all output lines Returns: Printed output to ostream """ if ostream is None: ostream = sys.stdout # Get DoF and model stats if dof: dof_stat = degrees_of_freedom(self[index]) nv = number_variables(self[index]) nc = number_activated_constraints(self[index]) nb = number_activated_blocks(self[index]) # Create stream table if true_state: disp_dict = self[index].define_state_vars() else: disp_dict = self[index].define_display_vars() stream_attributes = {} for k in disp_dict: for i in disp_dict[k]: if i is None: stream_attributes[k] = disp_dict[k][i] else: stream_attributes[k + " " + i] = disp_dict[k][i] # Write output max_str_length = 84 tab = " " * 4 ostream.write("\n" + "=" * max_str_length + "\n") lead_str = f"{prefix}State : {self.name}" trail_str = f"Index: {index}" mid_str = " " * (max_str_length - len(lead_str) - len(trail_str)) ostream.write(lead_str + mid_str + trail_str) if dof: ostream.write("\n" + "=" * max_str_length + "\n") ostream.write(f"{prefix}{tab}Local Degrees of Freedom: {dof_stat}") ostream.write('\n') ostream.write(f"{prefix}{tab}Total Variables: {nv}{tab}" f"Activated Constraints: {nc}{tab}" f"Activated Blocks: {nb}") ostream.write("\n" + "-" * max_str_length + "\n") ostream.write(f"{prefix}{tab}State Report") if any(isinstance(v, _VarData) for k, v in stream_attributes.items()): ostream.write("\n" * 2) ostream.write(f"{prefix}{tab}Variables: \n\n") tabular_writer( ostream, prefix + tab, ((k, v) for k, v in stream_attributes.items() if isinstance(v, _VarData)), ("Value", "Fixed", "Bounds"), lambda k, v: ["{:#.5g}".format(value(v)), v.fixed, v.bounds]) if any( isinstance(v, _ExpressionData) for k, v in stream_attributes.items()): ostream.write("\n" * 2) ostream.write(f"{prefix}{tab}Expressions: \n\n") tabular_writer(ostream, prefix + tab, ((k, v) for k, v in stream_attributes.items() if isinstance(v, _ExpressionData)), ("Value", ), lambda k, v: ["{:#.5g}".format(value(v))]) ostream.write("\n" + "=" * max_str_length + "\n")