Support for writing fractional seconds

[belegdol]

Now that we can read fractional seconds, it would be interesting to see whether we can easily implement writing.
I have done some brief tests with write_xport(), and was able to produce reasonable results by removing the two round() calls from

pyreadstat/pyreadstat/_readstat_writer.pyx

Line 91 in e23b1d8

df = df.with_columns((((nw.nth(col_indx).cast(nw.Float64))/convfac) + offset_secs).round() * mulfac)

and

pyreadstat/pyreadstat/_readstat_writer.pyx

Line 141 in e23b1d8

df = df.with_columns((nw.nth(col_indx).cast(nw.Float64)/1e9).round() * mulfac)

What I am not clear on is when the vectorized functions are used vs convert_datetimelike_to_number()
This is a simple reproducer:

import pandas as pd
import pyreadstat

df = pd.DataFrame.from_dict({"min": pd.to_datetime("1850-01-01 12:34:56.123456"), "max": pd.to_datetime("2100-12-31 23:45:56.123456")}, columns=["testdt"], orient="index")
print(df)
pyreadstat.write_xport(df, "./minmax.xpt")

sasdf, meta = pyreadstat.read_xport(
    "./minmax.xpt", output_format="polars")

print(sasdf)

With current code, sasdf is truncated to whole seconds. With the round() call removed, microseconds are preserved.

[ofajardo]

The values of the columns are classified as either PYWRITER_DATETIME or PYWRITER_DATETIME64:

pyreadstat/pyreadstat/_readstat_writer.pyx

Lines 347 to 358 in e23b1d8

	elif col_type == nw.Datetime:
	if col_type.time_unit == 'us':
	result.append((PYWRITER_DATETIME64, 0,has_missing, 'us'))
	continue
	elif col_type.time_unit == 'ns':
	result.append((PYWRITER_DATETIME64, 0,has_missing, 'ns'))
	continue
	elif col_type.time_unit == 'ms':
	result.append((PYWRITER_DATETIME64, 0,has_missing, 'ms'))
	continue
	else:
	result.append((PYWRITER_DATETIME, 0, has_missing, None))

think for instance in an pandas object column with python datetime.datetime (or datetime.time) elements, vectorized operations cannot be applied to those, so those will become PYWRITER_DATETIME)

then depending on which type the vectorized conversion is applied (for 64 variant), or the non vectorized version

[belegdol]

It looks like implementing this properly across all the codepaths and backends might be quite challenging if not impossible.
I experimented a bit with the approach from PR #337, and the result of the final conversion from decimal to float appears to be influenced by the selected backend. This results in three mismatches in the fractional_seconds test case.
As an example, 2278-04-20T12:41:18.331215 ends up cast to decimal 10044650478.331215 by both pandas and polars, but once converted to float, it ends up as 1.00446504783312168e10 in polars and 10.04465047833121500E+09 in pandas. This is using exactly the same narwhals code. Upon closer inspection, these values differ by exactly one bit.
While 2278 is slightly beyond where microsecond-level precision is possible using 64-bit floating point, it appears to be possible to produce a number matching what SAS is doing.