docs: def exact(cls, value, precision=None):
          """Convert an integer, float or BigFloat with no loss of precision.
          Also convert a string with given precision.
  
          This constructor makes no use of the current context.
          """
          # figure out precision to use
          if isinstance(value, six.string_types):
              if precision is None:
                  raise TypeError("precision must be supplied when "
                                  "converting from a string")
          else:
              if precision is not None:
                  raise TypeError("precision argument should not be "
                                  "specified except when converting "
                                  "from a string")
              if isinstance(value, float):
                  precision = _builtin_max(DBL_PRECISION, PRECISION_MIN)
              elif isinstance(value, six.integer_types):
                  precision = _builtin_max(_bit_length(value), PRECISION_MIN)
              elif isinstance(value, BigFloat):
                  precision = value.precision
              else:
                  raise TypeError("Can't convert argument %s of type %s "
                                  "to BigFloat" % (value, type(value)))
  
          # Use unlimited exponents, with given precision.
          with _saved_flags():
              set_flagstate(set())  # clear all flags
              context = (
                  WideExponentContext +
                  Context(precision=precision) +
                  RoundTiesToEven
              )
              with context:
                  result = BigFloat(value)
              if test_flag(Overflow):
                  raise ValueError("value too large to represent as a BigFloat")
              if test_flag(Underflow):
                  raise ValueError("value too small to represent as a BigFloat")
              if test_flag(Inexact) and not isinstance(value, six.string_types):
                  # since this is supposed to be an exact conversion, the
                  # inexact flag should never be set except when converting
                  # from a string.
                  assert False, ("Inexact conversion in BigFloat.exact. "
                                 "This shouldn't ever happen.  Please report.")
  
          return result