def test__init_maps_size(self):
"""Layout should init properly"""
layout = Layout(
[Map(Layer(Source(SOURCE))),
Map(Layer(Source(SOURCE)))], 1, 2)
assert layout._n_size == 1
assert layout._m_size == 2
def test_global_viewport(self):
"""Layout should return the same viewport for every map"""
layout = Layout([
Map(Layer(Source(SOURCE))),
Map(Layer(Source(SOURCE)))
], viewport={'zoom': 5})
assert layout._layout[0].get('viewport') == {'zoom': 5}
assert layout._layout[1].get('viewport') == {'zoom': 5}
def test_custom_viewport(self):
"""Layout should return a different viewport for every map"""
layout = Layout([
Map(Layer(Source(SOURCE)), viewport={'zoom': 2}),
Map(Layer(Source(SOURCE)))
], viewport={'zoom': 5})
assert layout._layout[0].get('viewport') == {'zoom': 2}
assert layout._layout[1].get('viewport') == {'zoom': 5}
def test_is_static(self):
"""Layout should set correctly is_static property for each map"""
layout = Layout([
Map(Layer(Source(SOURCE))),
Map(Layer(Source(SOURCE)))
], viewport={'zoom': 5})
assert layout._layout[0].get('is_static') is True
assert layout._layout[1].get('is_static') is True
def test_two_layers(self):
"""Map layer should be able to initialize two layers in the correct order"""
source_1 = Source(build_geodataframe([-10, 0], [-10, 0]))
source_2 = Source(build_geodataframe([0, 10], [10, 0]))
layer_1 = Layer(source_1)
layer_2 = Layer(source_2)
map = Map([layer_1, layer_2])
assert map.layers == [layer_1, layer_2]
def test_two_layers(self):
"""Map layer should be able to initialize two layers in the correct order"""
source_1 = Source(build_geojson([-10, 0], [-10, 0]))
source_2 = Source(build_geojson([0, 10], [10, 0]))
layer_1 = Layer(source_1)
layer_2 = Layer(source_2)
map = Map([layer_1, layer_2])
self.assertEqual(map.layers, [layer_2, layer_1])
self.assertEqual(len(map.layer_defs), 2)
def test_custom_camera(self):
"""Layout should return the correct camera for each map"""
layout = Layout([
Map(Layer(Source(SOURCE)), viewport={'zoom': 2}),
Map(Layer(Source(SOURCE)))
], viewport={'zoom': 5})
assert layout._layout[0].get('camera') == {
'bearing': None, 'center': None, 'pitch': None, 'zoom': 2}
assert layout._layout[1].get('camera') == {
'bearing': None, 'center': None, 'pitch': None, 'zoom': 5}
def test_kuviz_publisher_set_layers(self, mocker):
setup_mocks(mocker, self.credentials)
source_1 = Source(build_geodataframe([-10, 0], [-10, 0]))
source_2 = Source(build_geodataframe([0, 10], [10, 0]))
layer_1 = Layer(source_1)
layer_2 = Layer(source_2)
vmap = Map([layer_1, layer_2])
kuviz_publisher = KuvizPublisher(None)
kuviz_publisher.set_layers(vmap.layers)
assert kuviz_publisher._layers != vmap.layers
assert len(kuviz_publisher._layers) == len(vmap.layers)
def test__init_maps_valid(self):
"""Layout should raise an error if any element in the map list is not a Map"""
msg = 'All the elements in the Layout should be an instance of Map.'
with pytest.raises(Exception) as e:
Layout([Layer(Source(SOURCE))])
assert str(e.value) == msg
def test_default_interactive_layer(self):
"""Map layer should get the default event if the interactivity is set to []"""
source_1 = Source(build_geojson([-10, 0], [-10, 0]))
layer = Layer(source_1, popup={})
map = Map(layer)
self.assertEqual(map.layer_defs[0].get('interactivity'), [])
def test_kuviz_delete_publication(self, mocker):
setup_mocks(mocker, self.credentials)
html = 'fake_html'
kuviz_name = 'fake_name'
kuviz = CartoKuvizMock(kuviz_name)
KuvizManagerNamedtuple = namedtuple('KuvizManager', ['all'])
kuviz_manager_namedtuple = KuvizManagerNamedtuple(lambda: [kuviz])
mocker.patch('cartoframes.viz.kuviz._create_kuviz', return_value=kuviz)
mocker.patch('cartoframes.viz.kuviz._get_kuviz_manager',
return_value=kuviz_manager_namedtuple)
mock = mocker.patch(
'tests.unit.mocks.kuviz_mock.CartoKuvizMock.delete')
vmap = Map(Layer('fake_table', credentials=self.credentials))
kuviz_publisher = KuvizPublisher(None)
kuviz_publisher.set_layers(vmap.layers)
kuviz_publisher.publish(html, kuviz_name, None)
delete_publication(kuviz_name, credentials=self.credentials)
mock.assert_called_once_with()
def test_interactive_layer(self):
"""Map layer should indicate if the layer has interactivity configured"""
source_1 = Source(
build_geodataframe([-10, 0], [-10, 0], ['pop', 'name']))
layer = Layer(
source_1,
popup_click=[popup_element('pop'),
popup_element('name')],
popup_hover=[popup_element('pop', 'Pop')])
map = Map(layer)
assert map.layer_defs[0].get('interactivity') == [{
'event': 'click',
'attrs': {
'name': 'v8e0f74',
'title': 'name'
}
}, {
'event': 'click',
'attrs': {
'name': 'v559339',
'title': 'pop'
}
}, {
'event': 'hover',
'attrs': {
'name': 'v559339',
'title': 'Pop'
}
}]
def test_interactive_layer(self):
"""Map layer should indicate if the layer has interactivity configured"""
source_1 = Source(
build_geodataframe([-10, 0], [-10, 0], ['pop', 'name']))
layer = Layer(
source_1,
popup_click=[popup_element('pop'),
popup_element('name')],
popup_hover=[popup_element('pop', 'Pop')])
map = Map(layer)
layer_def = map.layers[0].get_layer_def()
assert layer_def.get('interactivity') == [{
'event': 'click',
'attrs': {
'name': 'v6ae999',
'title': 'name',
'format': None
}
}, {
'event': 'click',
'attrs': {
'name': 'v4f197c',
'title': 'pop',
'format': None
}
}, {
'event': 'hover',
'attrs': {
'name': 'v4f197c',
'title': 'Pop',
'format': None
}
}]
def test_interactive_layer(self):
"""Map layer should indicate if the layer has interactivity configured"""
source_1 = Source(build_geojson([-10, 0], [-10, 0]))
layer = Layer(source_1,
popup={
'click': ['$pop', '$name'],
'hover': [{
'title': 'Pop',
'value': '$pop'
}]
})
map = Map(layer)
self.assertEqual(map.layer_defs[0].get('interactivity'),
[{
'event':
'click',
'attrs': [{
'name': 'v559339',
'title': '$pop'
}, {
'name': 'v8e0f74',
'title': '$name'
}]
}, {
'event': 'hover',
'attrs': [{
'name': 'v559339',
'title': 'Pop'
}]
}])
def test_default_interactive_layer(self):
"""Map layer should get the default event if the interactivity is set to []"""
source_1 = Source(build_geodataframe([-10, 0], [-10, 0]))
layer = Layer(source_1)
map = Map(layer)
assert map.layer_defs[0].get('interactivity') == []
def test_layout_publish_remote_default(self, mocker):
setup_mocks(mocker)
mock_set_content = mocker.patch('cartoframes.viz.html.html_layout.HTMLLayout.set_content')
vlayout = Layout([Map(Layer('fake_table', credentials=self.credentials))])
name = 'cf_publish'
kuviz_dict = vlayout.publish(name, None, self.credentials)
self.assert_kuviz_dict(kuviz_dict, name, 'public')
mock_set_content.assert_called_once_with(
is_embed=True,
is_static=False,
m_size=1,
n_size=1,
size=['100%', 250],
map_height='100%',
maps=[{
'layers': [{
'credentials': {
'username': '******',
'api_key': 'fake_api_key',
'base_url': 'https://fake_username.carto.com'
},
'interactivity': [],
'legends': [],
'has_legend_list': True,
'encode_data': True,
'widgets': [],
'data': 'select * from fake_table',
'type': 'Query',
'title': None,
'options': {},
'map_index': 0,
'source': 'select * from fake_table',
'viz': '''color: hex("#EE4D5A")
strokeColor: opacity(#222,ramp(linear(zoom(),0,18),[0,0.6]))
strokeWidth: ramp(linear(zoom(),0,18),[0,1])
width: ramp(linear(zoom(),0,18),[2,10])
'''
}],
'bounds': [[-180, -90], [180, 90]],
'size': None,
'viewport': None,
'camera': None,
'basemap': 'Positron',
'basecolor': '',
'token': '',
'show_info': None,
'has_legends': False,
'has_widgets': False,
'theme': None,
'title': None,
'description': None,
'is_static': False,
'layer_selector': False,
'_carto_vl_path': None,
'_airship_path': None
}]
)
def test_map_publish_with_password(self, mocker):
setup_mocks(mocker)
map = Map(Layer(Source('fake_table', credentials=self.credentials)))
name = 'cf_publish'
kuviz_dict = map.publish(name, '1234', credentials=self.credentials)
self.assert_kuviz_dict(kuviz_dict, name, 'password')
def test_kuviz_publisher_create_new_apikey(self, mocker):
token = '1234'
setup_mocks(mocker, self.credentials, is_public=False, token=token)
layers = [Layer('fake_table', credentials=self.credentials)]
kuviz_publisher = KuvizPublisher(None)
assert kuviz_publisher._create_maps_api_keys(layers) == token
def geo_api():
"""
Introduciendo un criterio para llamar a la API de Foursquare, obtienes un mapa con los puntos obtenidos
"""
load_dotenv()
tok1 = os.getenv("tok1")
tok2 = os.getenv("tok2")
url_query = 'https://api.foursquare.com/v2/venues/explore'
criterio = input("¿Qué quieres buscar en Foursquare? \n")
limite = input("¿Cuántas búsquedas quieres que muestre? \n")
radio = input("¿En qué radio?(medida = metros) \n")
params = {
"client_id": tok1,
"client_secret": tok2,
"v": "20180323",
"ll": f"60.17212, 24.94519",
"query": f"{criterio}",
"limit": {limite},
"radius": {radio}
}
resp = requests.get(url=url_query, params=params)
data = json.loads(resp.text)
decoding_data = data.get("response")
decoded = decoding_data.get("groups")[0]
items = decoded.get("items")
mapa_nombre = ["venue", "name"]
m_latitude = ["venue", "location", "lat"]
m_longitude = ["venue", "location", "lng"]
def getFromDict(diccionario, mapa):
return reduce(operator.getitem, mapa, diccionario)
list_items = []
for dic in items:
items_dict = {}
items_dict["name"] = getFromDict(dic, mapa_nombre)
items_dict["latitud"] = getFromDict(dic, m_latitude)
items_dict["longitud"] = getFromDict(dic, m_longitude)
list_items.append(items_dict)
dataframefinal = pd.DataFrame(list_items)
gdf = gpd.GeoDataFrame(dataframefinal,
geometry=gpd.points_from_xy(
dataframefinal.longitud,
dataframefinal.latitud))
mapa = Map(
Layer(gdf, popup_hover=[popup_element("name", f"{criterio}")]))
return mapa
def test_map_publish_deletion(self, mocker):
setup_mocks(mocker)
map = Map(Layer(Source('fake_table', credentials=self.credentials)))
name = 'cf_publish'
map.publish(name, None, credentials=self.credentials)
response = map.delete_publication()
assert response is True
def test_map_publish_update_password(self, mocker):
setup_mocks(mocker)
map = Map(Layer(Source('fake_table', credentials=self.credentials)))
name = 'cf_publish'
map.publish(name, None, credentials=self.credentials)
kuviz_dict = map.update_publication(name, '1234"')
self.assert_kuviz_dict(kuviz_dict, name, 'password')
def test_map_publish_remote_default(self, mocker):
setup_mocks(mocker)
mock_set_content = mocker.patch(
'cartoframes.viz.html.html_map.HTMLMap.set_content')
vmap = Map(Layer('fake_table', credentials=self.credentials))
name = 'cf_publish'
kuviz_dict = vmap.publish(name, None, self.credentials)
self.assert_kuviz_dict(kuviz_dict, name, 'public')
mock_set_content.assert_called_once_with(
_airship_path=None,
_carto_vl_path=None,
basemap='Positron',
bounds=[[-180, -90], [180, 90]],
camera=None,
description=None,
is_embed=True,
is_static=None,
layer_selector=False,
layers=[{
'credentials': {
'username': '******',
'api_key': 'fake_api_key',
'base_url': 'https://fake_username.carto.com'
},
'interactivity': [],
'legends': [],
'has_legend_list':
True,
'encode_data':
True,
'widgets': [],
'data':
'select * from fake_table',
'type':
'Query',
'title':
None,
'options': {},
'map_index':
0,
'source':
'select * from fake_table',
'viz':
'''color: hex("#EE4D5A")
strokeColor: opacity(#222,ramp(linear(zoom(),0,18),[0,0.6]))
strokeWidth: ramp(linear(zoom(),0,18),[0,1])
width: ramp(linear(zoom(),0,18),[2,10])
'''
}],
show_info=False,
size=None,
theme=None,
title='cf_publish')
def test_wrong_crs_layer():
# Given
gdf = GeoDataFrame({'geometry': [Point([0, 0])]}, crs='epsg:2263')
# When
with pytest.raises(ValueError) as e:
Layer(gdf)
# Then
assert str(
e.value
) == 'No valid geometry CRS "epsg:2263", it must be "epsg:4326".'
def test_initialization_objects(self):
"""Layer should initialize layer attributes"""
layer = Layer(Source('layer_source'))
self.assertFalse(layer.is_basemap)
self.assertEqual(layer.orig_query,
'SELECT * FROM "public"."layer_source"')
self.assertTrue(isinstance(layer.source, Source))
self.assertTrue(isinstance(layer.style, Style))
self.assertTrue(isinstance(layer.popup, Popup))
self.assertTrue(isinstance(layer.legend, Legend))
self.assertEqual(layer.interactivity, [])
def test_initialization_simple(self, mocker):
"""Layer should initialize layer attributes"""
setup_mocks(mocker, 'layer_source')
layer = Layer('layer_source', {}, credentials=Credentials('fakeuser'))
assert layer.is_basemap is False
assert layer.source_data == 'SELECT * FROM "public"."layer_source"'
assert isinstance(layer.source, Source)
assert isinstance(layer.style, Style)
assert isinstance(layer.popups, PopupList)
assert isinstance(layer.legends, LegendList)
assert isinstance(layer.widgets, WidgetList)
assert layer.interactivity == []
def test_kuviz_publisher_update_fail(self, mocker):
setup_mocks(mocker, self.credentials)
vmap = Map(Layer('fake_table', credentials=self.credentials))
html = 'fake_html'
kuviz_name = 'fake_name'
kuviz_publisher = KuvizPublisher(None)
kuviz_publisher.set_layers(vmap.layers)
with pytest.raises(Exception):
kuviz_publisher.update(html, kuviz_name, None)
def test_one_layer(self):
"""Map layer should be able to initialize one layer"""
source = Source(build_geojson([-10, 0], [-10, 0]))
layer = Layer(source)
map = Map(layer)
self.assertEqual(map.layers, [layer])
self.assertEqual(len(map.layer_defs), 1)
self.assertEqual(map.layer_defs[0].get('interactivity'), [])
self.assertIsNotNone(map.layer_defs[0].get('credentials'))
self.assertIsNotNone(map.layer_defs[0].get('legend'))
self.assertIsNotNone(map.layer_defs[0].get('query'))
self.assertEqual(map.layer_defs[0].get('type'), 'GeoJSON')
self.assertIsNotNone(map.layer_defs[0].get('viz'))
def test_one_layer(self):
"""Map layer should be able to initialize one layer"""
source = Source(build_geodataframe([-10, 0], [-10, 0]))
layer = Layer(source)
map = Map(layer)
assert map.layers == [layer]
assert len(map.layer_defs) == 1
assert map.layer_defs[0].get('interactivity') == []
assert map.layer_defs[0].get('credentials') is None
assert map.layer_defs[0].get('legends') is not None
assert map.layer_defs[0].get('widgets') is not None
assert map.layer_defs[0].get('data') is not None
assert map.layer_defs[0].get('type') == 'GeoJSON'
assert map.layer_defs[0].get('viz') is not None
def test_kuviz_publisher_publish(self, mocker):
setup_mocks(mocker, self.credentials)
kuviz = CartoKuvizMock('fake_kuviz')
mocker.patch('cartoframes.viz.kuviz._create_kuviz', return_value=kuviz)
vmap = Map(Layer('fake_table', credentials=self.credentials))
html = 'fake_html'
kuviz_name = 'fake_name'
kuviz_publisher = KuvizPublisher(None)
kuviz_publisher.set_layers(vmap.layers)
result = kuviz_publisher.publish(html, kuviz_name, None)
assert kuviz_publisher.kuviz == kuviz
assert result == kuviz_to_dict(kuviz)
def test_style_str(self):
"""Layer style should set the style when it is a dict"""
layer = Layer(
'layer_source', """
@grad: [red, green, blue]
color: blue
width: 10
strokeColor: black
strokeWidth: 1
""")
self.assertTrue(isinstance(layer.style, Style))
self.assertTrue('@grad: [red, green, blue]' in layer.viz)
self.assertTrue('color: blue' in layer.viz)
self.assertTrue('width: 10' in layer.viz)
self.assertTrue('strokeColor: black' in layer.viz)
self.assertTrue('strokeWidth: 1' in layer.viz)
