docs: def write_eps(matrix, version, out, scale=1, border=None, color='#000',
                background=None):
      """\
      Serializes the QR Code as EPS document.
  
      :param matrix: The matrix to serialize.
      :param int version: The (Micro) QR code version
      :param out: Filename or a file-like object supporting to write strings.
      :param scale: Indicates the size of a single module (default: 1 which
              corresponds to 1 point (1/72 inch) per module).
      :param int border: Integer indicating the size of the quiet zone.
              If set to ``None`` (default), the recommended border size
              will be used (``4`` for QR Codes, ``2`` for a Micro QR Codes).
      :param color: Color of the modules (default: black). The
              color can be provided as ``(R, G, B)`` tuple (this method
              acceppts floats as R, G, B values), as web color name (like
              "red") or in hexadecimal format (``#RGB`` or ``#RRGGBB``).
      :param background: Optional background color (default: ``None`` = no
              background color). See `color` for valid values.
      """
      import textwrap
  
      def write_line(writemeth, content):
          """\
          Writes `content` and ``LF``.
          """
          # Postscript: Max. 255 characters per line
          for line in textwrap.wrap(content, 254):
              writemeth(line)
              writemeth('\n')
  
      def rgb_to_floats(clr):
          """\
          Converts the provided color into an acceptable format for Postscript's
           ``setrgbcolor``
          """
          def to_float(c):
              if isinstance(c, float):
                  if not 0.0 <= c <= 1.0:
                      raise ValueError('Invalid color "{0}". Not in range 0 .. 1'
                                       .format(c))
                  return c
              return 1 / 255.0 * c if c != 1 else c
  
          return tuple([to_float(i) for i in colors.color_to_rgb(clr)])
  
      check_valid_scale(scale)
      check_valid_border(border)
      with writable(out, 'wt') as f:
          writeline = partial(write_line, f.write)
          border = get_border(version, border)
          width, height = get_symbol_size(version, scale, border)
          # Write common header
          writeline('%!PS-Adobe-3.0 EPSF-3.0')
          writeline('%%Creator: {0}'.format(CREATOR))
          writeline('%%CreationDate: {0}'.format(time.strftime("%Y-%m-%d %H:%M:%S")))
          writeline('%%DocumentData: Clean7Bit')
          writeline('%%BoundingBox: 0 0 {0} {1}'.format(width, height))
          # Write the shortcuts
          writeline('/m { rmoveto } bind def')
          writeline('/l { rlineto } bind def')
          stroke_color_is_black = colors.color_is_black(color)
          stroke_color = color if stroke_color_is_black else rgb_to_floats(color)
          if background is not None:
              writeline('{0:f} {1:f} {2:f} setrgbcolor clippath fill'
                        .format(*rgb_to_floats(background)))
              if stroke_color_is_black:
                  # Reset RGB color back to black iff stroke color is black
                  # In case stroke color != black set the RGB color later
                  writeline('0 0 0 setrgbcolor')
          if not stroke_color_is_black:
              writeline('{0:f} {1:f} {2:f} setrgbcolor'.format(*stroke_color))
          if scale != 1:
              writeline('{0} {0} scale'.format(scale))
          writeline('newpath')
          # Current pen position y-axis
          # Note: 0, 0 = lower left corner in PS coordinate system
          y = get_symbol_size(version, scale=1, border=0)[1] + border - .5  # .5 = linewidth / 2
          line_iter = matrix_to_lines(matrix, border, y, incby=-1)
          # EPS supports absolute coordinates as well, but relative coordinates
          # are more compact and IMO nicer; so the 1st coordinate is absolute, all
          # other coordinates are relative
          (x1, y1), (x2, y2) = next(line_iter)
          coord = ['{0} {1} moveto {2} 0 l'.format(x1, y1, x2 - x1)]
          append_coord = coord.append
          x = x2
          for (x1, y1), (x2, y2) in line_iter:
              append_coord(' {0} {1} m {2} 0 l'.format(x1 - x, int(y1 - y), x2 - x1))
              x, y = x2, y2
          writeline(''.join(coord))
          writeline('stroke')
          writeline('%%EOF')