docs: def horizontal_graph(*args):
      r"""Consume an iterable of integers and produce a horizontal bar graph using
      braille characters.
  
      The graph is horizontal in that its dependent axis is the horizontal axis.
      Thus each value is represented as a column running bottom to top, and
      values are listed left to right.
  
      The graph is anchored to the bottom, so columns fill in from the bottom of
      the current braille character and the next character is added on top when
      needed. For columns with no dots, the blank braille character is used, not
      a space character.
  
          >>> horizontal_graph([1, 2, 3, 4])
          '⣠⣾'
          >>> horizontal_graph([1, 2, 3, 4, 5, 6])
          '⠀⠀⣠\n⣠⣾⣿'
          >>> print(horizontal_graph([1, 2, 3, 4, 5, 6]))
          ⠀⠀⣠
          ⣠⣾⣿
  
      Alternately, the arguments can be passed directly:
  
          >>> horizontal_graph(1, 2, 3, 4)
          '⣠⣾'
  
      """
      lines = []
  
      # If the arguments were passed as a single iterable, pull it out.
      # Otherwise, just use them as-is.
      if len(args) == 1:
  
          bars = args[0]
      else:
          bars = args
  
      # Break the bars into groups of two, one for each column in the braille
      # blocks.
      for bar_group in _chunk(bars, 2):
          column = []
  
          for braille_col, bar_value in enumerate(bar_group):
              # The number of full braille blocks needed to draw this bar. Each
              # block is four dots tall.
              full_blocks_needed = bar_value // 4
  
              # The number of braille blocks needed to draw this bar. This
              # accounts for a possible partial block.
              blocks_needed = full_blocks_needed + (1 if bar_value % 4 else 0)
  
              # The number of new lines we'll need to prepend to accomodate this
              # bar
              extra_blocks_needed = blocks_needed - len(column)
  
              # If we need extra blocks, add them.
              column = ([_BRAILLE_EMPTY_BLOCK] * extra_blocks_needed) + column
  
              # Fill in the majority of the column with full braille colums (four
              # dots). We negate the index to access from the end of the list.
              for block_index in range(-full_blocks_needed, 0, 1):
                  column[block_index] += _BRAILLE_FULL_COL[braille_col]
  
              # If we need a partial column, fill it in. We negate the index to
              # access from the end of the list.
              if bar_value % 4:
                  partial_index = (bar_value % 4) - 1
                  column[-blocks_needed] += (
                      _BRAILLE_PARTIAL_COL[braille_col][partial_index]
                  )
  
          # Add this column to the lines.
          _matrix_add_column(lines, column, default=_BRAILLE_EMPTY_BLOCK)
  
      # Convert all the code points into characters, concatenate them into lines,
      # then concatenate all the lines to make the final graph.
      return '\n'.join(''.join(chr(code) for code in line) for line in lines)