Hello community,
here is the log from the commit of package python-skyfield for openSUSE:Factory
checked in at 2020-07-24 10:02:24
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-skyfield (Old)
and /work/SRC/openSUSE:Factory/.python-skyfield.new.3592 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-skyfield"
Fri Jul 24 10:02:24 2020 rev:2 rq:822291 version:1.24
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-skyfield/python-skyfield.changes
2020-07-14 08:00:04.913943558 +0200
+++
/work/SRC/openSUSE:Factory/.python-skyfield.new.3592/python-skyfield.changes
2020-07-24 10:04:19.685873586 +0200
@@ -1,0 +2,27 @@
+Wed Jul 22 14:42:06 UTC 2020 - Benjamin Greiner <c...@bnavigator.de>
+
+- release precision for i586 test
+ gh#skyfielders/python-skyfield#411
+
+-------------------------------------------------------------------
+Wed Jul 22 14:13:46 UTC 2020 - Benjamin Greiner <c...@bnavigator.de>
+
+- Update to Version 1.24
+ * Added methods :meth:`~skyfield.timelib.Timescale.from_datetime()`
+ and :meth:`~skyfield.timelib.Timescale.from_datetimes()` to
+ the :class:`~skyfield.timelib.Timescale` class, to
+ better advertise the ability to build a Skyfield time
+ from a Python datetime — an ability that was previously
+ overloaded into the year parameter of the
+ :meth:`~skyfield.timelib.Timescale.utc()` method (where
+ it is still supported for backwards compatibility, but
+ no longer documented).
+ * Fix: improved the accuracy with which velocity is
+ converted between the Earth-fixed ITRF frame that rotates
+ with the Earth and the inertial GCRS frame that does not.
+ In particular, this should make Earth satellite
+ velocities more accurate.
+- rebase patches skyfield-pr404-comparefloat.patch
+ and skyfield-pr405-replace-assay-by-pytest.patch
+
+-------------------------------------------------------------------
Old:
----
skyfield-1.23.tar.gz
New:
----
skyfield-1.24.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-skyfield.spec ++++++
--- /var/tmp/diff_new_pack.RalY61/_old 2020-07-24 10:04:26.693878937 +0200
+++ /var/tmp/diff_new_pack.RalY61/_new 2020-07-24 10:04:26.693878937 +0200
@@ -17,12 +17,11 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
+%define assaycommit 18f320237345813a49173657e7d2d6ca85e9a38a
+%define assayver 245.18f3202
%define skip_python2 1
-%ifarch %{ix86}
-%define skyfield_atol export SKYFIELD_TEST_DEFAULT_ATOL=2e-16
-%endif
Name: python-skyfield
-Version: 1.23
+Version: 1.24
Release: 0
Summary: Elegant astronomy for Python
License: MIT
@@ -39,11 +38,10 @@
Source8: https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat
Source9: http://cdsarc.u-strasbg.fr/ftp/cats/I/239/hip_main.dat.gz
Source99: python-skyfield-rpmlintrc
-# PR404 Refine some float comparisons in the unit tests for flaky platforms
-Patch0:
https://github.com/skyfielders/python-skyfield/pull/404.patch#/skyfield-pr404-comparefloat.patch
-# PR405 Replace upstreams custom testrunner 'assay' with standard pytest
(first commit the rest is git repository specific)
-# https://github.com/skyfielders/python-skyfield/pull/405
-Patch1:
https://github.com/skyfielders/python-skyfield/pull/405/commits/cc229382ea8f301a1d911f228482feb043fc4db1.patch#/skyfield-pr405-replace-assay-by-pytest.patch
+# PR404 Refine some float comparisons in the unit tests for flaky platforms
gh#skyfielders/python-skyfield#404
+Patch0: skyfield-pr404-comparefloat.patch
+# PR405 Replace upstreams custom testrunner 'assay' with standard pytest
gh#skyfielders/python-skyfield#405
+Patch1: skyfield-pr405-replace-assay-by-pytest.patch
BuildRequires: %{python_module astropy}
BuildRequires: %{python_module beautifulsoup4}
BuildRequires: %{python_module certifi}
@@ -78,6 +76,8 @@
%prep
%setup -q -n skyfield-%{version}
%autopatch -p1
+# https://github.com/skyfielders/python-skyfield/issues/411
+sed -i -e 's/assert relative_error < 2e-12/assert relative_error < 4e-12/'
skyfield/tests/test_positions.py
# copy all test data files into the rootdir
cp %{SOURCE1} %{SOURCE2} %{SOURCE3} %{SOURCE4} %{SOURCE5} %{SOURCE6}
%{SOURCE7} %{SOURCE8} %{SOURCE9} ./
@@ -89,9 +89,7 @@
%python_expand %fdupes %{buildroot}%{$python_sitelib}
%check
-# https://github.com/skyfielders/python-skyfield/pull/404
-%{?skyfield_atol}
-%pytest -v
+%pytest
%files %{python_files}
%doc README.rst
++++++ skyfield-1.23.tar.gz -> skyfield-1.24.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/PKG-INFO new/skyfield-1.24/PKG-INFO
--- old/skyfield-1.23/PKG-INFO 2020-07-09 21:14:04.000000000 +0200
+++ new/skyfield-1.24/PKG-INFO 2020-07-21 03:45:09.000000000 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: skyfield
-Version: 1.23
+Version: 1.24
Summary: Elegant astronomy for Python
Home-page: http://github.com/brandon-rhodes/python-skyfield/
Author: Brandon Rhodes
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/__init__.py
new/skyfield-1.24/skyfield/__init__.py
--- old/skyfield-1.23/skyfield/__init__.py 2020-07-09 21:10:44.000000000
+0200
+++ new/skyfield-1.24/skyfield/__init__.py 2020-07-21 03:40:13.000000000
+0200
@@ -5,5 +5,5 @@
the source code, as well as the http://rhodesmill.org/skyfield/ site!
"""
-VERSION = (1, 23)
+VERSION = (1, 24)
__version__ = '.'.join(map(str, VERSION))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/constants.py
new/skyfield-1.24/skyfield/constants.py
--- old/skyfield-1.23/skyfield/constants.py 2020-07-09 20:14:26.000000000
+0200
+++ new/skyfield-1.24/skyfield/constants.py 2020-07-19 11:37:49.000000000
+0200
@@ -14,12 +14,12 @@
tau = 6.283185307179586476925287 # lower case, for symmetry with math.pi
# Physics.
-C = 299792458.0
+C = 299792458.0 # m/s
GM_SUN_Pitjeva_2005_km3_s2 = 132712440042 # Elena Pitjeva, 2015JPCRD..44c1210P
# Earth and its orbit.
-ANGVEL = 7.2921150e-5
-ERAD = 6378136.6
+ANGVEL = 7.2921150e-5 # radians/s
+ERAD = 6378136.6 # meters
IERS_2010_INVERSE_EARTH_FLATTENING = 298.25642
# Heliocentric gravitational constant in meters^3 / second^2, from DE-405.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/documentation/api.rst
new/skyfield-1.24/skyfield/documentation/api.rst
--- old/skyfield-1.23/skyfield/documentation/api.rst 2020-07-08
15:40:30.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/api.rst 2020-07-17
16:17:03.000000000 +0200
@@ -71,6 +71,8 @@
.. autosummary::
Timescale.now
+ Timescale.from_datetime
+ Timescale.from_datetimes
Timescale.utc
Timescale.tai
Timescale.tai_jd
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/skyfield-1.23/skyfield/documentation/bibliography.rst
new/skyfield-1.24/skyfield/documentation/bibliography.rst
--- old/skyfield-1.23/skyfield/documentation/bibliography.rst 2020-06-07
23:42:21.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/bibliography.rst 2020-07-10
02:16:57.000000000 +0200
@@ -8,7 +8,7 @@
*USNO Circular 179*
by George H. Kaplan, October 2005
- http://aa.usno.navy.mil/publications/docs/Circular_179.php
+
https://www.usno.navy.mil/USNO/astronomical-applications/publications/Circular_179.pdf/at_download/file
My favorite introduction to how the International Astronomical Union
responded in 1997 and 2000 to the problems with the old J2000 system
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/skyfield-1.23/skyfield/documentation/earth-satellites.rst
new/skyfield-1.24/skyfield/documentation/earth-satellites.rst
--- old/skyfield-1.23/skyfield/documentation/earth-satellites.rst
2020-06-16 03:59:17.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/earth-satellites.rst
2020-07-20 17:46:34.000000000 +0200
@@ -292,7 +292,7 @@
.. testoutput::
- [-3918.8765203 -1887.6483254 5209.08802574]
+ [-3918.8765203 -1887.6483254 5209.08802574]
.. would love to be able to do this someday - see the SPICE source file
nearpt.f
@@ -365,7 +365,7 @@
.. testoutput::
- [ 331.61883654 392.18468664 1049.76011302]
+ [ 331.61883722 392.18468536 1049.76011302]
But the most popular approach is to ask the topocentric position
for its altitude and azimuth coordinates,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/documentation/examples.rst
new/skyfield-1.24/skyfield/documentation/examples.rst
--- old/skyfield-1.23/skyfield/documentation/examples.rst 2020-06-05
14:41:11.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/examples.rst 2020-07-17
16:17:03.000000000 +0200
@@ -42,8 +42,8 @@
next_midnight = midnight + dt.timedelta(days=1)
ts = load.timescale(builtin=True)
- t0 = ts.utc(midnight)
- t1 = ts.utc(next_midnight)
+ t0 = ts.from_datetime(midnight)
+ t1 = ts.from_datetime(next_midnight)
eph = load('de421.bsp')
bluffton = Topos('40.8939 N', '83.8917 W')
f = almanac.dark_twilight_day(eph, bluffton)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/skyfield-1.23/skyfield/documentation/kepler-orbits.rst
new/skyfield-1.24/skyfield/documentation/kepler-orbits.rst
--- old/skyfield-1.23/skyfield/documentation/kepler-orbits.rst 2020-07-09
20:15:57.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/kepler-orbits.rst 2020-07-17
12:08:04.000000000 +0200
@@ -48,6 +48,12 @@
864 comets loaded
+Since the comets file has no explicit expiration date,
+``load.open()`` will only download the file once.
+Subsequent calls re-open the copy of the file already on your filesystem.
+To force a fresh download and receive updated orbits and new comets,
+pass ``reload=True``.
+
To generate a comet’s position,
first select its row from dataframe.
There are several Pandas techniques for selecting rows,
@@ -157,6 +163,12 @@
python mpc_make_excerpt.py 00001 00002 00003 00004 > MPCORB.excerpt.DAT
+Note that the minor planets file has no explicit expiration date,
+so ``load.open()`` in the above script
+will only download the file once.
+Subsequent calls re-open the copy of the file already on your filesystem.
+To force a fresh download, pass ``reload=True``.
+
In either case, the resulting file — shorn of its text header,
and containing only minor planet orbits —
is ready for Skyfield to load.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/documentation/planets.rst
new/skyfield-1.24/skyfield/documentation/planets.rst
--- old/skyfield-1.23/skyfield/documentation/planets.rst 2020-06-15
21:21:55.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/planets.rst 2020-07-17
17:08:22.000000000 +0200
@@ -218,8 +218,8 @@
.. _third-party-ephemerides:
-Third-party libraries for other ephemeris formats
-=================================================
+Type 1 and Type 21 ephemeris formats
+====================================
If you generate an ephemeris with a tool like NASA’s
`HORIZONS <https://ssd.jpl.nasa.gov/horizons.cgi>`_ system,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/documentation/positions.rst
new/skyfield-1.24/skyfield/documentation/positions.rst
--- old/skyfield-1.23/skyfield/documentation/positions.rst 2020-06-15
21:19:48.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/positions.rst 2020-07-17
16:17:03.000000000 +0200
@@ -146,10 +146,12 @@
astrometric = boston.at(t).observe(mars)
apparent = boston.at(t).observe(mars).apparent()
-**Small Solar System objects**
- Work is underway to support comets and asteroids.
- In the meantime,
- any Type 1 or Type 21 ephemerides you generate
+**Comets and Minor Planets Asteroids**
+ Comet, asteroid, and other minor planet positions
+ can be generated through Skyfield’s :doc:`kepler-orbits` support
+ of data files downloaded from the Minor Planet Center.
+
+ And any Type 1 or Type 21 ephemerides you generate
using NASA’s `HORIZONS <https://ssd.jpl.nasa.gov/horizons.cgi>`_ system
are supported through third-party libraries;
for details, see :ref:`third-party-ephemerides`.
@@ -234,33 +236,28 @@
that is a high-precision replacement
for the old J2000.0 system
that was popular at the end of the 20th century.
+The orientation of the axes is roughly:
+
+* *x-axis* — points at the Vernal Equinox:
+ the position of the Sun in our sky
+ at the moment the Sun’s annual journey along the ecliptic
+ carries it from south to north across the celestial equator
+ and Spring begins in the Northern Hemisphere.
+ To express the same thing more technically,
+ this axis points towards
+ the “ascending node of the ecliptic on the celestial equator”
+ as of the beginning of the year 2000.
+ In ancient times this point in the sky was called “the first point of Ares.”
+
+* *y-axis* — is aimed at the point 90° east of the Vernal Equinox
+ on the celestial equator.
+ It can be hard to remember which way is east in the sky, so:
+ if you were standing at the center of the celestial sphere
+ with the north pole above your head
+ and the x-axis in front of you,
+ this axis would be 90° to your *left.*
-The ICRS is one of three related concepts
-that you will often see mentioned together
-in technical publications:
-
-* | *Barycentric Celestial Reference System* (BCRS) —
- a coordinate origin whose relativistic frame of reference
- is the one that was carefully defined in IAU 2000 Resolution B1.3
- which puts the coordinate origin
- at the gravitational center of the Solar System.
- The direction in which the coordinate axes might point
- is left unspecified.
-
-* *International Celestial Reference Frame* (ICRF) —
- a precision reference frame
- that radio astronomers have helped us define,
- that will become forever more exact
- as we measure better and better positions
- for a list of very distant radio sources.
- Wherever the origin of your coordinate system might lie,
- you can use the ICRF to define
- where your *x*-axis, *y*-axis, and *z*-axis should point.
-
-* *International Celestial Reference System* (ICRS) —
- A coordinate system whose origin is defined by the BCRS
- and whose axis directions are defined by the ICRF.
- In essence, the ICRS = ICRF + BCRS.
+* *z-axis* — points towards the celestial North Pole.
Instead of using an acronym,
Skyfield uses the class name :class:`Barycentric`
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/documentation/time.rst
new/skyfield-1.24/skyfield/documentation/time.rst
--- old/skyfield-1.23/skyfield/documentation/time.rst 2020-06-16
15:50:10.000000000 +0200
+++ new/skyfield-1.24/skyfield/documentation/time.rst 2020-07-17
16:17:03.000000000 +0200
@@ -63,20 +63,20 @@
# All the ways you can create a Time object
# using a timescale:
- ts.utc(year, month, day, hour, minute, second)
- ts.utc(dt) # Python datetime.datetime object
+ t = ts.utc(year, month, day, hour, minute, second)
+ t = ts.utc(dt) # Python datetime.datetime object
- ts.tai(year, month, day, hour, minute, second)
- ts.tai(jd=float)
+ t = ts.tai(year, month, day, hour, minute, second)
+ t = ts.tai_jd(float) # Julian date
- ts.tt(year, month, day, hour, minute, second)
- ts.tt(jd=float)
+ t = ts.tt(year, month, day, hour, minute, second)
+ t = ts.tt_jd(float) # Julian date
- ts.tdb(year, month, day, hour, minute, second)
- ts.tdb(jd=float)
+ t = ts.tdb(year, month, day, hour, minute, second)
+ t = ts.tdb_jd(float) # Julian date
- ts.ut1(year, month, day, hour, minute, second)
- ts.ut1(jd=float)
+ t = ts.ut1(year, month, day, hour, minute, second)
+ t = ts.ut1_jd(float) # Julian date
Once you have constructed a :class:`Time` object,
you can provide it to any Skyfield routine that needs it.
@@ -110,8 +110,8 @@
.. _building-dates:
-UTC and your timezone
-=====================
+Building and printing UTC
+=========================
The ``utc`` parameter in the examples above
specifies Coordinated Universal Time (UTC),
@@ -140,14 +140,14 @@
# Several ways to print a time as UTC.
print(tuple(t1.utc))
- print(t1.utc_iso())
+ print(t1.utc_iso(' '))
print(t1.utc_jpl())
print(t1.utc_strftime('Date %Y-%m-%d and time %H:%M:%S'))
.. testoutput::
(2014, 1, 18, 1, 35, 37.5)
- 2014-01-18T01:35:38Z
+ 2014-01-18 01:35:38Z
A.D. 2014-Jan-18 01:35:37.5000 UT
Date 2014-01-18 and time 01:35:38
@@ -187,11 +187,33 @@
A.D. 2015-Oct-11 10:00:00.0000 UT
-To move beyond UTC to working with actual timezones,
-you will need to install
-the third-party `pytz`_ package,
-either by listing it in the dependencies of your package,
-adding it to your project’s `requirements.txt`_ file,
+UTC and your timezone
+=====================
+
+To move beyond UTC and work with other world timezones,
+you will need to install a time zone database
+for your version of Python.
+
+* Every version of Python that Skyfield supports
+ will work with the `pytz`_ package described in this section.
+
+* Python 3.6 upgraded the Standard Library ``datetime`` type
+ so that the contortions of `pytz`_ are no longer necessary,
+ and instead recommends
+ `dateutil <https://dateutil.readthedocs.io/en/stable/>`_
+ for working with timezones.
+ Consult its documentation if you are interested in using it.
+
+* Python 3.9 will offer a native
+ `zoneinfo <https://docs.python.org/3.9/library/zoneinfo.html>`_
+ module that for the first time brings timezone support
+ into the Python Standard Library.
+
+But this documentation will focus on the approach
+which works universally across all Python versions.
+You can install the third-party `pytz`_ library
+by listing it in the dependencies of your package,
+or adding it to your project’s `requirements.txt`_ file,
or simply installing it manually::
pip install pytz
@@ -213,7 +235,7 @@
d = datetime(2014, 1, 16, 1, 32, 9)
e = eastern.localize(d)
- t = ts.utc(e)
+ t = ts.from_datetime(e)
And if Skyfield returns a Julian date at the end of a calculation,
you can ask the Julian date object to build a ``datetime`` object
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/earthlib.py
new/skyfield-1.24/skyfield/earthlib.py
--- old/skyfield-1.23/skyfield/earthlib.py 2020-06-12 20:16:38.000000000
+0200
+++ new/skyfield-1.24/skyfield/earthlib.py 2020-07-21 02:49:47.000000000
+0200
@@ -133,13 +133,13 @@
# Compute the Earth Rotation Angle. Time argument is UT1.
- theta = earth_rotation_angle(t.ut1)
+ theta = earth_rotation_angle(t.whole, t.ut1_fraction)
# The equinox method. See Circular 179, Section 2.6.2.
# Precession-in-RA terms in mean sidereal time taken from third
# reference, eq. (42), with coefficients in arcseconds.
- t = (t.tdb - T0) / 36525.0
+ t = (t.whole - T0 + t.tdb_fraction) / 36525.0
st = ( 0.014506 +
(((( - 0.0000000368 * t
- 0.000029956 ) * t
@@ -152,16 +152,15 @@
return (st / 54000.0 + theta * 24.0) % 24.0
-def earth_rotation_angle(jd_ut1):
+def earth_rotation_angle(jd_ut1, fraction_ut1=0.0):
"""Return the value of the Earth Rotation Angle (theta) for a UT1 date.
Uses the expression from the note to IAU Resolution B1.8 of 2000.
Returns a fraction between 0.0 and 1.0 whole rotations.
"""
- thet1 = 0.7790572732640 + 0.00273781191135448 * (jd_ut1 - T0)
- thet3 = jd_ut1 % 1.0
- return (thet1 + thet3) % 1.0
+ th = 0.7790572732640 + 0.00273781191135448 * (jd_ut1 - T0 + fraction_ut1)
+ return (th % 1.0 + jd_ut1 % 1.0 + fraction_ut1) % 1.0
def refraction(alt_degrees, temperature_C, pressure_mbar):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/positionlib.py
new/skyfield-1.24/skyfield/positionlib.py
--- old/skyfield-1.23/skyfield/positionlib.py 2020-07-01 19:52:31.000000000
+0200
+++ new/skyfield-1.24/skyfield/positionlib.py 2020-07-21 03:38:20.000000000
+0200
@@ -743,22 +743,35 @@
# Todo: wobble
- spin = rot_z(t.gast * tau / 24.0)
+ spin = rot_z(t.gast / 24.0 * tau)
position = mxv(spin, array(rITRF))
return mxv(t.MT, position)
-def ITRF_to_GCRS2(t, rITRF, vITRF):
+def ITRF_to_GCRS2(t, rITRF, vITRF, _high_accuracy=False):
+ # TODO: wobble
- # Todo: wobble
+ spin = rot_z(t.gast / 24.0 * tau)
+ position = mxv(spin, array(rITRF))
+ velocity = mxv(spin, array(vITRF))
- spin = rot_z(t.gast * tau / 24.0)
+ # TODO: This is expensive, and should be extensively trimmed to only
+ # include the most important terms underlying GAST. But it improves
+ # the precision by something like 1e5 times when compared to using
+ # the round number skyfield.constants.ANGVEL!
+ #
+ # See the test `test_velocity_in_ITRF_to_GCRS2()`.
+ #
+ if _high_accuracy:
+ _one_second = 1.0 / DAY_S
+ t_later = t.ts.tt_jd(t.whole, t.tt_fraction + _one_second)
+ angvel = (t_later.gast - t.gast) / 24.0 * tau
+ else:
+ angvel = ANGVEL
- position = mxv(spin, array(rITRF))
- position = mxv(t.MT, position)
+ velocity[0] += DAY_S * angvel * - position[1]
+ velocity[1] += DAY_S * angvel * position[0]
- velocity = mxv(spin, array(vITRF))
+ position = mxv(t.MT, position)
velocity = mxv(t.MT, velocity)
- velocity[0] += DAY_S * ANGVEL * - position[1]
- velocity[1] += DAY_S * ANGVEL * position[0]
return position, velocity
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/sgp4lib.py
new/skyfield-1.24/skyfield/sgp4lib.py
--- old/skyfield-1.23/skyfield/sgp4lib.py 2020-06-15 18:58:53.000000000
+0200
+++ new/skyfield-1.24/skyfield/sgp4lib.py 2020-07-16 22:30:23.000000000
+0200
@@ -165,7 +165,8 @@
rTEME /= AU_KM
vTEME /= AU_KM
vTEME *= DAY_S
- rITRF, vITRF = TEME_to_ITRF(t.ut1, rTEME, vTEME)
+ rITRF, vITRF = TEME_to_ITRF(t.whole, rTEME, vTEME, 0.0, 0.0,
+ t.ut1_fraction)
return rITRF, vITRF, error
def _at(self, t):
@@ -263,23 +264,23 @@
i = jd.argsort()
return ts.tt_jd(jd[i]), v[i]
-_second = 1.0 / (24.0 * 60.0 * 60.0)
-
-def theta_GMST1982(jd_ut1):
+def theta_GMST1982(jd_ut1, fraction_ut1=0.0):
"""Return the angle of Greenwich Mean Standard Time 1982 given the JD.
This angle defines the difference between the idiosyncratic True
Equator Mean Equinox (TEME) frame of reference used by SGP4 and the
- more standard Pseudo Earth Fixed (PEF) frame of reference.
+ more standard Pseudo Earth Fixed (PEF) frame of reference. The UT1
+ time should be provided as a Julian date. Theta is returned in
+ radians, and its velocity in radians per day of UT1 time.
From AIAA 2006-6753 Appendix C.
"""
- t = (jd_ut1 - T0) / 36525.0
+ t = (jd_ut1 - T0 + fraction_ut1) / 36525.0
g = 67310.54841 + (8640184.812866 + (0.093104 + (-6.2e-6) * t) * t) * t
dg = 8640184.812866 + (0.093104 * 2.0 + (-6.2e-6 * 3.0) * t) * t
- theta = (jd_ut1 % 1.0 + g * _second % 1.0) * tau
- theta_dot = (1.0 + dg * _second / 36525.0) * tau
+ theta = (jd_ut1 % 1.0 + fraction_ut1 + g / DAY_S % 1.0) % 1.0 * tau
+ theta_dot = (1.0 + dg / (DAY_S * 36525.0)) * tau
return theta, theta_dot
_zero_zero_minus_one = array((0.0, 0.0, -1.0))
@@ -290,7 +291,7 @@
# Nearly 4x speedup over numpy cross(). TODO: Maybe move to .functions?
return a[_cross120] * b[_cross201] - a[_cross201] * b[_cross120]
-def TEME_to_ITRF(jd_ut1, rTEME, vTEME, xp=0.0, yp=0.0):
+def TEME_to_ITRF(jd_ut1, rTEME, vTEME, xp=0.0, yp=0.0, fraction_ut1=0.0):
"""Convert TEME position and velocity into standard ITRS coordinates.
This converts a position and velocity vector in the idiosyncratic
@@ -304,7 +305,7 @@
# TODO: are xp and yp the values from the IERS? Or from general
# nutation theory?
- theta, theta_dot = theta_GMST1982(jd_ut1)
+ theta, theta_dot = theta_GMST1982(jd_ut1, fraction_ut1)
angular_velocity = multiply.outer(_zero_zero_minus_one, theta_dot)
R = rot_z(-theta)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/fixes.py
new/skyfield-1.24/skyfield/tests/fixes.py
--- old/skyfield-1.23/skyfield/tests/fixes.py 2020-06-12 20:16:38.000000000
+0200
+++ new/skyfield-1.24/skyfield/tests/fixes.py 2020-07-20 17:55:20.000000000
+0200
@@ -1,6 +1,7 @@
"""Helpers for making Skyfield tests stable."""
import datetime as dt
+from skyfield import earthlib
import skyfield.api
import skyfield.timelib
@@ -27,3 +28,24 @@
skyfield.api.load = skyfield.iokit.Loader('.')
skyfield.timelib.Timescale._utcnow = dt.datetime.utcnow
dt.datetime = _real_datetime_class
+
+class low_precision_ERA(object):
+ """Compute the Earth rotation angle with only a single float for UT1.
+
+ Skyfield now uses two floats ``t.whole`` and ``t.ut1_fraction`` to
+ represent the UT1 Julian date, supplying an additional 16 digits of
+ precision. For the Earth rotation angle, which moves very quickly
+ per unit time compared to most other astronomical quantities, this
+ knocks Skyfield out of agreement with other libraries like NOVAS and
+ SOFA that round UT1 to a single float. Various tests use this
+ context manager to make Skyfield match the lower-precision output.
+
+ """
+ def __enter__(self):
+ self.saved = earthlib.earth_rotation_angle
+ earthlib.earth_rotation_angle = self.era
+ def __exit__(self, *args):
+ earthlib.earth_rotation_angle = self.saved
+ def era(self, whole, fraction):
+ rounded_single_float = whole + fraction
+ return self.saved(rounded_single_float)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/test_against_novas.py
new/skyfield-1.24/skyfield/tests/test_against_novas.py
--- old/skyfield-1.23/skyfield/tests/test_against_novas.py 2020-06-12
20:22:41.000000000 +0200
+++ new/skyfield-1.24/skyfield/tests/test_against_novas.py 2020-07-20
17:56:03.000000000 +0200
@@ -7,6 +7,7 @@
from skyfield.constants import AU_KM, AU_M
from skyfield.data import hipparcos
from skyfield.functions import length_of
+from .fixes import low_precision_ERA
OLD_AU_KM = 149597870.691 # TODO: load from de405
OLD_AU = AU_KM / OLD_AU_KM
@@ -246,7 +247,8 @@
def test_sidereal_time_with_nonzero_delta_t_on_date0():
jd = load.timescale(delta_t=99.9).tt_jd(2440423.345833333 + 99.9 *
one_second)
- compare(earthlib.sidereal_time(jd), 16.195436229760602, 1e-13)
+ with low_precision_ERA():
+ compare(earthlib.sidereal_time(jd), 16.195436229760602, 1e-13)
def test_sidereal_time_on_date1():
jd = load.timescale(delta_t=0.0).tt_jd(2448031.5)
@@ -254,7 +256,8 @@
def test_sidereal_time_with_nonzero_delta_t_on_date1():
jd = load.timescale(delta_t=99.9).tt_jd(2448031.5 + 99.9 * one_second)
- compare(earthlib.sidereal_time(jd), 15.825907462991848, 1e-13)
+ with low_precision_ERA():
+ compare(earthlib.sidereal_time(jd), 15.825907462991848, 1e-13)
def test_sidereal_time_on_date2():
jd = load.timescale(delta_t=0.0).tt_jd(2451545.0)
@@ -262,7 +265,8 @@
def test_sidereal_time_with_nonzero_delta_t_on_date2():
jd = load.timescale(delta_t=99.9).tt_jd(2451545.0 + 99.9 * one_second)
- compare(earthlib.sidereal_time(jd), 18.69737482966941, 1e-13)
+ with low_precision_ERA():
+ compare(earthlib.sidereal_time(jd), 18.69737482966941, 1e-13)
def test_sidereal_time_on_date3():
jd = load.timescale(delta_t=0.0).tt_jd(2456164.5)
@@ -270,7 +274,8 @@
def test_sidereal_time_with_nonzero_delta_t_on_date3():
jd = load.timescale(delta_t=99.9).tt_jd(2456164.5 + 99.9 * one_second)
- compare(earthlib.sidereal_time(jd), 22.2439084998698, 1e-13)
+ with low_precision_ERA():
+ compare(earthlib.sidereal_time(jd), 22.2439084998698, 1e-13)
def test_star_vector():
star = starlib.Star(ra_hours=2.530301028, dec_degrees=89.264109444,
@@ -455,22 +460,26 @@
def test_ITRF_to_GCRS_conversion_on_date0():
jd = load.timescale(delta_t=39.707).tt_jd(2440423.345833333)
- position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
+ with low_precision_ERA():
+ position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
compare(position, (0.5701172053658128, -1.5232987806096392,
1.3017400651201707), 1e-13)
def test_ITRF_to_GCRS_conversion_on_date1():
jd = load.timescale(delta_t=57.1136).tt_jd(2448031.5)
- position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
+ with low_precision_ERA():
+ position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
compare(position, (0.41362649279562963, -1.5741081933652488,
1.3004216700893525), 1e-13)
def test_ITRF_to_GCRS_conversion_on_date2():
jd = load.timescale(delta_t=63.8285).tt_jd(2451545.0)
- position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
+ with low_precision_ERA():
+ position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
compare(position, (1.3757008573963405, -0.8702954291925735,
1.3000126987400913), 1e-13)
def test_ITRF_to_GCRS_conversion_on_date3():
jd = load.timescale(delta_t=66.7846).tt_jd(2456164.5)
- position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
+ with low_precision_ERA():
+ position = positionlib.ITRF_to_GCRS(jd, [1.1, 1.2, 1.3])
compare(position, (1.5243574049688486, 0.5755748855663746,
1.2980940077752074), 1e-13)
def test_tdb_minus_tt_on_date0():
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/skyfield-1.23/skyfield/tests/test_earth_satellites.py
new/skyfield-1.24/skyfield/tests/test_earth_satellites.py
--- old/skyfield-1.23/skyfield/tests/test_earth_satellites.py 2020-06-12
20:16:38.000000000 +0200
+++ new/skyfield-1.24/skyfield/tests/test_earth_satellites.py 2020-07-17
16:17:03.000000000 +0200
@@ -5,6 +5,7 @@
from skyfield.api import EarthSatellite, load
from skyfield.constants import AU_KM, AU_M
from skyfield.sgp4lib import TEME_to_ITRF
+from skyfield.timelib import julian_date
iss_tle0 = """\
1 25544U 98067A 18184.80969102 .00001614 00000-0 31745-4 0 9993
@@ -63,7 +64,7 @@
arcminute = DEG2RAD / 60.0
arcsecond = arcminute / 60.0
-second = 1.0 / (24.0 * 60.0 * 60.0)
+seconds_per_day = 86400.0
# Note that the following test is based specifically on Revision 2 of
# "Revisiting Spacetrack Report #3" AIAA 2006-6753 (earlier versions of
@@ -76,25 +77,28 @@
vTEME = array([-4.746131487, 0.785818041, 5.531931288])
vTEME = vTEME * 24.0 * 60.0 * 60.0 # km/s to km/day
- ts = api.load.timescale()
- jd_ut1 = ts.tt(2004, 4, 6, 7, 51, 28.386 - 0.439961).tt
+ jd_utc = julian_date(2004, 4, 6, 7, 51, 28.386)
+ d_ut1 = -0.439961
+ jd_ut1 = jd_utc + d_ut1 / 86400.0
xp = -0.140682 * arcsecond
yp = 0.333309 * arcsecond
rITRF, vITRF = TEME_to_ITRF(jd_ut1, rTEME, vTEME, xp, yp)
- meter = 1e-3
+ epsilon = 5e-8 # Why not 1e-8, which would match all of their digits?
+
+ assert abs(-1033.47938300 - rITRF[0]) < epsilon
+ assert abs(+7901.29527540 - rITRF[1]) < epsilon
+ assert abs(+6380.35659580 - rITRF[2]) < epsilon
- assert abs(-1033.47938300 - rITRF[0]) < 0.1 * meter
- assert abs(+7901.29527540 - rITRF[1]) < 0.1 * meter
- assert abs(+6380.35659580 - rITRF[2]) < 0.1 * meter
+ vITRF_per_second = vITRF / seconds_per_day
- vITRF_per_second = vITRF * second
+ epsilon = 7e-8 # Why not 1e-9, which would match all of their digits?
- assert abs(-3.225636520 - vITRF_per_second[0]) < 1e-4 * meter
- assert abs(-2.872451450 - vITRF_per_second[1]) < 1e-4 * meter
- assert abs(+5.531924446 - vITRF_per_second[2]) < 1e-4 * meter
+ assert abs(-3.225636520 - vITRF_per_second[0]) < epsilon
+ assert abs(-2.872451450 - vITRF_per_second[1]) < epsilon
+ assert abs(+5.531924446 - vITRF_per_second[2]) < epsilon
def test_appendix_c_satellite():
ts = api.load.timescale(builtin=True)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/test_io.py
new/skyfield-1.24/skyfield/tests/test_io.py
--- old/skyfield-1.23/skyfield/tests/test_io.py 2020-06-12 20:16:38.000000000
+0200
+++ new/skyfield-1.24/skyfield/tests/test_io.py 2020-07-10 11:52:13.000000000
+0200
@@ -9,18 +9,6 @@
from skyfield import api
-#http://maia.usno.navy.mil/ser7/tai-utc.dat
-
-'''
-need files that contain internal state
-too great a chance user will move files etc and ruin date
-
-http://maia.usno.navy.mil/ser7/deltat.data - 1 year?
-http://maia.usno.navy.mil/ser7/deltat.preds - 1 year?
-
-https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat - "expires" message
-'''
-
old_content = (b' 2015 10 1 67.9546\n'
b' 2015 11 1 68.0055\n'
b' 2015 12 1 68.0514\n'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/test_positions.py
new/skyfield-1.24/skyfield/tests/test_positions.py
--- old/skyfield-1.23/skyfield/tests/test_positions.py 2020-06-12
20:16:38.000000000 +0200
+++ new/skyfield-1.24/skyfield/tests/test_positions.py 2020-07-21
03:38:20.000000000 +0200
@@ -1,9 +1,11 @@
import numpy as np
-from skyfield import api, constants
+from skyfield import api
+from skyfield.constants import DAY_S, tau
from skyfield.earthlib import earth_rotation_angle
-from skyfield.functions import length_of
-from skyfield.positionlib import ICRF, _GIGAPARSEC_AU
+from skyfield.functions import length_of, mxv, rot_z
+from skyfield.positionlib import ICRF, ITRF_to_GCRS2, _GIGAPARSEC_AU
from skyfield.starlib import Star
+from .fixes import low_precision_ERA
def test_subtraction():
p0 = ICRF((10,20,30), (40,50,60))
@@ -89,15 +91,42 @@
p = api.position_from_radec(6, 0)
assert length_of(p.position.au - [0, 1, 0]) < 1e-16
-def test_itrf_vector():
+def test_velocity_in_ITRF_to_GCRS2():
+ # TODO: Get test working with these vectors too, showing it works
+ # with a non-zero velocity vector, but in that case the test will
+ # have to be fancier in how it corrects.
+ # r = np.array([(1, 0, 0), (1, 1 / DAY_S, 0)]).T
+ # v = np.array([(0, 1, 0), (0, 1, 0)]).T
+
ts = api.load.timescale(builtin=True)
- t = ts.utc(2019, 11, 2, 3, 53)
- top = api.Topos(latitude_degrees=45, longitude_degrees=0,
- elevation_m=constants.AU_M - constants.ERAD)
- x, y, z = top.at(t).itrf_xyz().au
- assert abs(x - 0.7071) < 1e-4
- assert abs(y - 0.0) < 1e-14
- assert abs(z - 0.7071) < 1e-4
+ t = ts.utc(2020, 7, 17, 8, 51, [0, 1])
+ r = np.array([(1, 0, 0), (1, 0, 0)]).T
+ v = np.array([(0, 0, 0), (0, 0, 0)]).T
+
+ r, v = ITRF_to_GCRS2(t, r, v, True)
+
+ # Rotate back to equinox-of-date before applying correction.
+ r = mxv(t.M, r)
+ v = mxv(t.M, v)
+
+ r0, r1 = r.T
+ v0 = v[:,0]
+
+ # Apply a correction: the instantaneous velocity does not in fact
+ # carry the position in a straight line, but in an arc around the
+ # origin; so use trigonometry to move the destination point to where
+ # linear motion would have carried it.
+ angvel = (t.gast[1] - t.gast[0]) / 24.0 * tau
+ r1 = mxv(rot_z(np.arctan(angvel) - angvel), r1)
+ r1 *= np.sqrt(1 + angvel*angvel)
+
+ actual_motion = r1 - r0
+ predicted_motion = v0 / DAY_S
+
+ relative_error = (length_of(actual_motion - predicted_motion)
+ / length_of(actual_motion))
+
+ assert relative_error < 2e-12
# Test that the CIRS coordinate of the TIO is consistent with the Earth
Rotation Angle
# This is mostly an internal consistency check
@@ -198,7 +227,8 @@
for ((ra_icrs, dec_icrs, tdb), (ra_sofa, dec_sofa)) in zip(test_data,
sofa_results):
ss = Star(ra_hours=(ra_icrs / 15.0), dec_degrees=dec_icrs)
st = ts.tdb(jd=tdb)
- ra_cirs, dec_cirs, _ =
earth.at(st).observe(ss).apparent().cirs_radec(st)
+ with low_precision_ERA():
+ ra_cirs, dec_cirs, _ =
earth.at(st).observe(ss).apparent().cirs_radec(st)
assert np.allclose(ra_cirs._degrees, ra_sofa, rtol=0.0, atol=tol)
assert np.allclose(dec_cirs._degrees, dec_sofa, rtol=0.0, atol=tol)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/test_timelib.py
new/skyfield-1.24/skyfield/tests/test_timelib.py
--- old/skyfield-1.23/skyfield/tests/test_timelib.py 2020-07-02
18:46:33.000000000 +0200
+++ new/skyfield-1.24/skyfield/tests/test_timelib.py 2020-07-17
15:39:21.000000000 +0200
@@ -68,29 +68,36 @@
def test_that_building_time_from_naive_datetime_raises_exception(ts):
with assert_raises(ValueError) as info:
- ts.utc(datetime(1973, 12, 29, 23, 59, 48))
+ ts.from_datetime(datetime(1973, 12, 29, 23, 59, 48))
assert 'import timezone' in str(info.exception)
def test_building_time_from_single_utc_datetime(ts):
+ t = ts.from_datetime(datetime(1973, 12, 29, 23, 59, 48, tzinfo=utc))
+ assert t.tai == 2442046.5
t = ts.utc(datetime(1973, 12, 29, 23, 59, 48, tzinfo=utc))
assert t.tai == 2442046.5
def test_building_time_from_single_utc_datetime_with_timezone(ts):
tz = timezone('US/Eastern')
- t = ts.utc(tz.localize(datetime(2020, 5, 10, 12, 44, 13, 797865)))
+ t = ts.from_datetime(tz.localize(datetime(2020, 5, 10, 12, 44, 13,
797865)))
dt, leap_second = t.utc_datetime_and_leap_second()
assert dt == datetime(2020, 5, 10, 16, 44, 13, 797865, tzinfo=utc)
assert leap_second == 0
def test_building_time_from_list_of_utc_datetimes(ts):
- t = ts.utc([
+ datetimes = [
datetime(1973, 12, 29, 23, 59, 48, tzinfo=utc),
datetime(1973, 12, 30, 23, 59, 48, tzinfo=utc),
datetime(1973, 12, 31, 23, 59, 48, tzinfo=utc),
datetime(1974, 1, 1, 23, 59, 47, tzinfo=utc),
datetime(1974, 1, 2, 23, 59, 47, tzinfo=utc),
datetime(1974, 1, 3, 23, 59, 47, tzinfo=utc),
- ])
+ ]
+ t = ts.from_datetimes(datetimes)
+ assert list(t.tai) == [
+ 2442046.5, 2442047.5, 2442048.5, 2442049.5, 2442050.5, 2442051.5,
+ ]
+ t = ts.utc(datetimes)
assert list(t.tai) == [
2442046.5, 2442047.5, 2442048.5, 2442049.5, 2442050.5, 2442051.5,
]
@@ -100,13 +107,13 @@
jd = api.T0 - ten_thousand_years
t = ts.ut1(jd=jd)
- del t.ut1 # force re-computation of UT1
+ del t.ut1_fraction # force re-computation of UT1
print(jd - t.ut1)
assert abs(jd - t.ut1) < 1e-10
jd = api.T0 + ten_thousand_years
t = ts.ut1(jd=jd)
- del t.ut1 # force re-computation of UT1
+ del t.ut1_fraction # force re-computation of UT1
print(jd - t.ut1)
assert abs(jd - t.ut1) < 1e-10
@@ -162,7 +169,7 @@
def test_utc_datetime_microseconds_round_trip(ts):
dt = datetime(2020, 5, 10, 11, 50, 9, 727799, tzinfo=utc)
- t = ts.utc(dt)
+ t = ts.from_datetime(dt)
dt2, leap_second = t.utc_datetime_and_leap_second()
assert dt2 == dt
assert leap_second == 0
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/tests/test_topos.py
new/skyfield-1.24/skyfield/tests/test_topos.py
--- old/skyfield-1.23/skyfield/tests/test_topos.py 2020-06-12
20:16:38.000000000 +0200
+++ new/skyfield-1.24/skyfield/tests/test_topos.py 2020-07-17
16:17:03.000000000 +0200
@@ -1,13 +1,40 @@
from numpy import abs
-from skyfield.api import load
-from skyfield.toposlib import Topos
+from skyfield import constants
+from skyfield.api import Topos, load
+from skyfield.functions import length_of
angle = (-15, 15, 35, 45)
def ts():
yield load.timescale()
+def test_velocity():
+ # It looks like this is a sweet spot for accuracy: presumably a
+ # short enough fraction of a second that the vector does not time to
+ # change direction much, but long enough that the direction does not
+ # get lost down in the noise.
+ factor = 300.0
+
+ ts = load.timescale(builtin=True)
+ t = ts.utc(2019, 11, 2, 3, 53, [0, 1.0 / factor])
+ jacob = Topos(latitude_degrees=36.7138, longitude_degrees=-112.2169)
+ p = jacob.at(t)
+ velocity1 = p.position.km[:,1] - p.position.km[:,0]
+ velocity2 = p.velocity.km_per_s[:,0]
+ print(length_of(velocity2 - factor * velocity1))
+ assert length_of(velocity2 - factor * velocity1) < 0.0007
+
+def test_itrf_vector():
+ ts = load.timescale(builtin=True)
+ t = ts.utc(2019, 11, 2, 3, 53)
+ top = Topos(latitude_degrees=45, longitude_degrees=0,
+ elevation_m=constants.AU_M - constants.ERAD)
+ x, y, z = top.at(t).itrf_xyz().au
+ assert abs(x - 0.7071) < 1e-4
+ assert abs(y - 0.0) < 1e-14
+ assert abs(z - 0.7071) < 1e-4
+
def test_beneath(ts, angle):
t = ts.utc(2018, 1, 19, 14, 37, 55)
# An elevation of 0 is more difficult for the routine's accuracy
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/skyfield-1.23/skyfield/timelib.py
new/skyfield-1.24/skyfield/timelib.py
--- old/skyfield-1.23/skyfield/timelib.py 2020-07-02 18:44:12.000000000
+0200
+++ new/skyfield-1.24/skyfield/timelib.py 2020-07-21 03:27:53.000000000
+0200
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
+import datetime as dt
import re
from collections import namedtuple
-from datetime import date, datetime, timedelta, tzinfo
+from datetime import date, datetime
from numpy import (array, concatenate, cos, float_, interp, isnan, nan,
ndarray, pi, rollaxis, searchsorted, sin, where, zeros_like)
from time import strftime
@@ -32,27 +33,30 @@
@property
def second(self): return self[5]
-try:
- from pytz import utc
-except ImportError:
-
- # Lacking a full suite of timezones from pytz, we at least need a
- # time zone object for UTC.
-
- class UTC(tzinfo):
- 'UTC'
- zero = timedelta(0)
- def utcoffset(self, dt):
- return self.zero
- def tzname(self, dt):
- return 'UTC'
- def dst(self, dt):
- return self.zero
+if hasattr(dt, 'timezone'):
+ utc = dt.timezone.utc
+else:
+ try:
+ from pytz import utc
+ except ImportError:
+ # Lacking a full suite of timezones from pytz, we at least need a
+ # time zone object for UTC.
+
+ class UTC(dt.tzinfo):
+ 'UTC'
+ zero = dt.timedelta(0)
+ def utcoffset(self, dt):
+ return self.zero
+ def tzname(self, dt):
+ return 'UTC'
+ def dst(self, dt):
+ return self.zero
- utc = UTC()
+ utc = UTC()
# Much of the following code is adapted from the USNO's "novas.c".
+_time_zero = dt.time()
_half_minute = 30.0 / DAY_S
_half_second = 0.5 / DAY_S
_half_microsecond = 0.5e-6 / DAY_S
@@ -101,47 +105,62 @@
correct UTC date and time.
"""
- return self.utc(self._utcnow().replace(tzinfo=utc))
+ return self.from_datetime(self._utcnow().replace(tzinfo=utc))
+
+ def from_datetime(self, datetime):
+ """Return a `Time` for a Python ``datetime``.
+
+ The ``datetime`` must be “timezone-aware”: it must have a time
+ zone object as its ``tzinfo`` attribute instead of ``None``.
+
+ """
+ jd, fr = _utc_datetime_to_tai(
+ self.leap_dates, self.leap_offsets, datetime)
+ t = Time(self, jd, fr + tt_minus_tai)
+ t.tai_fraction = fr
+ return t
+
+ def from_datetimes(self, datetime_list):
+ """Return a `Time` for a Python ``datetime`` list.
+
+ The ``datetime`` objects must each be “timezone-aware”: they
+ must each have a time zone object as their ``tzinfo`` attribute
+ instead of ``None``.
+
+ """
+ leap_dates = self.leap_dates
+ leap_offsets = self.leap_offsets
+ pairs = [_utc_datetime_to_tai(leap_dates, leap_offsets, d)
+ for d in datetime_list]
+ jd, fr = zip(*pairs)
+ t = Time(self, _to_array(jd), fr + tt_minus_tai)
+ t.tai_fraction = fr
+ return t
def utc(self, year, month=1, day=1, hour=0, minute=0, second=0.0):
"""Build a `Time` from a UTC calendar date.
- You can either specify the date as separate components, or
- provide a time zone aware Python datetime. The following two
- calls are equivalent (the ``utc`` time zone object can be
- imported from the ``skyfield.api`` module, or from ``pytz`` if
- you have it)::
-
- ts.utc(2014, 1, 18, 1, 35, 37.5)
- ts.utc(datetime(2014, 1, 18, 1, 35, 37, 500000, tzinfo=utc))
-
- Note that only by passing the components separately can you
- specify a leap second, because a Python datetime will not allow
- the value 60 in its seconds field.
+ Specify the date as a numeric year, month, day, hour, minute,
+ and second. Any argument may be an array in which case the
+ return value is a ``Time`` representing a whole array of times.
"""
+ # TODO: someday deprecate passing datetime objects here, as
+ # there are now separate constructors for them.
if isinstance(year, datetime):
- dt = year
- tai1, tai2 = _utc_datetime_to_tai(self.leap_dates,
- self.leap_offsets, dt)
- elif isinstance(year, date):
- d = year
- tai1, tai2 = _utc_date_to_tai(self.leap_dates, self.leap_offsets,
d)
- elif hasattr(year, '__len__') and isinstance(year[0], datetime):
- # TODO: clean this up and better document the possibilities.
- list_of_datetimes = year
- tai1, tai2 = array([
- _utc_datetime_to_tai(self.leap_dates, self.leap_offsets, dt)
- for dt in list_of_datetimes
- ]).T
- else:
- tai1, tai2 = _utc_to_tai(
- self.leap_dates, self.leap_offsets, _to_array(year),
- _to_array(month), _to_array(day), _to_array(hour),
- _to_array(minute), _to_array(second),
- )
+ return self.from_datetime(year)
+ if isinstance(year, date):
+ return self.from_datetime(dt.combine(year, _time_zero))
+ if hasattr(year, '__len__') and isinstance(year[0], datetime):
+ return self.from_datetimes(year)
+
+ tai1, tai2 = _utc_to_tai(
+ self.leap_dates, self.leap_offsets, _to_array(year),
+ _to_array(month), _to_array(day), _to_array(hour),
+ _to_array(minute), _to_array(second),
+ )
t = Time(self, tai1, tai2 + tt_minus_tai)
- t.tai = tai1 + tai2
+ t.tai_fraction = tai2
return t
def tai(self, year=None, month=1, day=1, hour=0, minute=0, second=0.0,
@@ -254,7 +273,7 @@
)
return self.ut1_jd(ut1)
- def ut1_jd(self, jd, fraction=0.0):
+ def ut1_jd(self, jd):
"""Build a `Time` from a UT1 Julian date."""
ut1 = _to_array(jd)
@@ -271,9 +290,9 @@
# 10 centuries of either side of the present; for details, see:
# https://github.com/skyfielders/astronomy-notebooks
# and look for the notebook "error-in-timescale-ut1.ipynb".
- tt = ut1 + delta_t_approx / DAY_S
- t = Time(self, tt)
- t.ut1 = ut1
+ delta_t_approx /= DAY_S
+ t = Time(self, ut1, delta_t_approx)
+ t.ut1_fraction = 0.0
return t
def from_astropy(self, t):
@@ -321,7 +340,7 @@
# TODO: raise non-IndexError exception if this Time is not an array;
# otherwise, a `for` loop over it will not raise an error.
t = Time(self.ts, self.whole[index], self.tt_fraction[index])
- for name in 'tai', 'tdb_fraction', 'ut1', 'delta_t':
+ for name in 'tai_fraction', 'tdb_fraction', 'ut1_fraction':
value = getattr(self, name, None)
if value is not None:
if getattr(value, 'shape', None):
@@ -649,22 +668,25 @@
return (self.whole - 1721045.0 + self.tt_fraction) / 365.25
@reify
- def tai(self):
- return self.tt - tt_minus_tai
-
- @reify
def utc(self):
utc = self._utc_tuple()
return array(utc).view(CalendarArray) if self.shape else
CalendarTuple(*utc)
@reify
+ def tai_fraction(self):
+ return self.tt_fraction - tt_minus_tai
+
+ @reify
def tdb_fraction(self):
fr = self.tt_fraction
return fr + tdb_minus_tt(self.whole, fr) / DAY_S
@reify
- def ut1(self):
- return self.tt - self.delta_t / DAY_S
+ def ut1_fraction(self):
+ # Calling "self.delta_t" would cache a useless intermediate value, so:
+ table = self.ts.delta_t_table
+ delta_t = interpolate_delta_t(table, self.tt)
+ return self.tt_fraction - delta_t / DAY_S
@reify
def delta_t(self):
@@ -689,11 +711,16 @@
# TODO: move this into an eqeq function?
c_terms = equation_of_the_equinoxes_complimentary_terms(tt)
eq_eq = d_psi * cos(self._mean_obliquity_radians) + c_terms
+ # TODO: constrain to 24 hours?
return self.gmst + eq_eq / tau * 24.0
# Low-precision floats generated from internal float pairs.
@property
+ def tai(self):
+ return self.whole + self.tai_fraction
+
+ @property
def tt(self):
return self.whole + self.tt_fraction
@@ -701,6 +728,10 @@
def tdb(self):
return self.whole + self.tdb_fraction
+ @property
+ def ut1(self):
+ return self.whole + self.ut1_fraction
+
# Crucial functions of time.
def nutation_matrix(self):
@@ -887,7 +918,8 @@
def _utc_datetime_to_tai(leap_dates, leap_offsets, dt):
if dt.tzinfo is None:
raise ValueError(_naive_complaint)
- dt = dt.astimezone(utc)
+ if dt.tzinfo is not utc:
+ dt = dt.astimezone(utc)
return _utc_to_tai(leap_dates, leap_offsets,
dt.year, dt.month, dt.day,
dt.hour, dt.minute, dt.second + dt.microsecond * 1e-6)
@@ -942,7 +974,7 @@
d = datetime(..., tzinfo=utc) # to build a new datetime
d = d.replace(tzinfo=utc) # to fix an existing datetime
-Or install the third-party `pytz` library and use any of its timezones:
+Or use a timezone object like those provided by the third-party `pytz` library:
from pytz import timezone
eastern = timezone('US/Eastern')
++++++ skyfield-pr404-comparefloat.patch ++++++
--- /var/tmp/diff_new_pack.RalY61/_old 2020-07-24 10:04:26.925879115 +0200
+++ /var/tmp/diff_new_pack.RalY61/_new 2020-07-24 10:04:26.929879118 +0200
@@ -7,132 +7,55 @@
skyfield/tests/test_planetarylib.py | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
-diff --git a/skyfield/tests/test_planetarylib.py
b/skyfield/tests/test_planetarylib.py
-index 83877bd1..928f5386 100644
---- a/skyfield/tests/test_planetarylib.py
-+++ b/skyfield/tests/test_planetarylib.py
-@@ -1,4 +1,5 @@
- import numpy as np
-+from numpy.testing import assert_allclose
- from skyfield.api import PlanetaryConstants, T0, load
- from skyfield.constants import AU_KM, AU_M
- from skyfield.positionlib import ICRF
-@@ -43,11 +44,11 @@ def test_frame_rotation_matrices():
+Index: skyfield-1.24/skyfield/tests/test_planetarylib.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_planetarylib.py
++++ skyfield-1.24/skyfield/tests/test_planetarylib.py
+@@ -43,11 +43,11 @@ def test_frame_rotation_matrices():
]
R = frame.rotation_at(ts.tdb_jd(tdb))
- assert (R == desired_rotation).all() # Boom.
-+ assert_allclose(R, desired_rotation)
++ np.testing.assert_array_max_ulp(R, desired_rotation)
R2, Rv = frame.rotation_and_rate_at(ts.tdb_jd(tdb))
- assert (R == R2).all()
- assert (Rv == desired_rate).all() # Boom.
-+ assert_allclose(R, R2)
-+ assert_allclose(Rv, desired_rate)
++ np.testing.assert_array_max_ulp(R, R2)
++ np.testing.assert_array_max_ulp(Rv, desired_rate)
# Second, a moment when the angle W is more than 2500 radians.
-@@ -93,11 +94,11 @@ def test_frame_rotation_matrices():
- frame = pc.build_frame_named('MOON_ME_DE421')
+@@ -66,12 +66,11 @@ def test_frame_rotation_matrices():
+ -2.1589045361778893e-10],
+ ]
R = frame.rotation_at(ts.tdb_jd(tdb))
- delta = abs(R - desired_rotation)
-- assert (R == desired_rotation).all()
-+ assert_allclose(R, desired_rotation)
+- delta = abs(R - desired_rotation)
+- assert (delta < 2e-13).all() # a few digits are lost in large W radians?
++ np.testing.assert_allclose(R, desired_rotation, atol=2e-13)
R2, Rv = frame.rotation_and_rate_at(ts.tdb_jd(tdb))
- assert (R == R2).all()
-- assert (Rv == desired_rate).all()
-+ assert_allclose(R, R2)
-+ assert_allclose(Rv, desired_rate)
-
- def test_rotating_vector_into_frame():
- et_seconds = 259056665.1855896
-
-From 5d8366e84003dbb48afe06bf1395182cc8119fb2 Mon Sep 17 00:00:00 2001
-From: Ben Greiner <c...@bnavigator.de>
-Date: Fri, 10 Jul 2020 14:36:55 +0200
-Subject: [PATCH 2/2] custom float compare function instead of standard numpy
-
----
- skyfield/tests/test_planetarylib.py | 48 ++++++++++++++++++++++++-----
- 1 file changed, 41 insertions(+), 7 deletions(-)
-
-diff --git a/skyfield/tests/test_planetarylib.py
b/skyfield/tests/test_planetarylib.py
-index 928f5386..6d29fed2 100644
---- a/skyfield/tests/test_planetarylib.py
-+++ b/skyfield/tests/test_planetarylib.py
-@@ -1,9 +1,43 @@
- import numpy as np
--from numpy.testing import assert_allclose
-+import os
- from skyfield.api import PlanetaryConstants, T0, load
- from skyfield.constants import AU_KM, AU_M
- from skyfield.positionlib import ICRF
-
-+
-+def assert_floatsareclose(a, b, atol=None):
-+ """compare a list of floats as tight as possible
-+
-+ https://github.com/skyfielders/python-skyfield/pull/404
-+
-+ Parameters
-+ ----------
-+ a, b : array_like float
-+ Arrays to compare
-+ atol : float, optional
-+ maximum absolute difference
-+
-+ Raises
-+ ------
-+ AssertionError
-+ if the difference of any element in `a` and `b` is too large
-+ or the shapes don't match
-+ """
-+ if not atol:
-+ atol = float(os.getenv("SKYFIELD_TEST_DEFAULT_ATOL", "1e-25"))
-+ assert np.shape(a) == np.shape(b)
-+ difference = np.asarray(a) - np.asarray(b)
-+ if not np.all(np.abs(difference) < atol):
-+ imax = np.argmax(difference)
-+ maxe = np.max(difference)
-+ raise AssertionError("The difference between\n"
-+ "{} and \n"
-+ "{}\n"
-+ "is larger than the allowed {:.3g}.\n"
-+ "Maximum difference at element {}: {:.7g}"
-+ "".format(a, b, atol, imax, maxe))
-+
-+
- def test_frame_rotation_matrices():
- # To produce the following matrices:
- #
-@@ -44,11 +78,11 @@ def test_frame_rotation_matrices():
+- assert abs(Rv - desired_rate).max() < 4e-19 # About 13 digits precision.
++ np.testing.assert_array_max_ulp(R, R2)
++ np.testing.assert_allclose(Rv, desired_rate, atol=4e-19)
+
+ # Finally, a frame which is defined by a constant rotation of
+ # another frame.
+@@ -92,12 +91,12 @@ def test_frame_rotation_matrices():
]
-
- R = frame.rotation_at(ts.tdb_jd(tdb))
-- assert_allclose(R, desired_rotation)
-+ assert_floatsareclose(R, desired_rotation)
-
- R2, Rv = frame.rotation_and_rate_at(ts.tdb_jd(tdb))
-- assert_allclose(R, R2)
-- assert_allclose(Rv, desired_rate)
-+ assert_floatsareclose(R, R2)
-+ assert_floatsareclose(Rv, desired_rate)
-
- # Second, a moment when the angle W is more than 2500 radians.
-
-@@ -94,11 +128,11 @@ def test_frame_rotation_matrices():
frame = pc.build_frame_named('MOON_ME_DE421')
R = frame.rotation_at(ts.tdb_jd(tdb))
- delta = abs(R - desired_rotation)
-- assert_allclose(R, desired_rotation)
-+ assert_floatsareclose(R, desired_rotation)
+- delta = abs(R - desired_rotation)
+- assert (R == desired_rotation).all()
++ np.testing.assert_array_max_ulp(R, desired_rotation)
R2, Rv = frame.rotation_and_rate_at(ts.tdb_jd(tdb))
-- assert_allclose(R, R2)
-- assert_allclose(Rv, desired_rate)
-+ assert_floatsareclose(R, R2)
-+ assert_floatsareclose(Rv, desired_rate)
+- assert (R == R2).all()
+- assert (Rv == desired_rate).all()
++ np.testing.assert_array_max_ulp(R, R2)
++ np.testing.assert_array_max_ulp(Rv, desired_rate)
++
def test_rotating_vector_into_frame():
et_seconds = 259056665.1855896
++++++ skyfield-pr405-replace-assay-by-pytest.patch ++++++
--- /var/tmp/diff_new_pack.RalY61/_old 2020-07-24 10:04:26.933879121 +0200
+++ /var/tmp/diff_new_pack.RalY61/_new 2020-07-24 10:04:26.933879121 +0200
@@ -17,11 +17,10 @@
10 files changed, 54 insertions(+), 29 deletions(-)
create mode 100644 skyfield/tests/conftest.py
-diff --git a/skyfield/tests/conftest.py b/skyfield/tests/conftest.py
-new file mode 100644
-index 00000000..bb5c5c4c
+Index: skyfield-1.24/skyfield/tests/conftest.py
+===================================================================
--- /dev/null
-+++ b/skyfield/tests/conftest.py
++++ skyfield-1.24/skyfield/tests/conftest.py
@@ -0,0 +1,11 @@
+"""conftest.py to provide session wide fixtures"""
+
@@ -34,10 +33,10 @@
+def ts():
+ """Provide standard timescale for tests"""
+ return load.timescale()
-diff --git a/skyfield/tests/test_against_novas.py
b/skyfield/tests/test_against_novas.py
-index af38d597..65eae075 100644
---- a/skyfield/tests/test_against_novas.py
-+++ b/skyfield/tests/test_against_novas.py
+Index: skyfield-1.24/skyfield/tests/test_against_novas.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_against_novas.py
++++ skyfield-1.24/skyfield/tests/test_against_novas.py
@@ -1,6 +1,8 @@
'Auto-generated accuracy tests vs NOVAS (see build_novas_tests.py).'
@@ -47,7 +46,7 @@
from skyfield import (earthlib, framelib, nutationlib, positionlib,
precessionlib, starlib, timelib)
from skyfield.api import Topos, load
-@@ -25,9 +27,13 @@ def compare(value, expected_value, epsilon):
+@@ -26,9 +28,13 @@ def compare(value, expected_value, epsil
else:
assert abs(value - expected_value) <= epsilon
@@ -61,10 +60,10 @@
def earth():
eph = load('de405.bsp')
yield eph[399]
-diff --git a/skyfield/tests/test_api.py b/skyfield/tests/test_api.py
-index 1292cb14..5c27a1cd 100644
---- a/skyfield/tests/test_api.py
-+++ b/skyfield/tests/test_api.py
+Index: skyfield-1.24/skyfield/tests/test_api.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_api.py
++++ skyfield-1.24/skyfield/tests/test_api.py
@@ -1,6 +1,6 @@
"""Basic tests of the Skyfield API module and its contents."""
@@ -82,7 +81,7 @@
" with a Time instance as its argument,"
" instead of the value 'blah'"):
earth.at('blah')
-@@ -40,10 +40,10 @@ def test_exception_raised_for_dates_outside_ephemeris(ts):
+@@ -40,10 +40,10 @@ def test_exception_raised_for_dates_outs
'ephemeris segment only covers dates 1899-07-28 23:59:18Z'
' through 2053-10-08 23:58:51Z UT'
)
@@ -131,11 +130,11 @@
api.NamedStar('foo')
def test_named_star_returns_star():
-diff --git a/skyfield/tests/test_io.py b/skyfield/tests/test_io.py
-index 8c5ead99..a31a719d 100644
---- a/skyfield/tests/test_io.py
-+++ b/skyfield/tests/test_io.py
-@@ -5,7 +5,11 @@
+Index: skyfield-1.24/skyfield/tests/test_io.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_io.py
++++ skyfield-1.24/skyfield/tests/test_io.py
+@@ -5,7 +5,11 @@ import shutil
import tempfile
from contextlib import contextmanager
from datetime import date
@@ -148,7 +147,7 @@
from skyfield import api
-@@ -28,6 +32,7 @@
+@@ -16,6 +20,7 @@ old_content = (b' 2015 10 1 67.9546\n'
new_content = (old_content +
b' 2016 2 1 68.1577\n')
@@ -156,27 +155,27 @@
def load():
path = tempfile.mkdtemp()
try:
-diff --git a/skyfield/tests/test_stars.py b/skyfield/tests/test_stars.py
-index bff6a9e1..926c0c5d 100644
---- a/skyfield/tests/test_stars.py
-+++ b/skyfield/tests/test_stars.py
-@@ -4,5 +4,5 @@
+Index: skyfield-1.24/skyfield/tests/test_stars.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_stars.py
++++ skyfield-1.24/skyfield/tests/test_stars.py
+@@ -4,5 +4,5 @@ from skyfield.data.hipparcos import load
def test_dataframe():
with api.load.open('hip_main.dat.gz') as f:
df = load_dataframe(f)
- star = api.Star.from_dataframe(df)
+ star = api.Star.from_dataframe(df.iloc[:214])
assert repr(star) == 'Star(ra shape=214, dec shape=214, ra_mas_per_year
shape=214, dec_mas_per_year shape=214, parallax_mas shape=214, epoch shape=214)'
-diff --git a/skyfield/tests/test_strs_and_reprs.py
b/skyfield/tests/test_strs_and_reprs.py
-index 536a45ad..bd1316f9 100644
---- a/skyfield/tests/test_strs_and_reprs.py
-+++ b/skyfield/tests/test_strs_and_reprs.py
+Index: skyfield-1.24/skyfield/tests/test_strs_and_reprs.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_strs_and_reprs.py
++++ skyfield-1.24/skyfield/tests/test_strs_and_reprs.py
@@ -1,3 +1,4 @@
+import pytest
import textwrap
from ..api import Topos, load
from ..sgp4lib import EarthSatellite
-@@ -5,6 +6,7 @@
+@@ -5,6 +6,7 @@ from ..sgp4lib import EarthSatellite
def dedent(s):
return textwrap.dedent(s.rstrip())
@@ -184,10 +183,10 @@
def eph():
yield load('de421.bsp')
-diff --git a/skyfield/tests/test_timelib.py b/skyfield/tests/test_timelib.py
-index 27d9fc6e..0648741e 100644
---- a/skyfield/tests/test_timelib.py
-+++ b/skyfield/tests/test_timelib.py
+Index: skyfield-1.24/skyfield/tests/test_timelib.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_timelib.py
++++ skyfield-1.24/skyfield/tests/test_timelib.py
@@ -1,5 +1,5 @@
import numpy as np
-from assay import assert_raises
@@ -195,7 +194,7 @@
from pytz import timezone
from skyfield import api
from skyfield.constants import DAY_S
-@@ -12,9 +12,9 @@
+@@ -12,9 +12,9 @@ epsilon = one_second * 42.0e-6 # 20.1e-
time_parameter = ['tai', 'tt', 'tdb', 'ut1']
time_value = [(1973, 1, 18, 1, 35, 37.5), 2441700.56640625]
@@ -207,7 +206,7 @@
def test_time_creation_methods(ts, time_parameter, time_value):
method = getattr(ts, time_parameter)
if isinstance(time_value, tuple):
-@@ -55,6 +55,9 @@ def
test_tt_seconds_preserve_10_decimal_places_in_calendar_seconds(ts):
+@@ -55,6 +55,9 @@ time_params_with_array = [
(2018, 3, 25, 13, 1, (10, 11, 12)),
]
@@ -217,41 +216,49 @@
def test_time_creation_with_arrays(time_scale_name, time_params_with_array):
ts = api.load.timescale()
getattr(ts, time_scale_name)(*time_params_with_array)
-@@ -67,9 +70,8 @@ def test_timescale_utc_method_with_array_inside(ts):
+@@ -67,9 +70,8 @@ def test_timescale_utc_method_with_array
assert t.tai[i] == ts.utc(1973, 12, 29, 23, 59, second).tai
def test_that_building_time_from_naive_datetime_raises_exception(ts):
- with assert_raises(ValueError) as info:
+ with pytest.raises(ValueError, match='import timezone'):
- ts.utc(datetime(1973, 12, 29, 23, 59, 48))
+ ts.from_datetime(datetime(1973, 12, 29, 23, 59, 48))
- assert 'import timezone' in str(info.exception)
def test_building_time_from_single_utc_datetime(ts):
- t = ts.utc(datetime(1973, 12, 29, 23, 59, 48, tzinfo=utc))
-diff --git a/skyfield/tests/test_topos.py b/skyfield/tests/test_topos.py
-index 0c47237e..e442ced2 100644
---- a/skyfield/tests/test_topos.py
-+++ b/skyfield/tests/test_topos.py
-@@ -1,13 +1,12 @@
+ t = ts.from_datetime(datetime(1973, 12, 29, 23, 59, 48, tzinfo=utc))
+Index: skyfield-1.24/skyfield/tests/test_topos.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_topos.py
++++ skyfield-1.24/skyfield/tests/test_topos.py
+@@ -1,4 +1,5 @@
from numpy import abs
+import pytest
--from skyfield.api import load
- from skyfield.toposlib import Topos
+ from skyfield import constants
+ from skyfield.api import Topos, load
+@@ -6,9 +7,6 @@ from skyfield.functions import length_of
angle = (-15, 15, 35, 45)
-def ts():
- yield load.timescale()
+-
+ def test_velocity():
+ # It looks like this is a sweet spot for accuracy: presumably a
+ # short enough fraction of a second that the vector does not time to
+@@ -35,6 +33,7 @@ def test_itrf_vector():
+ assert abs(y - 0.0) < 1e-14
+ assert abs(z - 0.7071) < 1e-4
+@pytest.mark.parametrize("angle", angle)
def test_beneath(ts, angle):
t = ts.utc(2018, 1, 19, 14, 37, 55)
# An elevation of 0 is more difficult for the routine's accuracy
-diff --git a/skyfield/tests/test_units.py b/skyfield/tests/test_units.py
-index a4a14832..d07d2d34 100644
---- a/skyfield/tests/test_units.py
-+++ b/skyfield/tests/test_units.py
+Index: skyfield-1.24/skyfield/tests/test_units.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_units.py
++++ skyfield-1.24/skyfield/tests/test_units.py
@@ -1,6 +1,6 @@
"""Tests of whether units behave."""
@@ -272,7 +279,7 @@
cannot directly unpack a Distance into several values
To unpack a Distance into three components, you need to ask for its
-@@ -98,9 +98,9 @@ def test_iterating_over_raw_measurement():
+@@ -98,9 +98,9 @@ value in specific units through an attri
def test_iterating_over_raw_velocity():
velocity = Velocity(au_per_d=1.234)
@@ -284,7 +291,7 @@
cannot directly unpack a Velocity into several values
To unpack a Velocity into three components, you need to ask for its
-@@ -113,9 +113,9 @@ def test_iterating_over_raw_velocity():
+@@ -113,9 +113,9 @@ value in specific units through an attri
def test_iterating_over_raw_angle():
angle = Angle(degrees=4.5)
@@ -296,10 +303,10 @@
Instead of iterating over this Angle object, try iterating over one of
its unit-specific arrays like .degrees, .hours, or .radians, or else over
-diff --git a/skyfield/tests/test_vectors.py b/skyfield/tests/test_vectors.py
-index 8407cbd1..69c4949e 100644
---- a/skyfield/tests/test_vectors.py
-+++ b/skyfield/tests/test_vectors.py
+Index: skyfield-1.24/skyfield/tests/test_vectors.py
+===================================================================
+--- skyfield-1.24.orig/skyfield/tests/test_vectors.py
++++ skyfield-1.24/skyfield/tests/test_vectors.py
@@ -1,6 +1,6 @@
# Test the behavior of all combinations of vector.
