@taldcroft - I have on and off wrote sequences like this as well, as it helps speed up the case where the scale is already correct (avoiding the creation of a new instance). But it is also a bit ugly... Often, like here, it is in preparation to get both jd, so maybe a function to get those in a certain scale? (with default, just returning internal jd1, jd2 if no scale given). But perhaps this is overoptimization...

Actually, @eteq - since this seem to happen mostly when you are getting out jd1 and jd2, maybe this would be something for a very small helper function instead:

def jds(time, scale=None):
    t = time if scale is None or scale == time.scale else getattr(time, scale)
    return t.jd1, t.jd2

which allows you do do:

jd1, jd2 = jds(obstime, scale='utc')

(or for simple functions to put in directly as arguments: erfa.obl06(*jds(obstime, 'tt')))

@mhvk - relevant to the above questions, here is the code:

    def __getattr__(self, attr):
        """
        Get dynamic attributes to output format or do timescale conversion.
        """
        if attr in self.SCALES and self.scale is not None:
            tm = self.replicate()
            tm._set_scale(attr)
            return tm

What about:

• Return self if attr == self.scale?
• Cache other scales so getting both jd1 and jd2 after transforming will be efficient?
  Roughly:

    def __getattr__(self, attr):
        """
        Get dynamic attributes to output format or do timescale conversion.
        """
        if attr in self.SCALES and self.scale is not None:
            if attr == self.scale:
                tm = self
            elif attr in self._scale_cache:
                tm = self._scale_cache[attr]
            else:
                tm = self.replicate()
                tm._set_scale(attr)
                self._scale_cache[attr] = tm
            return tm

I guess we would need to clear the cache if delta_ut1_utc or delta_tdb_tt were set.

@taldcroft - since Time instances are immutable, I think we could at least do the very simple change of just returning self if the scale is already correct. The caching I'm less sure about; maybe adding a bit too much complexity.

I like @taldcroft's suggestion here. The first thing I thought was "I should be able to do time.tt.jd1, time.tt.jd2, because that's the clearest. But then I checked and realized it's not cached, so I decided it wasn't fast enough given that this is in inner loops. So I naturally assumed there would be a cache and was surprised that there wasn't.

If it helps any, there's precedence in coordinates itself for this. So I'd advocate for instead doing just as @taldcroft says here.

I think that's a "new feature", though, so it probably has to wait for 1.2 . In the meantime, I will create a utility function as @mhvk suggests just for coordinates, which we can later change to just being return getattr(time, scale).jd1, getattr(time, scale).jd2 or just replace all of it with direct conversions once the caching and such is in.

@eteq @mhvk - I've created issue #4309 to discuss this since it's getting a bit OT here.

By just accessing delta_ut1_utc you'll get an IndexError if the time is outside of the IERS table. I think if the time is OK, it is not a problem for the time instance to change, but if it is outside IERS, it should ideally not be set. I think you would need to do something like:

    if scale == time.scale:
        newtime = time
    else:
        try:
            newtime = getattr(time, scale)
        except IndexError:
            # similar warning to that in get_dut1dutc
            newtime = time
    return newtime.jd1, newtime.jd2

ohh, I didn't realize the accessor triggered the error - will do what you suggest here, then.