def test_impose_finite_difference_dt(): class H1(HCRS): pass class H2(HCRS): pass class H3(HCRS): pass graph = t.TransformGraph() tfun = lambda c, f: f.__class__(ra=c.ra, dec=c.dec) # Set up a number of transforms with different time steps old_dt = 1*u.min transform1 = t.FunctionTransformWithFiniteDifference(tfun, H1, H1, register_graph=graph, finite_difference_dt=old_dt) transform2 = t.FunctionTransformWithFiniteDifference(tfun, H2, H2, register_graph=graph, finite_difference_dt=old_dt * 2) transform3 = t.FunctionTransformWithFiniteDifference(tfun, H2, H3, register_graph=graph, finite_difference_dt=old_dt * 3) # Check that all of the transforms have the same new time step new_dt = 1*u.yr with graph.impose_finite_difference_dt(new_dt): assert transform1.finite_difference_dt == new_dt assert transform2.finite_difference_dt == new_dt assert transform3.finite_difference_dt == new_dt # Check that all of the original time steps have been restored assert transform1.finite_difference_dt == old_dt assert transform2.finite_difference_dt == old_dt * 2 assert transform3.finite_difference_dt == old_dt * 3
def test_multiple_aliases(): from astropy.coordinates.baseframe import BaseCoordinateFrame # Define a frame with multiple aliases class MultipleAliasesFrame(BaseCoordinateFrame): name = ['alias_1', 'alias_2'] default_representation = r.SphericalRepresentation def tfun(c, f): return f.__class__(lon=c.lon, lat=c.lat) # Register a transform graph = t.TransformGraph() _ = t.FunctionTransform(tfun, MultipleAliasesFrame, MultipleAliasesFrame, register_graph=graph) # Test that both aliases have been added to the transform graph assert graph.lookup_name('alias_1') == MultipleAliasesFrame assert graph.lookup_name('alias_2') == MultipleAliasesFrame # Test that both aliases appear in the graphviz DOT format output dotstr = graph.to_dot_graph() assert '`alias_1`\\n`alias_2`' in dotstr
def test_remove_transform_and_unregister(): def tfun(c, f): f.__class__(ra=c.ra, dec=c.dec) # Register transforms graph = t.TransformGraph() ftrans1 = t.FunctionTransform(tfun, TCoo1, TCoo1, register_graph=graph) ftrans2 = t.FunctionTransform(tfun, TCoo2, TCoo2, register_graph=graph) _ = t.FunctionTransform(tfun, TCoo1, TCoo2, register_graph=graph) # Confirm that the frames are part of the graph assert TCoo1 in graph.frame_set assert TCoo2 in graph.frame_set # Use all three ways to remove a transform # Remove the only transform with TCoo2 as the "from" frame ftrans2.unregister(graph) # TCoo2 should still be part of the graph because it is the "to" frame of a transform assert TCoo2 in graph.frame_set # Remove the remaining transform that involves TCoo2 graph.remove_transform(TCoo1, TCoo2, None) # Now TCoo2 should not be part of the graph assert TCoo2 not in graph.frame_set # Remove the remaining transform that involves TCoo1 graph.remove_transform(None, None, ftrans1) # Now TCoo1 should not be part of the graph assert TCoo1 not in graph.frame_set
def test_shortest_path(): class FakeTransform: def __init__(self, pri): self.priority = pri g = t.TransformGraph() # cheating by adding graph elements directly that are not classes - the # graphing algorithm still works fine with integers - it just isn't a valid # TransformGraph # the graph looks is a down-going diamond graph with the lower-right slightly # heavier and a cycle from the bottom to the top # also, a pair of nodes isolated from 1 g._graph[1][2] = FakeTransform(1) g._graph[1][3] = FakeTransform(1) g._graph[2][4] = FakeTransform(1) g._graph[3][4] = FakeTransform(2) g._graph[4][1] = FakeTransform(5) g._graph[5][6] = FakeTransform(1) path, d = g.find_shortest_path(1, 2) assert path == [1, 2] assert d == 1 path, d = g.find_shortest_path(1, 3) assert path == [1, 3] assert d == 1 path, d = g.find_shortest_path(1, 4) print('Cached paths:', g._shortestpaths) assert path == [1, 2, 4] assert d == 2 # unreachable path, d = g.find_shortest_path(1, 5) assert path is None assert d == float('inf') path, d = g.find_shortest_path(5, 6) assert path == [5, 6] assert d == 1
def test_remove_transform_errors(): graph = t.TransformGraph() tfun = lambda c, f: f.__class__(ra=c.ra, dec=c.dec) _ = t.FunctionTransform(tfun, TCoo1, TCoo1, register_graph=graph) # Test bad calls to remove_transform with pytest.raises(ValueError): graph.remove_transform(None, TCoo1, None) with pytest.raises(ValueError): graph.remove_transform(TCoo1, None, None) with pytest.raises(ValueError): graph.remove_transform(None, None, None) with pytest.raises(ValueError): graph.remove_transform(None, None, 1) with pytest.raises(ValueError): graph.remove_transform(TCoo1, TCoo1, 1)