class_docstr: An ASCII picture.
  The pictures are represented as a list of equal length strings.
class_docstr_tok: ["An","ASCII","picture",".","The","pictures","are","represented","as","a","list","of","equal","length","strings","."]
docstr: Return the string form of self.
  
  Unless the argument line_break is set to False, it will
  break the expression in a form that can be printed
  on the terminal without being broken up.
docstr_tok: ["Return","the","string","form","of","self",".","Unless","the","argument","line_break","is","set","to","False",",","it","will","break","the","expression","in","a","form","that","can","be","printed","on","the","terminal","without","being","broken","up","."]
code: def render(self, *args, **kwargs):
      """Return the string form of self.
  
      Unless the argument line_break is set to False, it will
      break the expression in a form that can be printed
      on the terminal without being broken up.
      """
      if kwargs["wrap_line"] is False:
          return "\n".join(self.picture)
  
      if kwargs["num_columns"] is not None:
          # Read the argument num_columns if it is not None
          ncols = kwargs["num_columns"]
      else:
          # Attempt to get a terminal width
          ncols = self.terminal_width()
  
      if ncols <= 0:
          ncols = 80
  
      # If smaller than the terminal width, no need to correct
      if self.width() <= ncols:
          return type(self.picture[0])(self)
  
      """
          Break long-lines in a visually pleasing format.
          without overflow indicators | with overflow indicators
          |   2  2        3     |     |   2  2        3    ↪|
          |6*x *y  + 4*x*y  +   |     |6*x *y  + 4*x*y  +  ↪|
          |                     |     |                     |
          |     3    4    4     |     |↪      3    4    4   |
          |4*y*x  + x  + y      |     |↪ 4*y*x  + x  + y    |
          |a*c*e + a*c*f + a*d  |     |a*c*e + a*c*f + a*d ↪|
          |*e + a*d*f + b*c*e   |     |                     |
          |+ b*c*f + b*d*e + b  |     |↪ *e + a*d*f + b*c* ↪|
          |*d*f                 |     |                     |
          |                     |     |↪ e + b*c*f + b*d*e ↪|
          |                     |     |                     |
          |                     |     |↪ + b*d*f            |
          """
  
      overflow_first = ""
      if kwargs["use_unicode"] or pretty_use_unicode():
          overflow_start = "\N{RIGHTWARDS ARROW WITH HOOK} "
          overflow_end = " \N{RIGHTWARDS ARROW WITH HOOK}"
      else:
          overflow_start = "> "
          overflow_end = " >"
  
      def chunks(line):
          """Yields consecutive chunks of line_width ncols"""
          prefix = overflow_first
          width, start = line_width(prefix + overflow_end), 0
          for i, x in enumerate(line):
              wx = line_width(x)
              # Only flush the screen when the current character overflows.
              # This way, combining marks can be appended even when width == ncols.
              if width + wx > ncols:
                  yield prefix + line[start:i] + overflow_end
                  prefix = overflow_start
                  width, start = line_width(prefix + overflow_end), i
              width += wx
          yield prefix + line[start:]
  
      # Concurrently assemble chunks of all lines into individual screens
      pictures = zip(*map(chunks, self.picture))
  
      # Join lines of each screen into sub-pictures
      pictures = ["\n".join(picture) for picture in pictures]
  
      # Add spacers between sub-pictures
      return "\n\n".join(pictures)
  
imports: import shutil
  from .pretty_symbology import hobj, vobj, xsym, xobj, pretty_use_unicode, line_width, center
  from sympy.utilities.exceptions import sympy_deprecation_warning
label_desc: Use image node_id 14 for calling the stringPict obj's underlying member method code with example usage: obj.render() and returns: str, str, type