diff --git a/example_data/example_csv/links.csv b/example_data/example_csv/links.csv new file mode 100644 index 00000000..4095f13a --- /dev/null +++ b/example_data/example_csv/links.csv @@ -0,0 +1,3 @@ +index,from,modes,oneway,s2_to,attributes,capacity,freespeed,to,length,geometry,permlanes,id,s2_from +1,25508485,{'car'},1,5221390302696205321,"{'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}",600.0,4.166666666666667,21667818,52.765151087870265,kevj`maB_`la`}`@{ooxA`k~rH,1.0,1,5221390301001263407 +10,200048,{'car'},1,5221390299830573099,"{'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997927'}, 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Macfarren Place'}}",600.0,4.166666666666667,295927764,53.77508435879174,{nuphlaBkmquj|`@v`ab@uxieI,1.0,10,5221390299873156021 \ No newline at end of file diff --git a/example_data/example_csv/nodes.csv b/example_data/example_csv/nodes.csv new file mode 100644 index 00000000..fe3658ea --- /dev/null +++ b/example_data/example_csv/nodes.csv @@ -0,0 +1,5 @@ +index,x,y,lat,lon,s2_id,geometry,id +25508485,528489.467895946,182206.20303669578,51.524162533239284,-0.14930198709481451,5221390301001263407,"(528489.467895946, 182206.20303669578)",25508485 +21667818,528504.1342843144,182155.7435136598,51.52370573323939,-0.14910908709500162,5221390302696205321,"(528504.1342843144, 182155.7435136598)",21667818 +295927764,528358.873300625,182147.6313714285,51.52366583323934,-0.15120468709594614,5221390299830573099,"(528358.873300625, 182147.6313714285)",295927764 +200048,528364.6182191424,182094.16422237462,51.52318403323943,-0.1511413870962065,5221390299873156021,"(528364.6182191424, 182094.16422237462)",200048 \ No newline at end of file diff --git a/example_data/example_geojson/network_links.geojson b/example_data/example_geojson/network_links.geojson new file mode 100644 index 00000000..61b32f50 --- /dev/null +++ b/example_data/example_geojson/network_links.geojson @@ -0,0 +1,8 @@ +{ +"type": "FeatureCollection", +"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::27700" } }, +"features": [ +{ "type": "Feature", "properties": { "index": "1", "id": "1", "from": "25508485", "to": "21667818", "freespeed": 4.166666666666667, "capacity": 600.0, "permlanes": 1.0, "oneway": "1", "modes": "car", "s2_from": 5221390301001263407, "s2_to": 5221390302696205321, "attributes": { "osm:way:access": { "name": "osm:way:access", "class": "java.lang.String", "text": "permissive" }, "osm:way:highway": { "name": "osm:way:highway", "class": "java.lang.String", "text": "unclassified" }, "osm:way:id": { "name": "osm:way:id", "class": "java.lang.Long", "text": "26997928" }, "osm:way:name": { "name": "osm:way:name", "class": "java.lang.String", "text": "Brunswick Place" } }, "length": 52.765151087870265 }, "geometry": { "type": "LineString", "coordinates": [ [ 528489.467895945999771, 182206.203036695776973 ], [ 528504.134284314350225, 182155.743513659806922 ] ] } }, +{ "type": "Feature", "properties": { "index": "10", "id": "10", "from": "200048", "to": "295927764", "freespeed": 4.166666666666667, "capacity": 600.0, "permlanes": 1.0, "oneway": "1", "modes": "car", "s2_from": 5221390299873156021, "s2_to": 5221390299830573099, "attributes": { "osm:way:access": { "name": "osm:way:access", "class": "java.lang.String", "text": "permissive" }, "osm:way:highway": { "name": "osm:way:highway", "class": "java.lang.String", "text": "unclassified" }, "osm:way:id": { "name": "osm:way:id", "class": "java.lang.Long", "text": "26997927" }, "osm:way:name": { "name": "osm:way:name", "class": "java.lang.String", "text": "Macfarren Place" } }, "length": 53.775084358791737 }, "geometry": { "type": "LineString", "coordinates": [ [ 528364.618219142430462, 182094.164222374616656 ], [ 528358.873300625011325, 182147.631371428491548 ] ] } } +] +} diff --git a/example_data/example_geojson/network_nodes.geojson b/example_data/example_geojson/network_nodes.geojson new file mode 100644 index 00000000..e45fa58f --- /dev/null +++ b/example_data/example_geojson/network_nodes.geojson @@ -0,0 +1,10 @@ +{ +"type": "FeatureCollection", +"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::27700" } }, +"features": [ +{ "type": "Feature", "properties": { "index": "25508485", "id": "25508485", "x": 528489.467895946, "y": 182206.20303669578, "lon": -0.14930198709481451, "lat": 51.524162533239284, "s2_id": 5221390301001263407 }, "geometry": { "type": "Point", "coordinates": [ 528489.467895945999771, 182206.203036695776973 ] } }, +{ "type": "Feature", "properties": { "index": "21667818", "id": "21667818", "x": 528504.13428431435, "y": 182155.74351365981, "lon": -0.14910908709500162, "lat": 51.523705733239389, "s2_id": 5221390302696205321 }, "geometry": { "type": "Point", "coordinates": [ 528504.134284314350225, 182155.743513659806922 ] } }, +{ "type": "Feature", "properties": { "index": "200048", "id": "200048", "x": 528364.61821914243, "y": 182094.16422237462, "lon": -0.1511413870962065, "lat": 51.523184033239431, "s2_id": 5221390299873156021 }, "geometry": { "type": "Point", "coordinates": [ 528364.618219142430462, 182094.164222374616656 ] } }, +{ "type": "Feature", "properties": { "index": "295927764", "id": "295927764", "x": 528358.87330062501, "y": 182147.63137142849, "lon": -0.15120468709594614, "lat": 51.523665833239342, "s2_id": 5221390299830573099 }, "geometry": { "type": "Point", "coordinates": [ 528358.873300625011325, 182147.631371428491548 ] } } +] +} diff --git a/example_data/example_json/network.json b/example_data/example_json/network.json new file mode 100644 index 00000000..c48a52d0 --- /dev/null +++ b/example_data/example_json/network.json @@ -0,0 +1,126 @@ +{ + "nodes": { + "25508485": { + "id": "25508485", + "lon": -0.14930198709481451, + "y": 182206.20303669578, + "x": 528489.467895946, + "geometry": [ + 528489.467895946, + 182206.20303669578 + ], + "lat": 51.524162533239284, + "s2_id": 5221390301001263407 + }, + "21667818": { + "id": "21667818", + "lon": -0.14910908709500162, + "y": 182155.7435136598, + "x": 528504.1342843144, + "geometry": [ + 528504.1342843144, + 182155.7435136598 + ], + "lat": 51.52370573323939, + "s2_id": 5221390302696205321 + }, + "295927764": { + "id": "295927764", + "lon": -0.15120468709594614, + "y": 182147.6313714285, + "x": 528358.873300625, + "geometry": [ + 528358.873300625, + 182147.6313714285 + ], + "lat": 51.52366583323934, + "s2_id": 5221390299830573099 + }, + "200048": { + "id": "200048", + "lon": -0.1511413870962065, + "y": 182094.16422237462, + "x": 528364.6182191424, + "geometry": [ + 528364.6182191424, + 182094.16422237462 + ], + "lat": 51.52318403323943, + "s2_id": 5221390299873156021 + } + }, + "links": { + "1": { + "id": "1", + "attributes": { + "osm:way:access": { + "name": "osm:way:access", + "class": "java.lang.String", + "text": "permissive" + }, + "osm:way:highway": { + "name": "osm:way:highway", + "class": "java.lang.String", + "text": "unclassified" + }, + "osm:way:id": { + "name": "osm:way:id", + "class": "java.lang.Long", + "text": "26997928" + }, + "osm:way:name": { + "name": "osm:way:name", + "class": "java.lang.String", + "text": "Brunswick Place" + } + }, + "s2_from": 5221390301001263407, + "freespeed": 4.166666666666667, + "to": "21667818", + "permlanes": 1.0, + "modes": "car", + "geometry": "kevj`maB_`la`}`@{ooxA`k~rH", + "oneway": "1", + "from": "25508485", + "s2_to": 5221390302696205321, + "length": 52.765151087870265, + "capacity": 600.0 + }, + "10": { + "id": "10", + "attributes": { + "osm:way:access": { + "name": "osm:way:access", + "class": "java.lang.String", + "text": "permissive" + }, + "osm:way:highway": { + "name": "osm:way:highway", + "class": "java.lang.String", + "text": "unclassified" + }, + "osm:way:id": { + "name": "osm:way:id", + "class": "java.lang.Long", + "text": "26997927" + }, + "osm:way:name": { + "name": "osm:way:name", + "class": "java.lang.String", + "text": "Macfarren Place" + } + }, + "s2_from": 5221390299873156021, + "freespeed": 4.166666666666667, + "to": "295927764", + "permlanes": 1.0, + "modes": "car", + "geometry": "{nuphlaBkmquj|`@v`ab@uxieI", + "oneway": "1", + "from": "200048", + "s2_to": 5221390299830573099, + "length": 53.77508435879174, + "capacity": 600.0 + } + } +} \ No newline at end of file diff --git a/example_data/example_json/schedule.json b/example_data/example_json/schedule.json new file mode 100644 index 00000000..f920570a --- /dev/null +++ b/example_data/example_json/schedule.json @@ -0,0 +1,120 @@ +{ + "schedule": { + "stops": { + "490000235X.link:1": { + "lon": 51.51668503324075, + "id": "490000235X.link:1", + "name": "Tottenham Court Road Station (Stop X)", + "y": 181412.0975758662, + "lat": -0.12809598708996447, + "x": 529981.7958802709, + "isBlocking": "false", + "linkRefId": "1", + "s2_id": 2507584377443783851 + }, + "490000235YB.link:10": { + "lon": 51.51609803324078, + "id": "490000235YB.link:10", + "name": "Oxford Street Soho Street (Stop YB)", + "y": 181336.2815925331, + "lat": -0.13404398709291862, + "x": 529570.7813227688, + "isBlocking": "false", + "linkRefId": "10", + "s2_id": 2507584474601580133 + } + }, + "services": { + "20274": { + "id": "20274", + "name": "N55", + "routes": { + "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e": { + "route_short_name": "N55", + "mode": "bus", + "trips": { + "trip_id": [ + "VJ4e00b97ca9c6c0c96da8f793dfbd37b11f647fa7_03:40:00" + ], + "trip_departure_time": [ + "03:40:00" + ], + "vehicle_id": [ + "veh_0_bus" + ] + }, + "arrival_offsets": [ + "00:00:00", + "00:02:20" + ], + "departure_offsets": [ + "00:00:00", + "00:02:20" + ], + "route_long_name": "", + "id": "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e", + "route": [ + "1", + "10" + ], + "await_departure": [ + true, + true + ], + "ordered_stops": [ + "490000235X.link:1", + "490000235YB.link:10" + ] + } + } + } + }, + "minimal_transfer_times": { + "490000235X.link:1": { + "stop": "490000235YB.link:10", + "transferTime": 100.0 + }, + "490000235YB.link:10": { + "stop": "490000235X.link:1", + "transferTime": 100.0 + } + } + }, + "vehicles": { + "vehicle_types": { + "bus": { + "capacity": { + "seats": { + "persons": "70" + }, + "standingRoom": { + "persons": "0" + } + }, + "length": { + "meter": "18.0" + }, + "width": { + "meter": "2.5" + }, + "accessTime": { + "secondsPerPerson": "0.5" + }, + "egressTime": { + "secondsPerPerson": "0.5" + }, + "doorOperation": { + "mode": "serial" + }, + "passengerCarEquivalents": { + "pce": "2.8" + } + } + }, + "vehicles": { + "veh_0_bus": { + "type": "bus" + } + } + } +} \ No newline at end of file diff --git a/genet/__init__.py b/genet/__init__.py index 8d15bc73..9c9b3317 100644 --- a/genet/__init__.py +++ b/genet/__init__.py @@ -1,7 +1,8 @@ from genet.core import Network # noqa: F401 from genet.schedule_elements import Schedule, Service, Route, Stop # noqa: F401 +from genet.inputs_handler.read import * # noqa: F401,F403 from genet.auxiliary_files import AuxiliaryFile # noqa: F401 from genet.exceptions import ScheduleElementGraphSchemaError, RouteInitialisationError, \ ServiceInitialisationError # noqa: F401 from genet.utils import graph_operations # noqa: F401 -from genet.utils import google_directions # noqa: F401,F403 +from genet.utils import google_directions # noqa: F401 diff --git a/genet/core.py b/genet/core.py index 14cfd58b..37c9d314 100644 --- a/genet/core.py +++ b/genet/core.py @@ -4,14 +4,14 @@ import uuid import logging import os +import json from copy import deepcopy from typing import Union, List, Dict from pyproj import Transformer from s2sphere import CellId -import genet.inputs_handler.matsim_reader as matsim_reader -import genet.inputs_handler.osm_reader as osm_reader import genet.outputs_handler.matsim_xml_writer as matsim_xml_writer import genet.outputs_handler.geojson as geojson +import genet.outputs_handler.sanitiser as sanitiser import genet.modify.change_log as change_log import genet.modify.graph as modify_graph import genet.utils.spatial as spatial @@ -188,7 +188,7 @@ def node_attribute_data_under_key(self, key): """ return pd.Series(graph_operations.get_attribute_data_under_key(self.nodes(), key)) - def node_attribute_data_under_keys(self, keys: list, index_name=None): + def node_attribute_data_under_keys(self, keys: Union[list, set], index_name=None): """ Generates a pandas.DataFrame object indexed by link ids, with data stored on the nodes under `key` :param keys: list of either a string e.g. 'x', or if accessing nested information, a dictionary @@ -217,7 +217,7 @@ def link_attribute_data_under_key(self, key: Union[str, dict]): """ return pd.Series(graph_operations.get_attribute_data_under_key(self.links(), key)) - def link_attribute_data_under_keys(self, keys: list, index_name=None): + def link_attribute_data_under_keys(self, keys: Union[list, set], index_name=None): """ Generates a pandas.DataFrame object indexed by link ids, with data stored on the links under `key` :param keys: list of either a string e.g. 'modes', or if accessing nested information, a dictionary @@ -349,10 +349,10 @@ def nodes_on_spatial_condition(self, region_input): """ if not isinstance(region_input, str): # assumed to be a shapely.geometry input - gdf = geojson.generate_geodataframes(self.graph)[0] + gdf = self.to_geodataframe()['nodes'].to_crs("epsg:4326") return self._find_ids_on_shapely_geometry(gdf, how='intersect', shapely_input=region_input) elif persistence.is_geojson(region_input): - gdf = geojson.generate_geodataframes(self.graph)[0] + gdf = self.to_geodataframe()['nodes'].to_crs("epsg:4326") return self._find_ids_on_geojson(gdf, how='intersect', geojson_input=region_input) else: # is assumed to be hex @@ -369,7 +369,7 @@ def links_on_spatial_condition(self, region_input, how='intersect'): - shapely.geometry object, e.g. Polygon or a shapely.geometry.GeometryCollection of such objects :return: link IDs """ - gdf = geojson.generate_geodataframes(self.graph)[1] + gdf = self.to_geodataframe()['links'].to_crs("epsg:4326") if not isinstance(region_input, str): # assumed to be a shapely.geometry input return self._find_ids_on_shapely_geometry(gdf, how, region_input) @@ -1337,7 +1337,7 @@ def zero_value(value): } return report - def generate_standard_outputs(self, output_dir, gtfs_day='19700101'): + def generate_standard_outputs(self, output_dir, gtfs_day='19700101', include_shp_files=False): """ Generates geojsons that can be used for generating standard kepler visualisations. These can also be used for validating network for example inspecting link capacity, freespeed, number of lanes, @@ -1347,74 +1347,10 @@ def generate_standard_outputs(self, output_dir, gtfs_day='19700101'): defaults to 1970/01/01 otherwise :return: None """ - geojson.generate_standard_outputs(self, output_dir, gtfs_day) + geojson.generate_standard_outputs(self, output_dir, gtfs_day, include_shp_files) logging.info('Finished generating standard outputs. Zipping folder.') persistence.zip_folder(output_dir) - def read_osm(self, osm_file_path, osm_read_config, num_processes: int = 1): - """ - Reads OSM data into a graph of the Network object - :param osm_file_path: path to .osm or .osm.pbf file - :param osm_read_config: config file (see configs folder in genet for examples) which informs for example which - highway types to read (in case of road network) and what modes to assign to them - :param num_processes: number of processes to split parallelisable operations across - :return: - """ - config = osm_reader.Config(osm_read_config) - nodes, edges = osm_reader.generate_osm_graph_edges_from_file( - osm_file_path, config, num_processes) - - nodes_and_attributes = parallel.multiprocess_wrap( - data=nodes, - split=parallel.split_dict, - apply=osm_reader.generate_graph_nodes, - combine=parallel.combine_dict, - epsg=self.epsg - ) - reindexing_dict, nodes_and_attributes = self.add_nodes(nodes_and_attributes) - - edges_attributes = parallel.multiprocess_wrap( - data=edges, - split=parallel.split_list, - apply=osm_reader.generate_graph_edges, - combine=parallel.combine_list, - reindexing_dict=reindexing_dict, - nodes_and_attributes=nodes_and_attributes, - config_path=osm_read_config - ) - self.add_edges(edges_attributes) - - logging.info('Deleting isolated nodes which have no edges.') - self.remove_nodes(list(nx.isolates(self.graph))) - - def read_matsim_network(self, path): - self.graph, self.link_id_mapping, duplicated_nodes, duplicated_links = \ - matsim_reader.read_network(path, self.transformer) - self.graph.graph['name'] = 'Network graph' - self.graph.graph['crs'] = {'init': self.epsg} - if 'simplified' not in self.graph.graph: - self.graph.graph['simplified'] = False - - for node_id, duplicated_node_attribs in duplicated_nodes.items(): - for duplicated_node_attrib in duplicated_node_attribs: - self.change_log.remove( - object_type='node', - object_id=node_id, - object_attributes=duplicated_node_attrib - ) - for link_id, reindexed_duplicated_links in duplicated_links.items(): - for duplicated_link in reindexed_duplicated_links: - self.change_log.modify( - object_type='link', - old_id=link_id, - old_attributes=self.link(duplicated_link), - new_id=duplicated_link, - new_attributes=self.link(duplicated_link) - ) - - def read_matsim_schedule(self, schedule_path, vehicles_path=''): - self.schedule.read_matsim_schedule(schedule_path, vehicles_path) - def read_auxiliary_link_file(self, file_path): aux_file = auxiliary_files.AuxiliaryFile(file_path) aux_file.attach({link_id for link_id, dat in self.links()}) @@ -1452,13 +1388,93 @@ def write_auxiliary_files(self, output_dir): for name, aux_file in self.auxiliary_files[id_type].items(): aux_file.write_to_file(output_dir) + def write_extras(self, output_dir): + self.change_log.export(os.path.join(output_dir, 'network_change_log.csv')) + self.write_auxiliary_files(os.path.join(output_dir, 'auxiliary_files')) + def write_to_matsim(self, output_dir): + """ + Writes Network and Schedule (if applicable) to MATSim xml format + :param output_dir: output directory + :return: + """ persistence.ensure_dir(output_dir) matsim_xml_writer.write_matsim_network(output_dir, self) if self.schedule: self.schedule.write_to_matsim(output_dir) - self.change_log.export(os.path.join(output_dir, 'network_change_log.csv')) - self.write_auxiliary_files(os.path.join(output_dir, 'auxiliary_files')) + self.write_extras(output_dir) + + def to_json(self): + _network = self.to_encoded_geometry_dataframe() + return {'nodes': _network['nodes'].T.to_dict(), 'links': _network['links'].T.to_dict()} - def save_network_to_geojson(self, output_dir): - geojson.save_network_to_geojson(self, output_dir) + def write_to_json(self, output_dir): + """ + Writes Network and Schedule (if applicable) to a single JSON file with nodes and links + :param output_dir: output directory + :return: + """ + persistence.ensure_dir(output_dir) + logging.info(f'Saving Network to JSON in {output_dir}') + with open(os.path.join(output_dir, 'network.json'), 'w') as outfile: + json.dump(sanitiser.sanitise_dictionary(self.to_json()), outfile) + if self.schedule: + self.schedule.write_to_json(output_dir) + self.write_extras(output_dir) + + def write_to_geojson(self, output_dir, epsg: str = None): + """ + Writes Network graph and Schedule (if applicable) to nodes and links geojson files. + :param output_dir: output directory + :param epsg: projection if the geometry is to be reprojected, defaults to own projection + :return: + """ + persistence.ensure_dir(output_dir) + _network = self.to_geodataframe() + if epsg is not None: + _network['nodes'] = _network['nodes'].to_crs(epsg) + _network['links'] = _network['links'].to_crs(epsg) + logging.info(f'Saving Network to GeoJSON in {output_dir}') + geojson.save_geodataframe(_network['nodes'], 'network_nodes', output_dir) + geojson.save_geodataframe(_network['links'], 'network_links', output_dir) + geojson.save_geodataframe(_network['nodes']['geometry'], 'network_nodes_geometry_only', output_dir) + geojson.save_geodataframe(_network['links']['geometry'], 'network_links_geometry_only', output_dir) + if self.schedule: + self.schedule.write_to_geojson(output_dir, epsg) + self.write_extras(output_dir) + + def to_geodataframe(self): + """ + Generates GeoDataFrames of the Network graph in Network's crs + :return: dict with keys 'nodes' and 'links', values are the GeoDataFrames corresponding to nodes and links + """ + return geojson.generate_geodataframes(self.graph) + + def to_encoded_geometry_dataframe(self): + _network = self.to_geodataframe() + _network['nodes'] = pd.DataFrame(_network['nodes']) + _network['links'] = pd.DataFrame(_network['links']) + _network['nodes']['geometry'] = _network['nodes']['geometry'].apply( + lambda row: [row.x, row.y]) + _network['links']['geometry'] = _network['links']['geometry'].apply( + lambda x: spatial.encode_shapely_linestring_to_polyline(x)) + return _network + + def write_to_csv(self, output_dir, gtfs_day='19700101'): + """ + Writes nodes and links tables for the Network and if there is a Schedule, exports it to a GTFS-like format. + :param output_dir: output directory + :param gtfs_day: defaults to 19700101, day which is represented in the Schedule + :return: + """ + network_csv_folder = os.path.join(output_dir, 'network') + schedule_csv_folder = os.path.join(output_dir, 'schedule') + persistence.ensure_dir(network_csv_folder) + csv_network = self.to_encoded_geometry_dataframe() + logging.info(f'Saving Network to CSV in {network_csv_folder}') + csv_network['nodes'].to_csv(os.path.join(network_csv_folder, 'nodes.csv')) + csv_network['links'].to_csv(os.path.join(network_csv_folder, 'links.csv')) + if self.schedule: + persistence.ensure_dir(schedule_csv_folder) + self.schedule.write_to_csv(schedule_csv_folder, gtfs_day) + self.write_extras(network_csv_folder) diff --git a/genet/exceptions.py b/genet/exceptions.py index 3791b378..21f330aa 100644 --- a/genet/exceptions.py +++ b/genet/exceptions.py @@ -6,6 +6,13 @@ class ScheduleElementGraphSchemaError(Exception): pass +class NetworkSchemaError(Exception): + """ + Raised when the Network or any of its' elements is missing data or is not arranged correctly + """ + pass + + class RouteInitialisationError(Exception): """ Raised when a genet.Route cannot be instantiated diff --git a/genet/inputs_handler/gtfs_reader.py b/genet/inputs_handler/gtfs_reader.py index a6cc3a21..91edfce4 100644 --- a/genet/inputs_handler/gtfs_reader.py +++ b/genet/inputs_handler/gtfs_reader.py @@ -2,8 +2,12 @@ import logging import os import shutil +import pandas as pd +import numpy as np +import networkx as nx from datetime import datetime, timedelta from genet.utils import spatial, persistence +import genet.modify.change_log as change_log from genet import variables @@ -34,7 +38,7 @@ def read_services_from_calendar(path, day): file = os.path.join(path, file_name) if ("calendar" in file) and (not ("dates" in file)): calendar_present = True - with open(file, mode='r') as infile: + with open(file, mode='r', encoding="utf-8-sig") as infile: reader = csv.DictReader(infile) for row in reader: if (int(day) in range(int(row['start_date']), int(row['end_date']))) and \ @@ -51,48 +55,31 @@ def read_services_from_calendar(path, day): def read_gtfs_to_db_like_tables(path): logging.info("Reading GTFS data into usable format") - trips_db = {} - stops_db = {} - routes_db = {} - stop_times_db = {} - stop_times = [] + trips_db = None + stops_db = None + routes_db = None + stop_times_db = None for file_name in os.listdir(path): file = os.path.join(path, file_name) if "stop_times" in file: logging.info("Reading stop times") - with open(file, mode='r') as infile: - reader = csv.DictReader(infile) - for row in reader: - stop_times.append(dict(row)) - if row['trip_id'] in stop_times_db: - stop_times_db[row['trip_id']].append(dict(row)) - else: - stop_times_db[row['trip_id']] = [dict(row)] + stop_times_db = pd.read_csv(file, dtype={'trip_id': str, 'stop_id': str}, low_memory=False) elif "stops" in file: logging.info("Reading stops") - with open(file, mode='r') as infile: - reader = csv.DictReader(infile) - for row in reader: - stops_db[row['stop_id']] = dict(row) + stops_db = pd.read_csv(file, dtype={'stop_id': str}) elif "trips" in file: logging.info("Reading trips") - with open(file, mode='r') as infile: - reader = csv.DictReader(infile) - for row in reader: - trips_db[row['trip_id']] = dict(row) + trips_db = pd.read_csv(file, dtype={'route_id': str, 'service_id': str, 'trip_id': str}) elif "routes" in file: logging.info("Reading routes") - with open(file, mode='r') as infile: - reader = csv.DictReader(infile) - for row in reader: - routes_db[row['route_id']] = dict(row) + routes_db = pd.read_csv(file, dtype={'route_id': str}) - return stop_times, stop_times_db, stops_db, trips_db, routes_db + return stop_times_db, stops_db, trips_db, routes_db def get_mode(route_type): @@ -105,7 +92,7 @@ def get_mode(route_type): return 'other' -def parse_db_to_schedule_dict(stop_times_db, stops_db, trips_db, route_db, services): +def gtfs_db_to_schedule_graph(stop_times_db, stops_db, trips_db, routes_db, services): def get_time(time): # return time as datetime.datetime, account for 24 in %H time_list = time.split(':') @@ -120,77 +107,117 @@ def get_time(time): else: return datetime.strptime(time, '%H:%M:%S') - def get_the_route(route_id, stops): - for i in range(len(schedule[route_id])): - route = schedule[route_id][i] - stops_already_in_schedule = route['stops'] - if stops == stops_already_in_schedule: - return i - return None - - def update_route_info(route_id, departure_time, i): - # assuming all trips sharing the same route have the same time offsets - schedule[route_id][i]['stops'] = stops - schedule[route_id][i]['s2_stops'] = s2_stops - - for stop_time in stop_times: - stop_arrival = get_time(stop_time['arrival_time']) - stop_departure = get_time(stop_time['departure_time']) - schedule[route_id][i]['arrival_offsets'].append(str(stop_arrival - departure_time)) - schedule[route_id][i]['departure_offsets'].append(str(stop_departure - departure_time)) - - schedule = {} - - v_id = 0 # generating some ids for vehicles - for trip_id, trip_val in trips_db.items(): - route_id = trip_val['route_id'] - if trip_val['service_id'] in services: - if route_id not in schedule: - schedule[route_id] = [] - route_val = route_db[route_id] - stop_times = stop_times_db[trip_id] - stops = [stop_time['stop_id'] for stop_time in stop_times] - s2_stops = [spatial.generate_index_s2( - lat=float(stops_db[stop]['stop_lat']), lng=float(stops_db[stop]['stop_lon'])) for stop in stops] - mode = get_mode(route_val['route_type']) - - if len(stops) > 1: - # get the route - i = get_the_route(route_id, stops) - vehicle_id = 'veh_{}_{}'.format(v_id, mode) - if i is not None: - # add this trip and it's departure time to already existing route - schedule[route_id][i]['trips']['trip_id'].append(trip_id) - schedule[route_id][i]['trips']['trip_departure_time'].append(stop_times[0]['arrival_time']) - schedule[route_id][i]['trips']['vehicle_id'].append(vehicle_id) - if i is None: - # fresh route - schedule[route_id].append({ - # route info - 'route_short_name': route_val['route_short_name'], - 'route_long_name': route_val['route_long_name'], - 'mode': mode, - 'route_color': '#{}'.format(route_val['route_color']), - # trip ids, their own departure times and vehicles - 'trips': { - 'trip_id': [trip_id], - 'trip_departure_time': [stop_times[0]['arrival_time']], - 'vehicle_id': [vehicle_id]}, - # stops and time offsets for each stop along the route - 'stops': [], - 'arrival_offsets': [], - 'departure_offsets': [] - }) - departure_time = get_time(stop_times[0]['arrival_time']) - update_route_info(route_id, departure_time, len(schedule[route_id]) - 1) - v_id += 1 - elif len(schedule[route_id]) == 0: - del schedule[route_id] - - return schedule - - -def read_to_dict_schedule_and_stopd_db(path: str, day: str): + def timedelta_to_hms(td): + return str(td).split('days')[-1].strip(' ') + + def generate_stop_sequence(group): + group = group.sort_values(by='stop_sequence') + # remove stops that are loopy (consecutively duplicated) + unique_stops_mask = group['stop_id'].shift() != group['stop_id'] + if not unique_stops_mask.all(): + logging.warning( + 'Your GTFS has (a) looooop edge(s)! A zero link between a node and itself, edge affected ' + '\nThis edge will not be considered for computation, the stop will be deleted and the ' + f'schedule will be changed. Affected stops: {group[~unique_stops_mask]["stop_id"].to_list()}') + group = group.loc[unique_stops_mask] + flattened = group.iloc[0, :][ + list(set(group.columns) - {'trip_id', 'stop_sequence', 'stop_id', 'arrival_time', 'departure_time'})] + departure_time = group.iloc[0, :]['arrival_time'] + flattened['trip_departure_time'] = departure_time.strftime("%H:%M:%S") + flattened['ordered_stops'] = group['stop_id'].to_list() + flattened['stops_str'] = ','.join(group['stop_id'].to_list()) + flattened['arrival_offsets'] = [timedelta_to_hms(t - departure_time) for t in group['arrival_time']] + flattened['departure_offsets'] = [timedelta_to_hms(t - departure_time) for t in group['departure_time']] + return flattened + + def generate_trips(group): + flattened = group.iloc[0, :][ + list(set(group.columns) - {'route_id', 'stops_str', 'trip_id', 'vehicle_id', 'trip_departure_time'})] + trip_id = group['trip_id'].to_list() + trip_departure_time = group['trip_departure_time'].to_list() + vehicle_id = group['vehicle_id'].to_list() + flattened['trips'] = { + 'trip_id': trip_id, + 'trip_departure_time': trip_departure_time, + 'vehicle_id': vehicle_id + } + return flattened + + def generate_routes(group): + service_id = group.iloc[0, :]['service_id'] + group['route_id'] = [f'{service_id}_{i}' for i in range(len(group))] + return group + + trips_db = trips_db[trips_db['service_id'].isin(services)] + df = trips_db[['route_id', 'trip_id']].merge( + routes_db[['route_id', 'route_type', 'route_short_name', 'route_long_name', 'route_color']], on='route_id', + how='left') + df['mode'] = df['route_type'].apply(lambda x: get_mode(x)) + df = df.merge(stop_times_db[['trip_id', 'stop_id', 'arrival_time', 'departure_time', 'stop_sequence']], + on='trip_id', how='left') + df['arrival_time'] = df['arrival_time'].apply(lambda x: get_time(x)) + df['departure_time'] = df['departure_time'].apply(lambda x: get_time(x)) + + df = df.groupby('trip_id').apply(generate_stop_sequence).reset_index() + # drop stop sequences that are single stops + df = df[df['ordered_stops'].str.len() > 1] + df['vehicle_id'] = [f'veh_{i}' for i in range(len(df))] + df = df.groupby(['route_id', 'stops_str']).apply(generate_trips).reset_index() + df = df.drop('stops_str', axis=1) + df['service_id'] = df['route_id'].astype(str) + df = df.groupby(['service_id']).apply(generate_routes) + + g = nx.DiGraph(name='Schedule graph') + g.graph['crs'] = {'init': 'epsg:4326'} + g.graph['route_to_service_map'] = df.set_index('route_id')['service_id'].T.to_dict() + g.graph['service_to_route_map'] = df.groupby('service_id')['route_id'].apply(list).to_dict() + g.graph['change_log'] = change_log.ChangeLog() + + df['id'] = df['route_id'] + g.graph['routes'] = df.set_index('route_id').T.to_dict() + df['id'] = df['service_id'] + df = df.rename(columns={'route_short_name': 'name'}) + g.graph['services'] = df[['service_id', 'id', 'name']].groupby('service_id').first().T.to_dict() + + # finally nodes + stops = pd.DataFrame({ + col: np.repeat(df[col].values, df['ordered_stops'].str.len()) + for col in {'route_id', 'service_id'}} + ).assign(stop_id=np.concatenate(df['ordered_stops'].values)) + stop_groups = stops.groupby('stop_id') + stops = set(stop_groups.groups) + g.add_nodes_from(stops) + stops_db = stops_db.rename(columns={'stop_lat': 'lat', 'stop_lon': 'lon', 'stop_name': 'name'}) + stops_db['id'] = stops_db['stop_id'] + stops_db['x'] = stops_db['lon'] + stops_db['y'] = stops_db['lat'] + stops_db['epsg'] = 'epsg:4326' + stops_db['s2_id'] = stops_db.apply( + lambda x: spatial.generate_index_s2(lat=float(x['lat']), lng=float(x['lon'])), axis=1) + nx.set_node_attributes(g, stops_db[stops_db['stop_id'].isin(stops)].set_index('stop_id').T.to_dict()) + nx.set_node_attributes(g, pd.DataFrame(stop_groups['route_id'].apply(set)).rename( + columns={'route_id': 'routes'}).T.to_dict()) + nx.set_node_attributes(g, pd.DataFrame(stop_groups['service_id'].apply(set)).rename( + columns={'service_id': 'services'}).T.to_dict()) + + # and edges + df['ordered_stops'] = df['ordered_stops'].apply(lambda x: list(zip(x[:-1], x[1:]))) + stop_cols = np.concatenate(df['ordered_stops'].values) + edges = pd.DataFrame({ + col: np.repeat(df[col].values, df['ordered_stops'].str.len()) + for col in {'route_id', 'service_id'}} + ).assign(from_stop=stop_cols[:, 0], + to_stop=stop_cols[:, 1]) + edge_groups = edges.groupby(['from_stop', 'to_stop']) + g.add_edges_from(edge_groups.groups) + nx.set_edge_attributes(g, pd.DataFrame(edge_groups['route_id'].apply(set)).rename( + columns={'route_id': 'routes'}).T.to_dict()) + nx.set_edge_attributes(g, pd.DataFrame(edge_groups['service_id'].apply(set)).rename( + columns={'service_id': 'services'}).T.to_dict()) + return g + + +def read_gtfs_to_schedule_graph(path: str, day: str): if persistence.is_zip(path): gtfs_path = os.path.join(os.getcwd(), 'tmp') if not os.path.exists(gtfs_path): @@ -203,10 +230,9 @@ def read_to_dict_schedule_and_stopd_db(path: str, day: str): gtfs_path = path services = read_services_from_calendar(gtfs_path, day=day) - stop_times, stop_times_db, stops_db, trips_db, routes_db = read_gtfs_to_db_like_tables(gtfs_path) - schedule = parse_db_to_schedule_dict(stop_times_db, stops_db, trips_db, routes_db, services) + stop_times_db, stops_db, trips_db, routes_db = read_gtfs_to_db_like_tables(gtfs_path) + schedule_graph = gtfs_db_to_schedule_graph(stop_times_db, stops_db, trips_db, routes_db, services) if persistence.is_zip(path): shutil.rmtree(os.path.dirname(gtfs_path)) - - return schedule, stops_db + return schedule_graph diff --git a/genet/inputs_handler/read.py b/genet/inputs_handler/read.py new file mode 100644 index 00000000..25867dc4 --- /dev/null +++ b/genet/inputs_handler/read.py @@ -0,0 +1,330 @@ +import ast +import pandas as pd +import geopandas as gpd +import networkx as nx +import json +import logging +import genet.core as core +import genet.inputs_handler.gtfs_reader as gtfs_reader +import genet.inputs_handler.osm_reader as osm_reader +import genet.utils.parallel as parallel +import genet.inputs_handler.matsim_reader as matsim_reader +import genet.schedule_elements as schedule_elements +import genet.utils.spatial as spatial +import genet.modify.change_log as change_log +from genet.exceptions import NetworkSchemaError + + +def read_matsim(path_to_network: str, epsg: str, path_to_schedule: str = None, path_to_vehicles: str = None): + """ + Reads MATSim's network.xml to genet.Network object and if give, also the schedule.xml and vehicles.xml into + genet.Schedule object, part of the genet.Network object. + :param path_to_network: path to MATSim's network.xml file + :param path_to_schedule: path to MATSim's schedule.xml file, optional + :param path_to_vehicles: path to MATSim's vehicles.xml file, optional, expected to be passed with a schedule + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + n = read_matsim_network(path_to_network=path_to_network, epsg=epsg) + if path_to_schedule: + n.schedule = read_matsim_schedule( + path_to_schedule=path_to_schedule, path_to_vehicles=path_to_vehicles, epsg=epsg) + return n + + +def read_matsim_network(path_to_network: str, epsg: str): + """ + Reads MATSim's network.xml to genet.Network object + :param path_to_network: path to MATSim's network.xml file + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + n = core.Network(epsg=epsg) + n.graph, n.link_id_mapping, duplicated_nodes, duplicated_links = \ + matsim_reader.read_network(path_to_network, n.transformer) + n.graph.graph['name'] = 'Network graph' + n.graph.graph['crs'] = {'init': n.epsg} + if 'simplified' not in n.graph.graph: + n.graph.graph['simplified'] = False + + for node_id, duplicated_node_attribs in duplicated_nodes.items(): + for duplicated_node_attrib in duplicated_node_attribs: + n.change_log.remove( + object_type='node', + object_id=node_id, + object_attributes=duplicated_node_attrib + ) + for link_id, reindexed_duplicated_links in duplicated_links.items(): + for duplicated_link in reindexed_duplicated_links: + n.change_log.modify( + object_type='link', + old_id=link_id, + old_attributes=n.link(duplicated_link), + new_id=duplicated_link, + new_attributes=n.link(duplicated_link) + ) + return n + + +def read_matsim_schedule(path_to_schedule: str, epsg: str, path_to_vehicles: str = None): + """ + Reads MATSim's schedule.xml (and possibly vehicles.xml) to genet.Schedule object + :param path_to_schedule: path to MATSim's schedule.xml file, + :param path_to_vehicles: path to MATSim's vehicles.xml file, optional but encouraged + :param epsg: projection for the schedule, e.g. 'epsg:27700' + :return: genet.Schedule object + """ + services, minimal_transfer_times = matsim_reader.read_schedule(path_to_schedule, epsg) + if path_to_vehicles: + vehicles, vehicle_types = matsim_reader.read_vehicles(path_to_vehicles) + matsim_schedule = schedule_elements.Schedule( + services=services, epsg=epsg, vehicles=vehicles, vehicle_types=vehicle_types) + else: + matsim_schedule = schedule_elements.Schedule(services=services, epsg=epsg) + matsim_schedule.minimal_transfer_times = minimal_transfer_times + return matsim_schedule + + +def read_json(network_path: str, epsg: str, schedule_path: str = ''): + """ + Reads Network and, if passed, Schedule JSON files in to a genet.Network + :param network_path: path to json network file + :param schedule_path: path to json schedule file + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + n = read_json_network(network_path, epsg) + if schedule_path: + n.schedule = read_json_schedule(schedule_path, epsg) + return n + + +def read_geojson_network(nodes_path: str, links_path: str, epsg: str): + """ + Reads Network graph from JSON file. + :param nodes_path: path to geojson network nodes file + :param links_path: path to geojson network links file + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + logging.info(f'Reading Network nodes from {nodes_path}') + nodes = gpd.read_file(nodes_path) + nodes = nodes.drop('geometry', axis=1) + nodes['id'] = nodes['id'].astype(int).astype(str) + nodes = nodes.set_index('id', drop=False) + if 'index' in nodes.columns: + nodes = nodes.drop('index', axis=1) + + logging.info(f'Reading Network links from {links_path}') + links = gpd.read_file(links_path).to_crs(epsg) + links['modes'] = links['modes'].apply(lambda x: set(x.split(','))) + links['id'] = links['id'].astype(int).astype(str) + links = links.set_index('id', drop=False) + if 'index' in links.columns: + links = links.drop('index', axis=1) + + n = core.Network(epsg=epsg) + n.add_nodes(nodes.T.to_dict()) + n.add_links(links.T.to_dict()) + n.change_log = change_log.ChangeLog() + return n + + +def read_json_network(network_path: str, epsg: str): + """ + Reads Network graph from JSON file. + :param network_path: path to json or geojson network file + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + logging.info(f'Reading Network from {network_path}') + with open(network_path) as json_file: + json_data = json.load(json_file) + for node, data in json_data['nodes'].items(): + try: + del data['geometry'] + except KeyError: + pass + + for link, data in json_data['links'].items(): + try: + data['geometry'] = spatial.decode_polyline_to_shapely_linestring(data['geometry']) + except KeyError: + pass + try: + data['modes'] = set(data['modes'].split(',')) + except KeyError: + pass + + n = core.Network(epsg=epsg) + n.add_nodes(json_data['nodes']) + n.add_links(json_data['links']) + n.change_log = change_log.ChangeLog() + return n + + +def read_json_schedule(schedule_path: str, epsg: str): + """ + Reads Schedule from a JSON file. + :param schedule_path: path to json or geojson schedule file + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Schedule object + """ + logging.info(f'Reading Schedule from {schedule_path}') + with open(schedule_path) as json_file: + json_data = json.load(json_file) + + for service_id, service_data in json_data['schedule']['services'].items(): + routes = [] + for route_id, route_data in service_data['routes'].items(): + stops = route_data.pop('ordered_stops') + route_data['stops'] = [schedule_elements.Stop(**json_data['schedule']['stops'][stop], epsg=epsg) for stop in + stops] + routes.append(schedule_elements.Route(**route_data)) + service_data['routes'] = routes + + services = [schedule_elements.Service(**service_data) for service_id, service_data in + json_data['schedule']['services'].items()] + + s = schedule_elements.Schedule( + epsg=epsg, + services=services, + vehicles=json_data['vehicles']['vehicles'], + vehicle_types=json_data['vehicles']['vehicle_types']) + if 'minimal_transfer_times' in json_data['schedule']: + s.minimal_transfer_times = json_data['schedule']['minimal_transfer_times'] + return s + + +def _literal_eval_col(df_col): + try: + df_col = df_col.apply(lambda x: ast.literal_eval(x)) + except KeyError: + pass + return df_col + + +def read_csv(path_to_network_nodes: str, path_to_network_links: str, epsg: str): + """ + Reads CSV data into a genet.Network object + :param path_to_network_nodes: CSV file describing nodes. Should at least include columns: + - id: unique ID for the node + - x: spatial coordinate in given epsg + - y: spatial coordinate in given epsg + :param path_to_network_links: CSV file describing links. + Should at least include columns: + - from - source Node ID + - to - target Node ID + Optional columns, but strongly encouraged + - id - unique ID for link + - length - link length in metres + - freespeed - meter/seconds speed + - capacity - vehicles/hour + - permlanes - number of lanes + - modes - set of modes + :param epsg: projection for the network, e.g. 'epsg:27700' + :return: genet.Network object + """ + logging.info(f'Reading nodes from {path_to_network_nodes}') + df_nodes = pd.read_csv(path_to_network_nodes) + if {'index', 'id'}.issubset(set(df_nodes.columns)): + df_nodes = df_nodes.drop('index', axis=1) + elif 'id' not in df_nodes.columns: + raise NetworkSchemaError('Expected `id` column in the nodes.csv is missing. This need to be the IDs to which ' + 'links.csv refers to in `from` and `to` columns.') + df_nodes['id'] = df_nodes['id'].astype(int).astype(str) + df_nodes = df_nodes.set_index('id', drop=False) + try: + df_nodes = df_nodes.drop('geometry', axis=1) + except KeyError: + pass + + logging.info(f'Reading links from {path_to_network_nodes}') + df_links = pd.read_csv(path_to_network_links) + if {'index', 'id'}.issubset(set(df_links.columns)): + df_links = df_links.drop('index', axis=1) + elif 'id' not in df_links.columns: + if 'index' in df_links.columns: + if not df_links['index'].duplicated().any(): + df_links['id'] = df_links['index'] + else: + df_links = df_links.drop('index', axis=1) + else: + df_links['id'] = range(len(df_links)) + + df_links['id'] = df_links['id'].astype(int).astype(str) + df_links['from'] = df_links['from'].astype(int).astype(str) + df_links['to'] = df_links['to'].astype(int).astype(str) + df_links = df_links.set_index('id', drop=False) + # recover encoded geometry + try: + df_links['geometry'] = df_links['geometry'].apply(lambda x: spatial.decode_polyline_to_shapely_linestring(x)) + except KeyError: + pass + df_links['attributes'] = _literal_eval_col(df_links['attributes']) + df_links['modes'] = _literal_eval_col(df_links['modes']) + + n = core.Network(epsg=epsg) + n.add_nodes(df_nodes.T.to_dict()) + n.add_links(df_links.T.to_dict()) + n.change_log = change_log.ChangeLog() + return n + + +def read_gtfs(path, day, epsg=None): + """ + Reads from GTFS. The resulting services will not have network routes. Assumed to be in lat lon epsg:4326. + :param path: to GTFS folder or a zip file + :param day: 'YYYYMMDD' to use from the gtfs + :param epsg: projection for the output Schedule, e.g. 'epsg:27700'. If not provided, the Schedule remains in + epsg:4326 + :return: + """ + logging.info(f'Reading GTFS from {path}') + schedule_graph = gtfs_reader.read_gtfs_to_schedule_graph(path, day) + s = schedule_elements.Schedule(epsg='epsg:4326', _graph=schedule_graph) + if epsg is not None: + s.reproject(new_epsg=epsg) + return s + + +def read_osm(osm_file_path, osm_read_config, num_processes: int = 1, epsg=None): + """ + Reads OSM data into a graph of the Network object + :param osm_file_path: path to .osm or .osm.pbf file + :param osm_read_config: config file (see configs folder in genet for examples) which informs for example which + highway types to read (in case of road network) and what modes to assign to them + :param num_processes: number of processes to split parallelisable operations across + :param epsg: projection for the output Network, e.g. 'epsg:27700'. If not provided, defaults to epsg:4326 + :return: genet.Network object + """ + if epsg is None: + epsg = 'epsg:4326' + config = osm_reader.Config(osm_read_config) + n = core.Network(epsg) + nodes, edges = osm_reader.generate_osm_graph_edges_from_file( + osm_file_path, config, num_processes) + + nodes_and_attributes = parallel.multiprocess_wrap( + data=nodes, + split=parallel.split_dict, + apply=osm_reader.generate_graph_nodes, + combine=parallel.combine_dict, + epsg=epsg + ) + reindexing_dict, nodes_and_attributes = n.add_nodes(nodes_and_attributes) + + edges_attributes = parallel.multiprocess_wrap( + data=edges, + split=parallel.split_list, + apply=osm_reader.generate_graph_edges, + combine=parallel.combine_list, + reindexing_dict=reindexing_dict, + nodes_and_attributes=nodes_and_attributes, + config_path=osm_read_config + ) + n.add_edges(edges_attributes) + + logging.info('Deleting isolated nodes which have no edges.') + n.remove_nodes(list(nx.isolates(n.graph))) + return n diff --git a/genet/outputs_handler/geojson.py b/genet/outputs_handler/geojson.py index 999dc8e5..dd63e16d 100644 --- a/genet/outputs_handler/geojson.py +++ b/genet/outputs_handler/geojson.py @@ -1,8 +1,8 @@ import os import logging -import osmnx as ox -from networkx import MultiDiGraph from itertools import chain +from shapely.geometry import Point, LineString +import geopandas as gpd import genet.use.schedule as use_schedule import genet.utils.persistence as persistence import genet.outputs_handler.sanitiser as sanitiser @@ -25,47 +25,53 @@ def setify(x): def generate_geodataframes(graph): - if not isinstance(graph, MultiDiGraph): - graph = MultiDiGraph(graph) - gdf_nodes, gdf_links = ox.utils_graph.graph_to_gdfs(graph) - gdf_nodes = gdf_nodes.to_crs("EPSG:4326") - gdf_links = gdf_links.to_crs("EPSG:4326") - return gdf_nodes, gdf_links + def line_geometry(): + from_node = nodes.loc[_u, :] + to_node = nodes.loc[_v, :] + return LineString( + [(float(from_node['x']), float(from_node['y'])), (float(to_node['x']), float(to_node['y']))]) + + crs = graph.graph['crs']['init'] + + node_ids, data = zip(*graph.nodes(data=True)) + geometry = [Point(float(d['x']), float(d['y'])) for d in data] + nodes = gpd.GeoDataFrame(data, index=node_ids, crs=crs, geometry=geometry) + nodes.index = nodes.index.set_names(['index']) + + u, v, data = zip(*graph.edges(data=True)) + geometry = [] + for _u, _v, d in zip(u, v, data): + try: + geom = d['geometry'] + except KeyError: + geom = line_geometry() + geometry.append(geom) + links = gpd.GeoDataFrame(data, crs=crs, geometry=geometry) + links['u'] = u + links['v'] = v + if 'id' in links.columns: + links = links.set_index('id', drop=False) + links.index = links.index.set_names(['index']) + return {'nodes': nodes, 'links': links} -def save_geodataframe(gdf, filename, output_dir): + +def save_geodataframe(gdf, filename, output_dir, include_shp_files=False): if not gdf.empty: gdf = sanitiser.sanitise_geodataframe(gdf) persistence.ensure_dir(output_dir) gdf.to_file(os.path.join(output_dir, f'{filename}.geojson'), driver='GeoJSON') for col in [col for col in gdf.columns if is_datetime(gdf[col])]: gdf[col] = gdf[col].astype(str) - shp_files = os.path.join(output_dir, 'shp_files') - persistence.ensure_dir(shp_files) - gdf.to_file(os.path.join(shp_files, f'{filename}.shp')) - - -def save_network_to_geojson(n, output_dir): - graph_nodes, graph_links = generate_geodataframes(n.graph) - - logging.info(f'Saving network graph nodes and links geojsons to {output_dir}') - save_geodataframe(graph_nodes, 'network_nodes', output_dir) - save_geodataframe(graph_links, 'network_links', output_dir) - save_geodataframe(graph_nodes['geometry'], 'network_nodes_geometry_only', output_dir) - save_geodataframe(graph_links['geometry'], 'network_links_geometry_only', output_dir) - - if n.schedule: - schedule_nodes, schedule_links = generate_geodataframes(MultiDiGraph(n.schedule.graph())) - logging.info(f'Saving schedule graph nodes and links geojsons to {output_dir}') - save_geodataframe(schedule_nodes, 'schedule_nodes', output_dir) - save_geodataframe(schedule_links, 'schedule_links', output_dir) - save_geodataframe(schedule_nodes['geometry'], 'schedule_nodes_geometry_only', output_dir) - save_geodataframe(schedule_links['geometry'], 'schedule_links_geometry_only', output_dir) + if include_shp_files: + shp_files = os.path.join(output_dir, 'shp_files') + persistence.ensure_dir(shp_files) + gdf.to_file(os.path.join(shp_files, f'{filename}.shp')) -def generate_standard_outputs_for_schedule(schedule, output_dir, gtfs_day='19700101'): +def generate_standard_outputs_for_schedule(schedule, output_dir, gtfs_day='19700101', include_shp_files=False): logging.info('Generating geojson standard outputs for schedule') - schedule_nodes, schedule_links = generate_geodataframes(schedule.graph()) + schedule_links = schedule.to_geodataframe()['links'].to_crs("epsg:4326") df = schedule.route_trips_with_stops_to_dataframe(gtfs_day=gtfs_day) df_all_modes_vph = None @@ -78,7 +84,9 @@ def generate_standard_outputs_for_schedule(schedule, output_dir, gtfs_day='19700 save_geodataframe( df_vph, filename=f'vehicles_per_hour_{mode}', - output_dir=vph_dir) + output_dir=vph_dir, + include_shp_files=include_shp_files + ) if df_all_modes_vph is None: df_vph['mode'] = mode @@ -88,28 +96,36 @@ def generate_standard_outputs_for_schedule(schedule, output_dir, gtfs_day='19700 df_all_modes_vph = df_all_modes_vph.append(df_vph) logging.info(f'Generating schedule graph for {mode}') - schedule_subgraph_nodes, schedule_subgraph_links = generate_geodataframes( + schedule_subgraph = generate_geodataframes( schedule.subgraph(graph_mode_map[mode])) save_geodataframe( - schedule_subgraph_links, + schedule_subgraph['links'].to_crs("epsg:4326"), filename=f'schedule_subgraph_links_{mode}', - output_dir=subgraph_dir) + output_dir=subgraph_dir, + include_shp_files=include_shp_files + ) save_geodataframe( - schedule_subgraph_nodes, + schedule_subgraph['nodes'].to_crs("epsg:4326"), filename=f'schedule_subgraph_nodes_{mode}', - output_dir=subgraph_dir) + output_dir=subgraph_dir, + include_shp_files=include_shp_files + ) logging.info('Saving vehicles per hour for all PT modes') save_geodataframe( df_all_modes_vph, filename='vehicles_per_hour_all_modes', - output_dir=vph_dir) + output_dir=vph_dir, + include_shp_files=include_shp_files + ) logging.info('Saving vehicles per hour for all PT modes for selected hour slices') for h in [7, 8, 9, 13, 16, 17, 18]: save_geodataframe( df_all_modes_vph[df_all_modes_vph['hour'].dt.hour == h], filename=f'vph_all_modes_within_{h-1}:30-{h}:30', - output_dir=vph_dir) + output_dir=vph_dir, + include_shp_files=include_shp_files + ) logging.info('Generating csv for vehicles per hour for each service') use_schedule.vehicles_per_hour( @@ -139,11 +155,11 @@ def generate_standard_outputs_for_schedule(schedule, output_dir, gtfs_day='19700 os.path.join(output_dir, 'trips_per_day_per_route_aggregated_per_stop_name_pair.csv')) -def generate_standard_outputs(n, output_dir, gtfs_day='19700101'): +def generate_standard_outputs(n, output_dir, gtfs_day='19700101', include_shp_files=False): logging.info(f'Generating geojson outputs for the entire network in {output_dir}') - save_network_to_geojson(n, output_dir) + n.write_to_geojson(output_dir) - graph_nodes, graph_links = generate_geodataframes(n.graph) + graph_links = n.to_geodataframe()['links'].to_crs("epsg:4326") logging.info('Generating geojson outputs for car/driving modal subgraph') graph_output_dir = os.path.join(output_dir, 'graph') @@ -153,7 +169,8 @@ def generate_standard_outputs(n, output_dir, gtfs_day='19700101'): save_geodataframe( gdf_car[[attribute, 'geometry', 'id']], filename=f'car_{attribute}_subgraph', - output_dir=graph_output_dir) + output_dir=graph_output_dir, + include_shp_files=include_shp_files) except KeyError: logging.warning(f'Your network is missing a vital attribute {attribute}') @@ -167,7 +184,9 @@ def generate_standard_outputs(n, output_dir, gtfs_day='19700101'): save_geodataframe( graph_links[graph_links['id'].isin(tag_links)], filename=f'car_osm_highway_{tag}', - output_dir=graph_output_dir) + output_dir=graph_output_dir, + include_shp_files=include_shp_files + ) for mode in n.modes(): logging.info(f'Generating geometry-only geojson outputs for {mode} modal subgraph') @@ -175,11 +194,15 @@ def generate_standard_outputs(n, output_dir, gtfs_day='19700101'): save_geodataframe( gdf[['geometry', 'id']], filename=f'subgraph_geometry_{mode}', - output_dir=os.path.join(graph_output_dir, 'geometry_only_subgraphs')) + output_dir=os.path.join(graph_output_dir, 'geometry_only_subgraphs'), + include_shp_files=include_shp_files + ) # schedule outputs if n.schedule: generate_standard_outputs_for_schedule( n.schedule, output_dir=os.path.join(output_dir, 'schedule'), - gtfs_day=gtfs_day) + gtfs_day=gtfs_day, + include_shp_files=include_shp_files + ) diff --git a/genet/outputs_handler/sanitiser.py b/genet/outputs_handler/sanitiser.py index ea326dc2..ab8eb944 100644 --- a/genet/outputs_handler/sanitiser.py +++ b/genet/outputs_handler/sanitiser.py @@ -32,4 +32,15 @@ def sanitise_dictionary_for_xml(d): d[k] = sanitise_list(v) if isinstance(v, (int, float)): d[k] = str(v) + if isinstance(v, dict): + sanitise_dictionary_for_xml(v) + return d + + +def sanitise_dictionary(d): + for k, v in d.items(): + if isinstance(v, (set, list)): + d[k] = sanitise_list(v) + if isinstance(v, dict): + sanitise_dictionary(v) return d diff --git a/genet/schedule_elements.py b/genet/schedule_elements.py index 51d5b643..a15ac214 100644 --- a/genet/schedule_elements.py +++ b/genet/schedule_elements.py @@ -8,6 +8,7 @@ import io import yaml import pkgutil +import json from datetime import datetime from pandas import DataFrame, Series from copy import deepcopy @@ -18,8 +19,6 @@ import genet.utils.plot as plot import genet.utils.spatial as spatial import genet.utils.dict_support as dict_support -import genet.inputs_handler.matsim_reader as matsim_reader -import genet.inputs_handler.gtfs_reader as gtfs_reader import genet.outputs_handler.matsim_xml_writer as matsim_xml_writer import genet.utils.persistence as persistence import genet.utils.graph_operations as graph_operations @@ -576,7 +575,7 @@ def is_exact(self, other): same_departure_offsets = self.departure_offsets == other.departure_offsets statement = same_route_name and same_mode and same_stops and same_trips and same_arrival_offsets \ - and same_departure_offsets + and same_departure_offsets # noqa: E127 return statement def isin_exact(self, routes: list): @@ -831,6 +830,7 @@ def split_graph(self): is a list of the same length as routes, each item is a set of graph edges and corresponds to the item in routes list in that same index """ + def route_overlap_condition(graph_edge_group): edges_in_common = bool(graph_edge_group & route_edges) if edges_in_common: @@ -1803,7 +1803,7 @@ def _find_stops_on_geojson(self, geojson_input): return self._find_stops_on_shapely_geometry(shapely_input) def _find_stops_on_shapely_geometry(self, shapely_input): - stops_gdf = gngeojson.generate_geodataframes(self._graph)[0] + stops_gdf = self.to_geodataframe()['nodes'].to_crs("epsg:4326") return list(stops_gdf[stops_gdf.intersects(shapely_input)].index) def _find_stops_on_s2_geometry(self, s2_input): @@ -2167,7 +2167,7 @@ def is_valid_schedule(self, return_reason=False): def generate_validation_report(self): return schedule_validation.generate_validation_report(schedule=self) - def generate_standard_outputs(self, output_dir, gtfs_day='19700101'): + def generate_standard_outputs(self, output_dir, gtfs_day='19700101', include_shp_files=False): """ Generates geojsons that can be used for generating standard kepler visualisations. These can also be used for validating network for example inspecting link capacity, freespeed, number of lanes, @@ -2177,59 +2177,167 @@ def generate_standard_outputs(self, output_dir, gtfs_day='19700101'): defaults to 1970/01/01 otherwise :return: None """ - gngeojson.generate_standard_outputs_for_schedule(self, output_dir, gtfs_day) + gngeojson.generate_standard_outputs_for_schedule(self, output_dir, gtfs_day, include_shp_files) logging.info('Finished generating standard outputs. Zipping folder.') persistence.zip_folder(output_dir) - def read_matsim_schedule(self, path_to_schedule, path_to_vehicles=''): - services, minimal_transfer_times = matsim_reader.read_schedule(path_to_schedule, self.epsg) - if path_to_vehicles: - vehicles, vehicle_types = matsim_reader.read_vehicles(path_to_vehicles) - matsim_schedule = self.__class__( - services=services, epsg=self.epsg, vehicles=vehicles, vehicle_types=vehicle_types) - else: - matsim_schedule = self.__class__(services=services, epsg=self.epsg) - matsim_schedule.minimal_transfer_times = minimal_transfer_times - self.add(matsim_schedule) + def write_to_matsim(self, output_dir): + persistence.ensure_dir(output_dir) + matsim_xml_writer.write_matsim_schedule(output_dir, self) + matsim_xml_writer.write_vehicles(output_dir, self.vehicles, self.vehicle_types) + self.write_extras(output_dir) + + def write_extras(self, output_dir): + self.change_log().export(os.path.join(output_dir, 'schedule_change_log.csv')) - def read_matsim_vehicles(self, path_to_vehicles): - vehicles, vehicle_types = matsim_reader.read_vehicles(path_to_vehicles) - self.update_vehicles(vehicles, vehicle_types) + def to_geodataframe(self): + """ + Generates GeoDataFrames of the Schedule graph in Schedule's crs + :return: dict with keys 'nodes' and 'links', values are the GeoDataFrames corresponding to nodes and edges + """ + return gngeojson.generate_geodataframes(self._graph) - def read_gtfs_schedule(self, path, day): + def to_json(self): + stop_keys = {d.name for d in graph_operations.get_attribute_schema(self._graph.nodes(data=True)).children} + stop_keys = stop_keys - {'routes', 'services', 'additional_attributes', 'epsg'} + stops = self.stop_attribute_data(keys=stop_keys) + services = self._graph.graph['services'] + for service_id, data in services.items(): + data['routes'] = {route_id: self._graph.graph['routes'][route_id] for route_id in + self._graph.graph['service_to_route_map'][service_id]} + d = {'stops': stops.T.to_dict(), 'services': services} + if self.minimal_transfer_times: + d['minimal_transfer_times'] = self.minimal_transfer_times + return {'schedule': d, 'vehicles': {'vehicle_types': self.vehicle_types, 'vehicles': self.vehicles}} + + def write_to_json(self, output_dir): """ - Reads from GTFS. The resulting services will not have route lists. Assumes to be in lat lon epsg:4326 - :param path: to GTFS folder or a zip file - :param day: 'YYYYMMDD' to use form the gtfs + Writes Schedule to a single JSON file with stops, services, vehicles and minimum transfer times (if applicable) + :param output_dir: output directory :return: """ - schedule, stops_db = gtfs_reader.read_to_dict_schedule_and_stopd_db(path, day) - services = [] - for key, routes in schedule.items(): - routes_list = [] - for route in routes: - r = Route( - route_short_name=route['route_short_name'], - mode=route['mode'], - stops=[Stop(id=id, x=stops_db[id]['stop_lon'], y=stops_db[id]['stop_lat'], epsg='epsg:4326') for id - in - route['stops']], - trips=route['trips'], - arrival_offsets=route['arrival_offsets'], - departure_offsets=route['departure_offsets'] - ) - routes_list.append(r) - services.append(Service(id=key, routes=routes_list)) - - # add services rather than creating new object (in case there are already services present) - to_add = self.__class__('epsg:4326', services) - self.add(to_add) + persistence.ensure_dir(output_dir) + logging.info(f'Saving Schedule to JSON in {output_dir}') + with open(os.path.join(output_dir, 'schedule.json'), 'w') as outfile: + json.dump(self.to_json(), outfile) + self.write_extras(output_dir) - def write_to_matsim(self, output_dir): + def write_to_geojson(self, output_dir, epsg): + """ + Writes Schedule graph to nodes and edges geojson files. + :param output_dir: output directory + :param epsg: projection if the geometry is to be reprojected, defaults to own projection + :return: + """ persistence.ensure_dir(output_dir) - matsim_xml_writer.write_matsim_schedule(output_dir, self) - matsim_xml_writer.write_vehicles(output_dir, self.vehicles, self.vehicle_types) - self.change_log().export(os.path.join(output_dir, 'schedule_change_log.csv')) + _gdfs = self.to_geodataframe() + if epsg is not None: + _gdfs['nodes'] = _gdfs['nodes'].to_crs(epsg) + _gdfs['links'] = _gdfs['links'].to_crs(epsg) + logging.info(f'Saving Schedule to GeoJSON in {output_dir}') + gngeojson.save_geodataframe(_gdfs['nodes'], 'schedule_nodes', output_dir) + gngeojson.save_geodataframe(_gdfs['links'], 'schedule_links', output_dir) + gngeojson.save_geodataframe(_gdfs['nodes']['geometry'], 'schedule_nodes_geometry_only', output_dir) + gngeojson.save_geodataframe(_gdfs['links']['geometry'], 'schedule_links_geometry_only', output_dir) + self.write_extras(output_dir) + + def to_gtfs(self, gtfs_day, mode_to_route_type: dict = None): + """ + Transforms Schedule in to GTFS-like format. It's not full GTFS as it only represents one day, misses a lot + of optional data and does not include `agency.txt` required file. Produces 'stops', 'routes', 'trips', + 'stop_times', 'calendar' tables. + :param gtfs_day: day used for GTFS when creating the network in YYYYMMDD format + :param mode_to_route_type: PT modes in Route objects to route type code by default uses + https://developers.google.com/transit/gtfs/reference#routestxt + { + "tram": 0, "subway": 1, "rail": 2, "bus": 3, "ferry": 4, "cablecar": 5, "gondola": 6, "funicular": 7 + } + Reference for extended mode types: + https://developers.google.com/transit/gtfs/reference/extended-route-types + + :return: Dictionary, keys are the names of the tables e.g. `stops` for the `stops.txt` file, values are + pandas.DataFrame tables. + """ + stops = self.stop_attribute_data( + keys=['id', 'name', 'lat', 'lon', 'stop_code', 'stop_desc', 'zone_id', 'stop_url', 'location_type', + 'parent_station', 'stop_timezone', 'wheelchair_boarding', 'level_id', 'platform_code']) + stops = stops.rename(columns={'id': 'stop_id', 'name': 'stop_name', 'lat': 'stop_lat', 'lon': 'stop_lon'}) + + routes = self.route_attribute_data( + keys=['id', 'route_short_name', 'route_long_name', 'mode', 'agency_id', 'route_desc', 'route_url', + 'route_type', 'route_color', 'route_text_color', 'route_sort_order', 'continuous_pickup', + 'continuous_drop_off']) + if mode_to_route_type is None: + mode_to_route_type = { + "tram": 0, "subway": 1, "rail": 2, "bus": 3, "ferry": 4, "cablecar": 5, "gondola": 6, "funicular": 7 + } + routes.loc[routes['route_type'].isna(), 'route_type'] = routes.loc[routes['route_type'].isna(), 'mode'].map( + mode_to_route_type) + routes['route_id'] = routes['id'].map(self._graph.graph['route_to_service_map']) + routes = routes.drop(['mode', 'id'], axis=1) + routes = routes.groupby('route_id').first().reset_index() + + trips = self.route_attribute_data(keys=['id', 'ordered_stops', 'arrival_offsets', 'departure_offsets']) + trips = trips.merge(self.route_trips_to_dataframe(), left_on='id', right_on='route_id') + trips['route_id'] = trips['service_id'] + + # expand the frame for stops and offsets to get stop times + trips['stop_sequence'] = trips['ordered_stops'].apply(lambda x: list(range(len(x)))) + trips['departure_offsets'] = trips['departure_offsets'].apply(lambda x: list(map(use_schedule.get_offset, x))) + trips['arrival_offsets'] = trips['arrival_offsets'].apply(lambda x: list(map(use_schedule.get_offset, x))) + stop_times = DataFrame({ + col: np.repeat(trips[col].values, trips['ordered_stops'].str.len()) + for col in {'trip_id', 'trip_departure_time'}} + ).assign(stop_id=np.concatenate(trips['ordered_stops'].values), + stop_sequence=np.concatenate(trips['stop_sequence'].values), + departure_time=np.concatenate(trips['departure_offsets'].values), + arrival_time=np.concatenate(trips['arrival_offsets'].values)) + stop_times['arrival_time'] = (stop_times['trip_departure_time'] + stop_times['arrival_time']).dt.strftime( + '%H:%M:%S') + stop_times['departure_time'] = (stop_times['trip_departure_time'] + stop_times['departure_time']).dt.strftime( + '%H:%M:%S') + stop_times = stop_times.drop(['trip_departure_time'], axis=1) + for col in ['stop_headsign', 'pickup_type', 'drop_off_type', 'continuous_pickup', 'continuous_drop_off', + 'shape_dist_traveled', 'timepoint']: + stop_times[col] = float('nan') + + # finish off trips frame + trips = trips[['route_id', 'service_id', 'trip_id']] + for col in ['trip_headsign', 'trip_short_name', 'direction_id', 'block_id', 'shape_id', 'wheelchair_accessible', + 'bikes_allowed']: + trips[col] = float('nan') + + calendar = DataFrame(routes['route_id']) + for col in ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']: + calendar[col] = 1 + calendar['start_date'] = gtfs_day + calendar['end_date'] = gtfs_day + return {'stops': stops, 'routes': routes, 'trips': trips, 'stop_times': stop_times, 'calendar': calendar} + + def write_to_csv(self, output_dir, gtfs_day='19700101', file_extention='csv'): + """ + Writes 'stops', 'routes', 'trips', 'stop_times', 'calendar' tables to CSV files + :param output_dir: folder to output csv or txt files + :param gtfs_day: day used for GTFS when creating the network in YYYYMMDD format defaults to 19700101 + :param file_extention: csv by default, or txt + :return: None + """ + persistence.ensure_dir(output_dir) + logging.info(f'Saving Schedule to GTFS {file_extention} in {output_dir}') + for table, df in self.to_gtfs(gtfs_day).items(): + file_path = os.path.join(output_dir, f'{table}.{file_extention}') + logging.info(f'Saving {file_path}') + df.to_csv(file_path) + self.write_extras(output_dir) + + def write_to_gtfs(self, output_dir, gtfs_day='19700101'): + """ + Writes 'stops', 'routes', 'trips', 'stop_times', 'calendar' tables to CSV files + :param output_dir: folder to output txt files + :param gtfs_day: day used for GTFS when creating the network in YYYYMMDD format defaults to 19700101 + :return: None + """ + self.write_to_csv(output_dir, gtfs_day=gtfs_day, file_extention='txt') def verify_graph_schema(graph): diff --git a/genet/use/schedule.py b/genet/use/schedule.py index a9e12551..98c20112 100644 --- a/genet/use/schedule.py +++ b/genet/use/schedule.py @@ -42,7 +42,7 @@ def generate_edge_vph_geodataframe(df, gdf_links): cols_to_delete = list(set(df.columns) - (set(groupby_cols) | {'vph'})) df = pd.merge(gpd.GeoDataFrame(df, crs=gdf_links.crs), gdf_links, left_on=['from_stop', 'to_stop'], right_on=['u', 'v']) - cols_to_delete.extend(['u', 'v', 'key', 'routes', 'services']) + cols_to_delete.extend(['u', 'v', 'routes', 'services']) df = df.drop(cols_to_delete, axis=1) return df diff --git a/genet/utils/google_directions.py b/genet/utils/google_directions.py index ef070653..64ae5ec9 100644 --- a/genet/utils/google_directions.py +++ b/genet/utils/google_directions.py @@ -127,7 +127,7 @@ def _generate_requests_for_simplified_network(n): :param n: genet.Network :return: """ - gdf_links = geojson.generate_geodataframes(n.modal_subgraph(modes='car'))[1] + gdf_links = geojson.generate_geodataframes(n.modal_subgraph(modes='car'))['links'].to_crs("epsg:4326") gdf_links['path_polyline'] = gdf_links['geometry'].apply(lambda x: spatial.swap_x_y_in_linestring(x)) gdf_links['path_polyline'] = gdf_links['path_polyline'].apply( lambda x: spatial.encode_shapely_linestring_to_polyline(x)) diff --git a/genet/utils/spatial.py b/genet/utils/spatial.py index 02114546..e7a64221 100644 --- a/genet/utils/spatial.py +++ b/genet/utils/spatial.py @@ -173,7 +173,7 @@ def add_links(self, n): :param n: genet.Network object :return: """ - self.links = gngeojson.generate_geodataframes(n.graph)[1] + self.links = n.to_geodataframe()['links'].to_crs('epsg:4326') self.links = self.links.rename(columns={'id': 'link_id'}) nodes = self.links.set_index('link_id').T.to_dict() diff --git a/notebooks/1. Intro.ipynb b/notebooks/1. Intro.ipynb index 07704fc8..0982ca81 100644 --- a/notebooks/1. Intro.ipynb +++ b/notebooks/1. Intro.ipynb @@ -955,7 +955,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/2.1. Reading MATSim data.ipynb b/notebooks/2.1. Reading MATSim data.ipynb index 58b6852d..9f9827e4 100644 --- a/notebooks/2.1. Reading MATSim data.ipynb +++ b/notebooks/2.1. Reading MATSim data.ipynb @@ -12,13 +12,13 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:25.865066Z", - "start_time": "2021-01-28T15:58:22.997662Z" + "end_time": "2021-03-31T10:34:32.418276Z", + "start_time": "2021-03-31T10:34:30.196822Z" } }, "outputs": [], "source": [ - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "from pprint import pprint" ] @@ -28,20 +28,24 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:25.872290Z", - "start_time": "2021-01-28T15:58:25.867746Z" + "end_time": "2021-03-31T10:34:32.428026Z", + "start_time": "2021-03-31T10:34:32.419899Z" } }, "outputs": [], "source": [ - "path_to_matsim_network = '../example_data/pt2matsim_network'" + "path_to_matsim_network = '../example_data/pt2matsim_network'\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We initiate an empty `Network` object." + "We can read the network, schedule and vehicles `xml` files. You can read only the network, without the schedule, but we wary that some of the operations that you can perform in GeNet may have an impact on the schedule file. For example, simplifying the `Network` graph will result in a lot of new, simplified, links with different ids. This means the network routes contained for services in the schedule need to be updated and validated." ] }, { @@ -49,13 +53,18 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:26.307008Z", - "start_time": "2021-01-28T15:58:25.875030Z" + "end_time": "2021-03-31T10:34:34.471004Z", + "start_time": "2021-03-31T10:34:32.430359Z" } }, "outputs": [], "source": [ - "n = Network('epsg:27700')" + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")" ] }, { @@ -63,95 +72,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:26.315514Z", - "start_time": "2021-01-28T15:58:26.308755Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Graph info: Name: Network graph\n", - "Type: MultiDiGraph\n", - "Number of nodes: 0\n", - "Number of edges: 0\n", - " \n", - "Schedule info: Schedule:\n", - "Number of services: 0\n", - "Number of unique routes: 0\n", - "Number of stops: 0\n" - ] - } - ], - "source": [ - "n.print()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "GeNet currently does not read `vehicle.xml` file. It is something that is being developed and will be added soon to preserve vehicle ids and definitions." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-01-28T15:58:26.322661Z", - "start_time": "2021-01-28T15:58:26.317571Z" - } - }, - "outputs": [], - "source": [ - "network = os.path.join(path_to_matsim_network, 'network.xml')\n", - "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Finally, we read the network and then the schedule `xml` files. You can read only the network, without the schedule, but we wary that some of the operations that you can perform in GeNet may have an impact on the schedule file. For example, simplifying the `Network` graph will result in a lot of new, simplified, links with different ids. This means the network routes contained for services in the schedule need to be updated and validated." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-01-28T15:58:26.633722Z", - "start_time": "2021-01-28T15:58:26.324318Z" - } - }, - "outputs": [], - "source": [ - "n.read_matsim_network(network)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-01-28T15:58:27.074129Z", - "start_time": "2021-01-28T15:58:26.635619Z" - } - }, - "outputs": [], - "source": [ - "n.read_matsim_schedule(schedule)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-01-28T15:58:27.088713Z", - "start_time": "2021-01-28T15:58:27.077166Z" + "end_time": "2021-03-31T10:34:34.490521Z", + "start_time": "2021-03-31T10:34:34.472833Z" } }, "outputs": [ @@ -167,7 +89,7 @@ "Average out degree: 1.9049 \n", "Schedule info: Schedule:\n", "Number of services: 9\n", - "Number of unique routes: 68\n", + "Number of routes: 68\n", "Number of stops: 45\n" ] } @@ -185,11 +107,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:29.916702Z", - "start_time": "2021-01-28T15:58:27.092193Z" + "end_time": "2021-03-31T10:34:37.513633Z", + "start_time": "2021-03-31T10:34:34.494526Z" } }, "outputs": [ @@ -197,15 +119,17 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -217,10 +141,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -238,11 +162,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:30.624902Z", - "start_time": "2021-01-28T15:58:29.918551Z" + "end_time": "2021-03-31T10:34:38.781697Z", + "start_time": "2021-03-31T10:34:37.525222Z" } }, "outputs": [ @@ -250,8 +174,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -268,10 +194,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 10, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -289,11 +215,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:31.377564Z", - "start_time": "2021-01-28T15:58:30.627275Z" + "end_time": "2021-03-31T10:34:39.715759Z", + "start_time": "2021-03-31T10:34:38.795512Z" } }, "outputs": [ @@ -301,15 +227,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -321,10 +251,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 11, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -342,11 +272,11 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:31.570439Z", - "start_time": "2021-01-28T15:58:31.380268Z" + "end_time": "2021-03-31T10:34:39.955449Z", + "start_time": "2021-03-31T10:34:39.728106Z" } }, "outputs": [ @@ -355,7 +285,7 @@ "output_type": "stream", "text": [ "attribute\n", - "├── id: ['109995', '25626680', '21590631', '21665581', '103928']\n", + "├── id: ['25501958', '3519133221', '25472648', '25503716', '311422343']\n", "├── x: [528387.4250512555, 528391.4406755936, 528393.2742107178, 528396.6287644263, 528396.3513181042]\n", "├── y: [181547.5850354673, 181552.72935927223, 181558.10532352765, 181559.970402835, 181562.0370527053]\n", "├── lon: [-0.15178558709839862, -0.15872448710537235, -0.13569068709168342, -0.13766218709633904, -0.13543658708819173]\n", @@ -377,11 +307,11 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:31.702605Z", - "start_time": "2021-01-28T15:58:31.572704Z" + "end_time": "2021-03-31T10:34:40.111166Z", + "start_time": "2021-03-31T10:34:39.959524Z" } }, "outputs": [ @@ -481,11 +411,11 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2021-01-28T15:58:31.718411Z", - "start_time": "2021-01-28T15:58:31.706778Z" + "end_time": "2021-03-31T10:34:40.128637Z", + "start_time": "2021-03-31T10:34:40.114878Z" } }, "outputs": [ @@ -522,18 +452,11 @@ "source": [ "pprint(n.link('1'))" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -547,7 +470,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/2.2. Reading OSM data.ipynb b/notebooks/2.2. Reading OSM data.ipynb index fa2da84b..33d64e24 100644 --- a/notebooks/2.2. Reading OSM data.ipynb +++ b/notebooks/2.2. Reading OSM data.ipynb @@ -12,38 +12,17 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:32.479716Z", - "start_time": "2021-03-15T10:16:30.123725Z" + "end_time": "2021-04-13T18:06:17.972005Z", + "start_time": "2021-04-13T18:06:15.311202Z" } }, "outputs": [], "source": [ - "from genet import Network\n", + "from genet import read_osm\n", "import os\n", "from pprint import pprint" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We again initiate an empty `Network` object." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-15T10:16:33.017858Z", - "start_time": "2021-03-15T10:16:32.487001Z" - } - }, - "outputs": [], - "source": [ - "n = Network('epsg:27700')" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -58,11 +37,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:43.412230Z", - "start_time": "2021-03-15T10:16:33.020775Z" + "end_time": "2021-04-13T18:06:28.439157Z", + "start_time": "2021-04-13T18:06:17.986653Z" } }, "outputs": [ @@ -70,30 +49,35 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:16:33,036 - Building OSM graph from file ../example_data/example.osm\n", - "2021-03-15 10:16:33,527 - Creating networkx graph from OSM data\n", - "2021-03-15 10:16:33,528 - OSM: Extract Nodes and Paths from OSM data\n", - "2021-03-15 10:16:33,737 - OSM: Add each OSM way (aka, path) to the OSM graph\n", - "2021-03-15 10:16:33,738 - Created OSM edges\n", - "2021-03-15 10:16:35,579 - Added 8695 nodes\n", - "2021-03-15 10:16:42,385 - Generated 802 link ids.\n", - "2021-03-15 10:16:43,155 - Added 802 links\n", - "2021-03-15 10:16:43,157 - Deleting isolated nodes which have no edges.\n", - "2021-03-15 10:16:43,407 - Removed 8132 nodes.\n" + "2021-04-13 19:06:18,906 - Building OSM graph from file ../example_data/example.osm\n", + "2021-04-13 19:06:19,373 - Creating networkx graph from OSM data\n", + "2021-04-13 19:06:19,374 - OSM: Extract Nodes and Paths from OSM data\n", + "2021-04-13 19:06:19,567 - OSM: Add each OSM way (aka, path) to the OSM graph\n", + "2021-04-13 19:06:19,568 - 1 or 2 batches of size 64 ish\n", + "2021-04-13 19:06:19,598 - Created OSM edges\n", + "2021-04-13 19:06:21,663 - Added 8695 nodes\n", + "2021-04-13 19:06:27,364 - Generated 802 link ids.\n", + "2021-04-13 19:06:28,134 - Added 802 links\n", + "2021-04-13 19:06:28,135 - Deleting isolated nodes which have no edges.\n", + "2021-04-13 19:06:28,426 - Removed 8132 nodes.\n" ] } ], "source": [ - "n.read_osm('../example_data/example.osm', '../genet/configs/OSM/slim_config.yml')" + "n = read_osm('../example_data/example.osm', \n", + " '../genet/configs/OSM/slim_config.yml',\n", + " num_processes=2,\n", + " epsg='epsg:27700'\n", + " )" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:43.436012Z", - "start_time": "2021-03-15T10:16:43.415678Z" + "end_time": "2021-04-13T18:06:28.491169Z", + "start_time": "2021-04-13T18:06:28.468414Z" } }, "outputs": [ @@ -120,11 +104,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:43.925698Z", - "start_time": "2021-03-15T10:16:43.439387Z" + "end_time": "2021-04-13T18:06:28.946231Z", + "start_time": "2021-04-13T18:06:28.509520Z" } }, "outputs": [ @@ -135,7 +119,9 @@ "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -152,10 +138,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -166,11 +152,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:43.967658Z", - "start_time": "2021-03-15T10:16:43.949090Z" + "end_time": "2021-04-13T18:06:28.988352Z", + "start_time": "2021-04-13T18:06:28.948047Z" } }, "outputs": [ @@ -194,11 +180,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:44.100450Z", - "start_time": "2021-03-15T10:16:43.970055Z" + "end_time": "2021-04-13T18:06:29.036458Z", + "start_time": "2021-04-13T18:06:28.992265Z" } }, "outputs": [ @@ -256,40 +242,40 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:16:44.120822Z", - "start_time": "2021-03-15T10:16:44.104421Z" + "end_time": "2021-04-13T18:06:29.047718Z", + "start_time": "2021-04-13T18:06:29.039068Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'permlanes': 2.0,\n", - " 'freespeed': 12.5,\n", - " 'capacity': 1200.0,\n", + "{'permlanes': 1.0,\n", + " 'freespeed': 44.44,\n", + " 'capacity': 9999.0,\n", " 'oneway': '1',\n", - " 'modes': ['car', 'walk', 'bike'],\n", - " 'from': '108235',\n", - " 'to': '25483808',\n", - " 's2_from': 5221390319574716373,\n", - " 's2_to': 5221390319550394773,\n", - " 'length': 18.964724652807188,\n", - " 'attributes': {'osm:way:highway': {'name': 'osm:way:highway',\n", + " 'modes': ['rail'],\n", + " 'from': '1655270799',\n", + " 'to': '1655270866',\n", + " 's2_from': 5221390815197466447,\n", + " 's2_to': 5221390815615696951,\n", + " 'length': 67.59566495488589,\n", + " 'attributes': {'osm:way:railway': {'name': 'osm:way:railway',\n", " 'class': 'java.lang.String',\n", - " 'text': 'tertiary'},\n", - " 'osm:way:osmid': {'name': 'osm:way:osmid',\n", + " 'text': 'disused'},\n", + " 'osm:way:tunnel': {'name': 'osm:way:tunnel',\n", " 'class': 'java.lang.String',\n", - " 'text': '47007861'},\n", - " 'osm:way:lanes': {'name': 'osm:way:lanes',\n", + " 'text': 'yes'},\n", + " 'osm:way:osmid': {'name': 'osm:way:osmid',\n", " 'class': 'java.lang.String',\n", - " 'text': '2'}},\n", + " 'text': '558070291'}},\n", " 'id': '1'}" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -305,18 +291,11 @@ "#### Remark:\n", "A graph generated from OSM is most likely not **strongly connected** which is something that MATSim expects for the mode `car` and if using `multimodal.contrib` also for modes `walk` and `bike`." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/2.3. Reading GTFS data.ipynb b/notebooks/2.3. Reading GTFS data.ipynb index 31fd424c..19109ff0 100644 --- a/notebooks/2.3. Reading GTFS data.ipynb +++ b/notebooks/2.3. Reading GTFS data.ipynb @@ -7,17 +7,17 @@ "# Reading GTFS data\n", "\n", "GeNet ingests zipped or unzipped GTFS feeds. The following files are required in the unzipped folder, or inside the zip file:\n", - "- calendar.txt\n", - "- stop_times.txt\n", - "- stops.txt\n", - "- trips.txt\n", - "- routes.txt\n", + "- `calendar.txt`\n", + "- `stop_times.txt`\n", + "- `stops.txt`\n", + "- `trips.txt`\n", + "- `routes.txt`\n", "\n", "When reading a GTFS feed, GeNet expects a date in `YYYYMMDD` format. It will raise an error if the selected date yields no services.\n", "\n", - "GeNet currently does not support filtering the output `genet.Schedule` objects based on a geographical area. This can \n", - "be done using [gtfs-lib](https://github.com/conveyal/gtfs-lib) prior to ingestion in GeNet. Or, you can attempt to \n", - "manipulate the `genet.Schedule` object within GeNet. Make sure to validate the final `genet.Schedule`.\n", + "[Here](https://developers.google.com/transit/gtfs/reference) is the reference page for the schema of GTFS data.\n", + "\n", + "GeNet does support extraction of services/routes/stops in the output `genet.Schedule` object based on a geographical area (Methods: `services_on_spatial_condition`, `routes_on_spatial_condition`, `stops_on_spatial_condition`, more information in notebook on using genet Network), but you might like to use [gtfs-lib](https://github.com/conveyal/gtfs-lib) prior to ingestion in GeNet.\n", "\n", "The user assumes responsibility for the quality of their input GTFS feed. There are various validation tools that can \n", "be used with GTFS feeds before using with GeNet, see this page for a summary of [validation tools](https://gtfs.org/testing/)." @@ -28,13 +28,13 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-12-15T17:49:12.159272Z", - "start_time": "2020-12-15T17:49:09.856109Z" + "end_time": "2021-03-29T11:50:57.251437Z", + "start_time": "2021-03-29T11:50:55.155858Z" } }, "outputs": [], "source": [ - "from genet import Schedule" + "from genet import read_gtfs" ] }, { @@ -49,13 +49,33 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-12-15T17:49:12.505080Z", - "start_time": "2020-12-15T17:49:12.162239Z" + "end_time": "2021-03-29T11:50:57.583098Z", + "start_time": "2021-03-29T11:50:57.253772Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-29 12:50:57,256 - Reading the calendar for GTFS\n", + "2021-03-29 12:50:57,260 - Reading GTFS data into usable format\n", + "2021-03-29 12:50:57,262 - Reading stop times\n", + "2021-03-29 12:50:57,267 - Reading trips\n", + "2021-03-29 12:50:57,274 - Reading stops\n", + "2021-03-29 12:50:57,279 - Reading routes\n" + ] + } + ], "source": [ - "s = Schedule('epsg:27700')" + "s = read_gtfs('../example_data/example_gtfs', '20190603')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GTFS is assumed to be in `epsg:4326`, you need to project the Schedule to projection you require." ] }, { @@ -63,26 +83,13 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-12-15T17:49:14.069104Z", - "start_time": "2020-12-15T17:49:12.507180Z" + "end_time": "2021-03-29T11:50:57.850735Z", + "start_time": "2021-03-29T11:50:57.585211Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2020-12-15 17:49:12,508 - Reading the calendar for GTFS\n", - "2020-12-15 17:49:12,511 - Reading GTFS data into usable format\n", - "2020-12-15 17:49:12,512 - Reading stop times\n", - "2020-12-15 17:49:12,514 - Reading trips\n", - "2020-12-15 17:49:12,516 - Reading stops\n", - "2020-12-15 17:49:12,518 - Reading routes\n" - ] - } - ], + "outputs": [], "source": [ - "s.read_gtfs_schedule('../example_data/example_gtfs', '20190603')" + "s.reproject('epsg:27700')" ] }, { @@ -90,8 +97,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-12-15T17:49:14.079130Z", - "start_time": "2020-12-15T17:49:14.072224Z" + "end_time": "2021-03-29T11:50:57.856790Z", + "start_time": "2021-03-29T11:50:57.852431Z" } }, "outputs": [ @@ -101,7 +108,7 @@ "text": [ "Schedule:\n", "Number of services: 2\n", - "Number of unique routes: 2\n", + "Number of routes: 2\n", "Number of stops: 4\n" ] } @@ -115,8 +122,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-12-15T17:49:14.269371Z", - "start_time": "2020-12-15T17:49:14.081914Z" + "end_time": "2021-03-29T11:50:58.011944Z", + "start_time": "2021-03-29T11:50:57.859401Z" } }, "outputs": [ @@ -124,15 +131,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -144,7 +151,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 5, @@ -166,7 +173,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -180,7 +187,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/2.4. Reading CSV data.ipynb b/notebooks/2.4. Reading CSV data.ipynb new file mode 100644 index 00000000..b2e84bce --- /dev/null +++ b/notebooks/2.4. Reading CSV data.ipynb @@ -0,0 +1,190 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reading a network from CSV\n", + "\n", + "You can read a network from node and link CSV files. For it to be a valid MATSim network, the CSVs need to have the following data columns:\n", + "\n", + "Nodes:\n", + " - id - unique ID for the Node\n", + " - x - x spatial coordinate in a given projection\n", + " - y - y spatial coordinate in a given projection\n", + " \n", + "Links:\n", + " - id - unique ID for the Link\n", + " - from - source Node ID\n", + " - to - target Node ID\n", + " - length - link length in metres\n", + " - freespeed - meter/seconds speed\n", + " - capacity - vehicles/hour\n", + " - permlanes - number of lanes\n", + " - modes - set of modes\n", + " \n", + "Following the [MATSim network schema](https://www.matsim.org/files/dtd/network_v2.dtd). As well as be strongly connected for modes available to agents. Check out Section/Notebook 6.1. Validating Network - MATSim Specific for more details about validating Network." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-30T15:05:09.804787Z", + "start_time": "2021-03-30T15:05:09.798551Z" + } + }, + "outputs": [], + "source": [ + "csv_nodes = '../example_data/example_csv/nodes.csv'\n", + "csv_links = '../example_data/example_csv/links.csv'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-30T15:05:12.816303Z", + "start_time": "2021-03-30T15:05:09.806292Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-30 16:05:12,209 - Reading nodes from ../example_data/example_csv/nodes.csv\n", + "2021-03-30 16:05:12,218 - Reading links from ../example_data/example_csv/nodes.csv\n", + "2021-03-30 16:05:12,799 - Added 4 nodes\n", + "2021-03-30 16:05:12,810 - Added 2 links\n" + ] + } + ], + "source": [ + "from genet import read_csv\n", + "n = read_csv(csv_nodes, csv_links, epsg='epsg:27700')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-30T15:05:12.826143Z", + "start_time": "2021-03-30T15:05:12.822024Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph info: Name: Network graph\n", + "Type: MultiDiGraph\n", + "Number of nodes: 4\n", + "Number of edges: 2\n", + "Average in degree: 0.5000\n", + "Average out degree: 0.5000 \n", + "Schedule info: Schedule:\n", + "Number of services: 0\n", + "Number of routes: 0\n", + "Number of stops: 0\n" + ] + } + ], + "source": [ + "n.print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For reading `Schedule` from csv inputs, head over to Section/Notebook 2.3. Reading GTFS data" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "genet", + "language": "python", + "name": "genet" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/2.5. Reading JSON & GeoJSON data.ipynb b/notebooks/2.5. Reading JSON & GeoJSON data.ipynb new file mode 100644 index 00000000..d7661edf --- /dev/null +++ b/notebooks/2.5. Reading JSON & GeoJSON data.ipynb @@ -0,0 +1,400 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reading JSON & GeoJSON data\n", + "\n", + "GeNet lets you read JSON data into a Networn graph and PT Schedule, or GeoJSON into Network Graph. \n", + "\n", + "For JSON inputs the network JSON file should follow this format:\n", + "```json\n", + "{\n", + " \"nodes\": {\n", + " \"unique_node_ID\": {\n", + " \"id\": \"unique_node_ID\",\n", + " \"y\": y_spatial_coordinate,\n", + " \"x\": x_spatial_coordinate\n", + " }\n", + " },\n", + " \"links\": {\n", + " \"unique_link_ID\": {\n", + " \"id\": \"unique_link_ID\",\n", + " \"from\": \"unique_source_node_ID\",\n", + " \"to\": \"unique_target_node_ID\",\n", + " \"freespeed\": 4.166666666666667,\n", + " \"permlanes\": 1,\n", + " \"modes\": \"car,bus,walk\",\n", + " \"geometry\": \"kevj`maB_`la`}`@{ooxA`k~rH\", (encoded polyline, otherwise assumed to be straight line between source and target node)\n", + " \"length\": 52.765151087870265,\n", + " \"capacity\": 600.0\n", + " \"attributes\": { (optional MATSim link attributes)\n", + " \"osm:way:access\": {\n", + " \"name\": \"osm:way:access\",\n", + " \"class\": \"java.lang.String\",\n", + " \"text\": \"permissive\"\n", + " }\n", + " },\n", + " }\n", + " }\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:09:32.090609Z", + "start_time": "2021-03-31T10:09:29.494770Z" + } + }, + "outputs": [], + "source": [ + "from genet import read_json_network, read_json_schedule, read_json" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:09:32.638094Z", + "start_time": "2021-03-31T10:09:32.093092Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:09:32,093 - Reading Network from ../example_data/example_json/network.json\n", + "2021-03-31 11:09:32,621 - Added 4 nodes\n", + "2021-03-31 11:09:32,632 - Added 2 links\n" + ] + } + ], + "source": [ + "n = read_json_network('../example_data/example_json/network.json', 'epsg:27700')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The JSON Schedule should follow this format:\n", + "\n", + "```json\n", + "{\n", + " \"schedule\": {\n", + " \"stops\": {\n", + " \"unique_stop_ID\": {\n", + " \"id\": \"unique_stop_ID\",\n", + " \"name\": \"Stop Name\", (optional but useful)\n", + " \"x\": y_spatial_coordinate,\n", + " \"y\": x_spatial_coordinate,\n", + " \"linkRefId\": \"netowrk_link_ID\", (reference to a link in the network graph)\n", + " }\n", + " },\n", + " \"services\": {\n", + " \"unique_service_ID\": {\n", + " \"id\": \"unique_service_ID\",\n", + " \"name\": \"N55\", (optional but useful)\n", + " \"routes\": {\n", + " \"unique_route_ID\": {\n", + " \"id\": \"unique_route_ID\",\n", + " \"route_short_name\": \"N55\", (optional but useful)\n", + " \"mode\": \"bus\", (PT mode)\n", + " \"trips\": {\n", + " \"trip_id\": [\n", + " \"unique_trip_ID\"\n", + " ],\n", + " \"trip_departure_time\": [\n", + " \"HH:MM:SS\" (departure time for the trip)\n", + " ],\n", + " \"vehicle_id\": [\n", + " \"unique_vehicle_ID\"\n", + " ]\n", + " },\n", + " \"arrival_offsets\": [ (arrival offsets from trip departure time for each stop in route)\n", + " \"00:00:00\",\n", + " \"00:02:20\"\n", + " ],\n", + " \"departure_offsets\": [ (departure offsets from trip departure time for each stop in route)\n", + " \"00:00:00\",\n", + " \"00:02:20\"\n", + " ],\n", + " \"route_long_name\": \"\", (optional but useful)\n", + " \"route\": [ (network route for the route)\n", + " \"1\",\n", + " \"10\"\n", + " ],\n", + " \"ordered_stops\": [\n", + " \"unique_stop_ID_1\",\n", + " \"unique_stop_ID_2\"\n", + " ]\n", + " }\n", + " }\n", + " }\n", + " },\n", + " \"minimal_transfer_times\": {\n", + " \"unique_stop_ID_1\": {\n", + " \"stop\": \"unique_stop_ID_2\",\n", + " \"transferTime\": 100.0\n", + " },\n", + " \"unique_stop_ID_2\": {\n", + " \"stop\": \"unique_stop_ID_1\",\n", + " \"transferTime\": 100.0\n", + " }\n", + " }\n", + " },\n", + " \"vehicles\": {\n", + " \"vehicle_types\": {\n", + " \"bus\": {\n", + " \"capacity\": {\n", + " \"seats\": {\n", + " \"persons\": \"70\"\n", + " },\n", + " \"standingRoom\": {\n", + " \"persons\": \"0\"\n", + " }\n", + " },\n", + " \"length\": {\n", + " \"meter\": \"18.0\"\n", + " },\n", + " \"width\": {\n", + " \"meter\": \"2.5\"\n", + " },\n", + " \"accessTime\": {\n", + " \"secondsPerPerson\": \"0.5\"\n", + " },\n", + " \"egressTime\": {\n", + " \"secondsPerPerson\": \"0.5\"\n", + " },\n", + " \"doorOperation\": {\n", + " \"mode\": \"serial\"\n", + " },\n", + " \"passengerCarEquivalents\": {\n", + " \"pce\": \"2.8\"\n", + " }\n", + " }\n", + " },\n", + " \"vehicles\": {\n", + " \"veh_0_bus\": {\n", + " \"type\": \"bus\"\n", + " }\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "the references to the network: `linkRefId` and `route` can be left out. That network will not work with MATSim. GeNet can snap and route PT services and fill in those blanks, though not at scale." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:09:32.842397Z", + "start_time": "2021-03-31T10:09:32.641035Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:09:32,642 - Reading Schedule from ../example_data/example_json/schedule.json\n" + ] + } + ], + "source": [ + "s = read_json_schedule('../example_data/example_json/schedule.json', 'epsg:27700')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you have both json inputs for a network you can also read both the network json and schedule json at the same time." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:09:33.442081Z", + "start_time": "2021-03-31T10:09:32.844763Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:09:32,846 - Reading Network from ../example_data/example_json/network.json\n", + "2021-03-31 11:09:33,236 - Added 4 nodes\n", + "2021-03-31 11:09:33,248 - Added 2 links\n", + "2021-03-31 11:09:33,251 - Reading Schedule from ../example_data/example_json/schedule.json\n" + ] + } + ], + "source": [ + "n = read_json(\n", + " network_path='../example_data/example_json/network.json', \n", + " schedule_path='../example_data/example_json/schedule.json',\n", + " epsg='epsg:27700'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given GeoJson, you can create a Network graph. Two files are expected, one for nodes and one for links.\n", + "\n", + "The nodes should follow this format:\n", + "```geojson\n", + "{\n", + "\"type\": \"FeatureCollection\",\n", + "\"crs\": { \"type\": \"name\", \"properties\": { \"name\": \"urn:ogc:def:crs:EPSG::27700\" } },\n", + "\"features\": [\n", + "{ \"type\": \"Feature\", \"properties\": {\"id\": \"25508485\", \"x\": 528489.467895946, \"y\": 182206.20303669578, \"lon\": -0.14930198709481451, \"lat\": 51.524162533239284, \"s2_id\": 5221390301001263407 }, \"geometry\": { \"type\": \"Point\", \"coordinates\": [ 528489.467895945999771, 182206.203036695776973 ] } }\n", + "]\n", + "}\n", + "```\n", + "And the links should follow this format:\n", + "```geojson\n", + "{\n", + "\"type\": \"FeatureCollection\",\n", + "\"crs\": { \"type\": \"name\", \"properties\": { \"name\": \"urn:ogc:def:crs:EPSG::27700\" } },\n", + "\"features\": [\n", + "{ \"type\": \"Feature\", \"properties\": {\"id\": \"1\", \"from\": \"25508485\", \"to\": \"21667818\", \"freespeed\": 4.166666666666667, \"capacity\": 600.0, \"permlanes\": 1.0, \"oneway\": \"1\", \"modes\": \"car\", \"s2_from\": 5221390301001263407, \"s2_to\": 5221390302696205321, \"attributes\": { \"osm:way:access\": { \"name\": \"osm:way:access\", \"class\": \"java.lang.String\", \"text\": \"permissive\" }, \"osm:way:highway\": { \"name\": \"osm:way:highway\", \"class\": \"java.lang.String\", \"text\": \"unclassified\" }, \"osm:way:id\": { \"name\": \"osm:way:id\", \"class\": \"java.lang.Long\", \"text\": \"26997928\" }, \"osm:way:name\": { \"name\": \"osm:way:name\", \"class\": \"java.lang.String\", \"text\": \"Brunswick Place\" } }, \"length\": 52.765151087870265 }, \"geometry\": { \"type\": \"LineString\", \"coordinates\": [ [ 528489.467895945999771, 182206.203036695776973 ], [ 528504.134284314350225, 182155.743513659806922 ] ] } }\n", + "]\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:09:33.944327Z", + "start_time": "2021-03-31T10:09:33.443660Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:09:33,444 - Reading Network nodes from ../example_data/example_geojson/network_nodes.geojson\n", + "2021-03-31 11:09:33,502 - Reading Network links from ../example_data/example_geojson/network_links.geojson\n", + "2021-03-31 11:09:33,927 - Added 4 nodes\n", + "2021-03-31 11:09:33,938 - Added 2 links\n" + ] + } + ], + "source": [ + "from genet import read_geojson_network\n", + "n = read_geojson_network(\n", + " '../example_data/example_geojson/network_nodes.geojson', \n", + " '../example_data/example_geojson/network_links.geojson', \n", + " 'epsg:27700')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The GeoJSONs carry a projection for their geometry. The epsg passed in the method above is for the Network, the links will inherit the geometry stored in the geojson but project it (if not already in the correct projection) to match the Network's projection" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "genet", + "language": "python", + "name": "genet" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/3.1. Writing MATSim data.ipynb b/notebooks/3.1. Writing MATSim data.ipynb index 1e4ccbfa..c2eb80c0 100644 --- a/notebooks/3.1. Writing MATSim data.ipynb +++ b/notebooks/3.1. Writing MATSim data.ipynb @@ -37,13 +37,23 @@ } ], "source": [ - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.print()" ] }, @@ -79,16 +89,16 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "Note that saving your network to MATSim format will only include the attributes included in the [MATSim network schema](https://www.matsim.org/files/dtd/network_v2.dtd). All other attributes will not be saved to this format, but you may be interested in also saving your network to CSV, or (Geo/)JSON formats." + ] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -102,7 +112,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/3.3. Writing GTFS data.ipynb b/notebooks/3.3. Writing GTFS data.ipynb new file mode 100644 index 00000000..f36b94b9 --- /dev/null +++ b/notebooks/3.3. Writing GTFS data.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Writing GTFS data\n", + "\n", + "GeNet can generate CSV or text files in GTFS-like format based on a `Schedule` object. It will return the following file\n", + "- `calendar.txt`\n", + "- `stop_times.txt`\n", + "- `stops.txt`\n", + "- `trips.txt`\n", + "- `routes.txt`\n", + "(or .csv depending on the method used)\n", + "\n", + "When reading a GTFS feed, GeNet expects a date in `YYYYMMDD` format. It does not retain this information. You are required to pass this GTFS day when exporting to GTFS. `Schedule` object does not contain a lot of the optional GTFS data point (a lot more is retained if the Schedule was created through GeNet). In particular, if using MATSim files as input, your Schedule will mostly contain only the required fields. Other important remarks:\n", + "- list of network link IDs associated with the transit routes as the path and the relation of stops to network link IDs is not exported.\n", + "- `agency.txt` is not generated\n", + "- `service_id` is generated from Service objects. If the Schedule object is generated from GTFS through GeNet, those service IDs are based off of the `route_id` field in GTFS. This means the two fields in output GTFS are the same. The transit route split of services (based on ordered chain of stops) is lost when exporting to GTFS.\n", + "- you can pass you own `mode_to_route_type` dictionary that will map modes in the Schedule to the `route_type` codes you want. Otherwise it will default to\n", + "```\n", + "{\n", + " \"tram\": 0, \"subway\": 1, \"rail\": 2, \"bus\": 3, \"ferry\": 4, \"cablecar\": 5, \"gondola\": 6, \"funicular\": 7\n", + "}\n", + "```\n", + "based on [this](https://developers.google.com/transit/gtfs/reference#routestxt). **Caveat** - if you have read Schedule from GTFS, the `route_type` codes are retained and will not be changed.\n", + "\n", + "[Here](https://developers.google.com/transit/gtfs/reference) is the reference page for the schema of GTFS data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:50.770818Z", + "start_time": "2021-03-29T11:54:48.200556Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-29 12:54:50,421 - Reading the calendar for GTFS\n", + "2021-03-29 12:54:50,423 - Reading GTFS data into usable format\n", + "2021-03-29 12:54:50,424 - Reading stop times\n", + "2021-03-29 12:54:50,429 - Reading trips\n", + "2021-03-29 12:54:50,432 - Reading stops\n", + "2021-03-29 12:54:50,436 - Reading routes\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from genet import read_gtfs\n", + "s = read_gtfs('../example_data/example_gtfs', '20190603')\n", + "s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can export `Schedule` straight to files:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:50.867599Z", + "start_time": "2021-03-29T11:54:50.772473Z" + } + }, + "outputs": [], + "source": [ + "s.write_to_csv('../example_data/output_gtfs', '20190603')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:50.959077Z", + "start_time": "2021-03-29T11:54:50.870111Z" + } + }, + "outputs": [], + "source": [ + "s.write_to_gtfs('../example_data/output_gtfs', '20190603')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or generate `pandas.DataFrame` GTFS tables:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:51.055327Z", + "start_time": "2021-03-29T11:54:50.960998Z" + } + }, + "outputs": [], + "source": [ + "gtfs = s.to_gtfs('20190603')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:51.063256Z", + "start_time": "2021-03-29T11:54:51.057596Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['stops', 'routes', 'trips', 'stop_times', 'calendar'])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gtfs.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-29T11:54:51.092528Z", + "start_time": "2021-03-29T11:54:51.068049Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stop_idstop_namestop_latstop_lonstop_codestop_desczone_idstop_urllocation_typeparent_stationstop_timezonewheelchair_boardinglevel_idplatform_code
RSNRSNRail Stop snap to node51.523134-0.141095NaNNaNNaNNaN0.0210G430NaNNaNNaNNaN
BSNBSNBus Stop snap to node51.521620-0.140053NaNNaNNaNNaN0.0210G432NaNNaNNaNNaN
BSEBSEBus Stop snap to edge51.522686-0.141362NaNNaNNaNNaN0.0210G433NaNNaNNaNNaN
RSERSERail Stop snap to edge51.519261-0.142159NaNNaNNaNNaN0.0210G431NaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " stop_id stop_name stop_lat stop_lon stop_code \\\n", + "RSN RSN Rail Stop snap to node 51.523134 -0.141095 NaN \n", + "BSN BSN Bus Stop snap to node 51.521620 -0.140053 NaN \n", + "BSE BSE Bus Stop snap to edge 51.522686 -0.141362 NaN \n", + "RSE RSE Rail Stop snap to edge 51.519261 -0.142159 NaN \n", + "\n", + " stop_desc zone_id stop_url location_type parent_station \\\n", + "RSN NaN NaN NaN 0.0 210G430 \n", + "BSN NaN NaN NaN 0.0 210G432 \n", + "BSE NaN NaN NaN 0.0 210G433 \n", + "RSE NaN NaN NaN 0.0 210G431 \n", + "\n", + " stop_timezone wheelchair_boarding level_id platform_code \n", + "RSN NaN NaN NaN NaN \n", + "BSN NaN NaN NaN NaN \n", + "BSE NaN NaN NaN NaN \n", + "RSE NaN NaN NaN NaN " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gtfs['stops'].head()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "genet", + "language": "python", + "name": "genet" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/3.4. Writing CSV data.ipynb b/notebooks/3.4. Writing CSV data.ipynb new file mode 100644 index 00000000..89b1327c --- /dev/null +++ b/notebooks/3.4. Writing CSV data.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Writing a network to CSV\n", + "Let's read in a sample MATSim network into GeNet's `Network` object." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-30T10:00:33.961128Z", + "start_time": "2021-03-30T10:00:25.756814Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph info: Name: Network graph\n", + "Type: MultiDiGraph\n", + "Number of nodes: 1662\n", + "Number of edges: 3166\n", + "Average in degree: 1.9049\n", + "Average out degree: 1.9049 \n", + "Schedule info: Schedule:\n", + "Number of services: 9\n", + "Number of routes: 68\n", + "Number of stops: 45\n" + ] + } + ], + "source": [ + "from genet import read_matsim\n", + "import os\n", + "\n", + "path_to_matsim_network = '../example_data/pt2matsim_network'\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", + "n.print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can export the `genet.Network` and the `Schedule` (if applicable) to CSV." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-30T10:00:36.203386Z", + "start_time": "2021-03-30T10:00:33.966561Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-30 11:00:35,722 - Saving Network to CSV in ../example_data/output_csv/network\n", + "2021-03-30 11:00:35,840 - Saving Schedule to GTFS CSV in ../example_data/output_csv/schedule\n", + "2021-03-30 11:00:36,113 - Saving ../example_data/output_csv/schedule/stops.csv\n", + "2021-03-30 11:00:36,114 - Saving ../example_data/output_csv/schedule/routes.csv\n", + "2021-03-30 11:00:36,117 - Saving ../example_data/output_csv/schedule/trips.csv\n", + "2021-03-30 11:00:36,136 - Saving ../example_data/output_csv/schedule/stop_times.csv\n", + "2021-03-30 11:00:36,193 - Saving ../example_data/output_csv/schedule/calendar.csv\n" + ] + } + ], + "source": [ + "n.write_to_csv('../example_data/output_csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The node and link CSVs describing the network will include any and all data stored as attributes on the graph---in contrast to the MATSim output which will only include attributes included in the [MATSim network schema](https://www.matsim.org/files/dtd/network_v2.dtd).\n", + "\n", + "For `Schedule` the outputs are saved to GTFS CSV files. Some data is lost when saving Schedule to GTFS, for example the relationship and paths between network and schedule. The details of this schema and what is lost can be found in Section/Notebook 3.3 Writing GTFS data." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "genet", + "language": "python", + "name": "genet" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/3.5. Writing JSON & GeoJSON data.ipynb b/notebooks/3.5. Writing JSON & GeoJSON data.ipynb new file mode 100644 index 00000000..73166473 --- /dev/null +++ b/notebooks/3.5. Writing JSON & GeoJSON data.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Writing JSON & GeoJSON data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:56:35.298397Z", + "start_time": "2021-03-31T10:56:30.153334Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph info: Name: Network graph\n", + "Type: MultiDiGraph\n", + "Number of nodes: 1662\n", + "Number of edges: 3166\n", + "Average in degree: 1.9049\n", + "Average out degree: 1.9049 \n", + "Schedule info: Schedule:\n", + "Number of services: 9\n", + "Number of routes: 68\n", + "Number of stops: 45\n" + ] + } + ], + "source": [ + "from genet import read_matsim\n", + "import os\n", + "\n", + "path_to_matsim_network = '../example_data/pt2matsim_network'\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", + "n.print()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can write the Network and it's Schedule (if applicable) to JSON:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:56:38.328520Z", + "start_time": "2021-03-31T10:56:35.303177Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:56:35,308 - Saving Network to JSON in ../example_data/output_json\n", + "2021-03-31 11:56:38,210 - Saving Schedule to JSON in ../example_data/output_json\n" + ] + } + ], + "source": [ + "n.write_to_json('../example_data/output_json')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Writing the Network to JSON preserves all of the Network data - unlike writing the Network to CSV or MATSim format. For limitations of those formats head over to Sections/Notebooks:\n", + "- Writing CSV data\n", + "- Writing MATSim data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also choose to write the network to GeoJSON. This will produce spatial representation of the Network graph and the Schedule graph. \n", + "\n", + "- The main diference for the Network graph outputs is that the link geometry is a `LINESTRING`, whereas in the JSON outputs, this geometry is an encoded polyline.\n", + "- The biggest difference is for the Schedule graph. With JSON output you get the entire Schedule data saved to file. With GeoJSON you get only the spatial representation of the graph, nodes and edges, where nodes are the Stops in the Schedule and edges are the connections between Stops as defined by the Route and Service objects which use those Stops. It does not include any information about the vehicles, their IDs or modes, vehicle definitions or network routes (the edges are straight lines between the Stops)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-31T10:56:41.603362Z", + "start_time": "2021-03-31T10:56:38.330914Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2021-03-31 11:56:39,729 - Saving Network to GeoJSON in ../example_data/output_geojson\n", + "2021-03-31 11:56:39,781 - ../example_data/output_geojson/network_nodes.geojson: No such file or directory\n", + "2021-03-31 11:56:39,782 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:40,139 - ../example_data/output_geojson/network_links.geojson: No such file or directory\n", + "2021-03-31 11:56:40,140 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:40,962 - ../example_data/output_geojson/network_nodes_geometry_only.geojson: No such file or directory\n", + "2021-03-31 11:56:40,963 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:41,128 - ../example_data/output_geojson/network_links_geometry_only.geojson: No such file or directory\n", + "2021-03-31 11:56:41,129 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:41,442 - Saving Schedule to GeoJSON in ../example_data/output_geojson\n", + "2021-03-31 11:56:41,467 - ../example_data/output_geojson/schedule_nodes.geojson: No such file or directory\n", + "2021-03-31 11:56:41,467 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:41,503 - ../example_data/output_geojson/schedule_links.geojson: No such file or directory\n", + "2021-03-31 11:56:41,505 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:41,535 - ../example_data/output_geojson/schedule_nodes_geometry_only.geojson: No such file or directory\n", + "2021-03-31 11:56:41,536 - driver GeoJSON does not support creation option ENCODING\n", + "2021-03-31 11:56:41,564 - ../example_data/output_geojson/schedule_links_geometry_only.geojson: No such file or directory\n", + "2021-03-31 11:56:41,568 - driver GeoJSON does not support creation option ENCODING\n" + ] + } + ], + "source": [ + "n.write_to_geojson('../example_data/output_geojson')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "genet", + "language": "python", + "name": "genet" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.0" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/4.1. Using Network - Accessing Data.ipynb b/notebooks/4.1. Using Network - Accessing Data.ipynb index 8694a080..b1dbd64a 100644 --- a/notebooks/4.1. Using Network - Accessing Data.ipynb +++ b/notebooks/4.1. Using Network - Accessing Data.ipynb @@ -14,8 +14,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.623775Z", - "start_time": "2021-03-15T10:18:24.967673Z" + "end_time": "2021-03-31T10:37:44.472492Z", + "start_time": "2021-03-31T10:37:39.390868Z" } }, "outputs": [ @@ -37,19 +37,23 @@ } ], "source": [ - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", "# in the schedule are of the expected type and the definition of the vehicle\n", "# is preserved\n", - "n.read_matsim_schedule(\n", - " os.path.join(path_to_matsim_network, 'schedule.xml'),\n", - " os.path.join(path_to_matsim_network, 'vehicles.xml'),\n", - ")\n", "n.print()" ] }, @@ -72,8 +76,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.825230Z", - "start_time": "2021-03-15T10:18:29.626301Z" + "end_time": "2021-03-31T10:37:44.705805Z", + "start_time": "2021-03-31T10:37:44.478958Z" } }, "outputs": [ @@ -82,7 +86,7 @@ "output_type": "stream", "text": [ "attribute\n", - "├── id: ['3320940063', '1230997208', '110029', '3113617873', '452149725']\n", + "├── id: ['1611082162', '4870807519', '6521887917', '21645238', '1104496346']\n", "├── x: [528387.4250512555, 528391.4406755936, 528393.2742107178, 528396.6287644263, 528396.3513181042]\n", "├── y: [181547.5850354673, 181552.72935927223, 181558.10532352765, 181559.970402835, 181562.0370527053]\n", "├── lon: [-0.15178558709839862, -0.15872448710537235, -0.13569068709168342, -0.13766218709633904, -0.13543658708819173]\n", @@ -100,8 +104,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.944072Z", - "start_time": "2021-03-15T10:18:29.827731Z" + "end_time": "2021-03-31T10:37:44.852403Z", + "start_time": "2021-03-31T10:37:44.710190Z" } }, "outputs": [ @@ -196,8 +200,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.954643Z", - "start_time": "2021-03-15T10:18:29.947226Z" + "end_time": "2021-03-31T10:37:44.868860Z", + "start_time": "2021-03-31T10:37:44.859676Z" } }, "outputs": [], @@ -210,8 +214,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.966571Z", - "start_time": "2021-03-15T10:18:29.956997Z" + "end_time": "2021-03-31T10:37:44.881475Z", + "start_time": "2021-03-31T10:37:44.871442Z" } }, "outputs": [ @@ -246,8 +250,8 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:29.995815Z", - "start_time": "2021-03-15T10:18:29.968578Z" + "end_time": "2021-03-31T10:37:44.909440Z", + "start_time": "2021-03-31T10:37:44.883346Z" } }, "outputs": [ @@ -283,8 +287,8 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.024054Z", - "start_time": "2021-03-15T10:18:29.997685Z" + "end_time": "2021-03-31T10:37:44.962024Z", + "start_time": "2021-03-31T10:37:44.911395Z" } }, "outputs": [ @@ -320,8 +324,8 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.077256Z", - "start_time": "2021-03-15T10:18:30.026875Z" + "end_time": "2021-03-31T10:37:45.076700Z", + "start_time": "2021-03-31T10:37:44.976406Z" } }, "outputs": [ @@ -414,8 +418,8 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.082308Z", - "start_time": "2021-03-15T10:18:30.079423Z" + "end_time": "2021-03-31T10:37:45.094658Z", + "start_time": "2021-03-31T10:37:45.084863Z" } }, "outputs": [], @@ -428,8 +432,8 @@ "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.113859Z", - "start_time": "2021-03-15T10:18:30.084037Z" + "end_time": "2021-03-31T10:37:45.137177Z", + "start_time": "2021-03-31T10:37:45.096348Z" } }, "outputs": [], @@ -444,8 +448,8 @@ "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.120806Z", - "start_time": "2021-03-15T10:18:30.115427Z" + "end_time": "2021-03-31T10:37:45.155079Z", + "start_time": "2021-03-31T10:37:45.139834Z" } }, "outputs": [ @@ -469,8 +473,8 @@ "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.127795Z", - "start_time": "2021-03-15T10:18:30.122834Z" + "end_time": "2021-03-31T10:37:45.171777Z", + "start_time": "2021-03-31T10:37:45.159752Z" } }, "outputs": [ @@ -502,8 +506,8 @@ "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.167252Z", - "start_time": "2021-03-15T10:18:30.130456Z" + "end_time": "2021-03-31T10:37:45.370148Z", + "start_time": "2021-03-31T10:37:45.177633Z" } }, "outputs": [], @@ -518,8 +522,8 @@ "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.182797Z", - "start_time": "2021-03-15T10:18:30.173357Z" + "end_time": "2021-03-31T10:37:45.382627Z", + "start_time": "2021-03-31T10:37:45.373845Z" } }, "outputs": [ @@ -543,8 +547,8 @@ "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.191602Z", - "start_time": "2021-03-15T10:18:30.185395Z" + "end_time": "2021-03-31T10:37:45.394260Z", + "start_time": "2021-03-31T10:37:45.385045Z" } }, "outputs": [ @@ -579,8 +583,8 @@ "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.247273Z", - "start_time": "2021-03-15T10:18:30.194704Z" + "end_time": "2021-03-31T10:37:45.530868Z", + "start_time": "2021-03-31T10:37:45.397475Z" } }, "outputs": [], @@ -597,8 +601,8 @@ "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.255029Z", - "start_time": "2021-03-15T10:18:30.249383Z" + "end_time": "2021-03-31T10:37:45.539903Z", + "start_time": "2021-03-31T10:37:45.533474Z" } }, "outputs": [ @@ -622,8 +626,8 @@ "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.263299Z", - "start_time": "2021-03-15T10:18:30.258755Z" + "end_time": "2021-03-31T10:37:45.548412Z", + "start_time": "2021-03-31T10:37:45.542145Z" } }, "outputs": [ @@ -647,8 +651,8 @@ "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.308510Z", - "start_time": "2021-03-15T10:18:30.266592Z" + "end_time": "2021-03-31T10:37:45.648114Z", + "start_time": "2021-03-31T10:37:45.551037Z" } }, "outputs": [], @@ -665,8 +669,8 @@ "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.319073Z", - "start_time": "2021-03-15T10:18:30.311738Z" + "end_time": "2021-03-31T10:37:45.665497Z", + "start_time": "2021-03-31T10:37:45.654449Z" } }, "outputs": [ @@ -704,8 +708,8 @@ "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.363660Z", - "start_time": "2021-03-15T10:18:30.321020Z" + "end_time": "2021-03-31T10:37:45.726123Z", + "start_time": "2021-03-31T10:37:45.671592Z" } }, "outputs": [], @@ -720,8 +724,8 @@ "execution_count": 22, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.375895Z", - "start_time": "2021-03-15T10:18:30.367130Z" + "end_time": "2021-03-31T10:37:45.739037Z", + "start_time": "2021-03-31T10:37:45.728212Z" } }, "outputs": [ @@ -745,8 +749,8 @@ "execution_count": 23, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.388727Z", - "start_time": "2021-03-15T10:18:30.382557Z" + "end_time": "2021-03-31T10:37:45.754732Z", + "start_time": "2021-03-31T10:37:45.746797Z" } }, "outputs": [ @@ -779,8 +783,8 @@ "execution_count": 24, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.426738Z", - "start_time": "2021-03-15T10:18:30.391945Z" + "end_time": "2021-03-31T10:37:45.816146Z", + "start_time": "2021-03-31T10:37:45.759336Z" } }, "outputs": [], @@ -798,8 +802,8 @@ "execution_count": 25, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.433426Z", - "start_time": "2021-03-15T10:18:30.428197Z" + "end_time": "2021-03-31T10:37:45.827652Z", + "start_time": "2021-03-31T10:37:45.821268Z" } }, "outputs": [ @@ -823,8 +827,8 @@ "execution_count": 26, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.440304Z", - "start_time": "2021-03-15T10:18:30.435494Z" + "end_time": "2021-03-31T10:37:45.840940Z", + "start_time": "2021-03-31T10:37:45.834459Z" } }, "outputs": [ @@ -855,8 +859,8 @@ "execution_count": 27, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.469619Z", - "start_time": "2021-03-15T10:18:30.443417Z" + "end_time": "2021-03-31T10:37:45.897404Z", + "start_time": "2021-03-31T10:37:45.844590Z" } }, "outputs": [], @@ -874,8 +878,8 @@ "execution_count": 28, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.477488Z", - "start_time": "2021-03-15T10:18:30.471082Z" + "end_time": "2021-03-31T10:37:45.909928Z", + "start_time": "2021-03-31T10:37:45.900769Z" } }, "outputs": [ @@ -899,8 +903,8 @@ "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.486288Z", - "start_time": "2021-03-15T10:18:30.479935Z" + "end_time": "2021-03-31T10:37:45.919353Z", + "start_time": "2021-03-31T10:37:45.912702Z" } }, "outputs": [ @@ -931,8 +935,8 @@ "execution_count": 30, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.512400Z", - "start_time": "2021-03-15T10:18:30.487830Z" + "end_time": "2021-03-31T10:37:45.961211Z", + "start_time": "2021-03-31T10:37:45.921950Z" } }, "outputs": [ @@ -963,15 +967,15 @@ "execution_count": 31, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:30.567853Z", - "start_time": "2021-03-15T10:18:30.514789Z" + "end_time": "2021-03-31T10:37:46.072882Z", + "start_time": "2021-03-31T10:37:45.964886Z" } }, "outputs": [ { "data": { "text/plain": [ - "['1230997208', '3113617873', '1611082199', '21665580', '1684410079']" + "['1611082162', '6521887917', '1104496346', '21665081', '25508738']" ] }, "execution_count": 31, @@ -1000,23 +1004,14 @@ "execution_count": 32, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:31.622875Z", - "start_time": "2021-03-15T10:18:30.570574Z" + "end_time": "2021-03-31T10:37:48.277837Z", + "start_time": "2021-03-31T10:37:46.075804Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - } - ], + "outputs": [], "source": [ - "from genet.outputs_handler.geojson import generate_geodataframes\n", - "gdf_nodes, gdf_links = generate_geodataframes(n.graph)" + "_ = n.to_geodataframe()\n", + "gdf_nodes, gdf_links = _['nodes'], _['links']" ] }, { @@ -1024,8 +1019,8 @@ "execution_count": 33, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:31.647067Z", - "start_time": "2021-03-15T10:18:31.627826Z" + "end_time": "2021-03-31T10:37:48.319423Z", + "start_time": "2021-03-31T10:37:48.279653Z" } }, "outputs": [ @@ -1051,16 +1046,16 @@ "execution_count": 34, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:32.131728Z", - "start_time": "2021-03-15T10:18:31.650576Z" + "end_time": "2021-03-31T10:37:49.521733Z", + "start_time": "2021-03-31T10:37:48.334027Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,\n", - " )" + "(,\n", + " )" ] }, "execution_count": 34, @@ -1069,7 +1064,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1081,7 +1076,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1101,19 +1096,11 @@ "execution_count": 35, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:33.260036Z", - "start_time": "2021-03-15T10:18:32.135933Z" + "end_time": "2021-03-31T10:37:52.265617Z", + "start_time": "2021-03-31T10:37:49.524175Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "data": { "text/plain": [ @@ -1138,16 +1125,16 @@ "execution_count": 36, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:33.750380Z", - "start_time": "2021-03-15T10:18:33.261889Z" + "end_time": "2021-03-31T10:37:53.077524Z", + "start_time": "2021-03-31T10:37:52.267883Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,\n", - " )" + "(,\n", + " )" ] }, "execution_count": 36, @@ -1156,7 +1143,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1168,7 +1155,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATEAAAD4CAYAAACE9dGgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3hb1fnHP0eS9947nvHMjrPJ3owASQij7BCgtKz217JXacsskELZoQ1QIGxIyHL2HnZix9uO997blmVJ9/fHlU2AJJZt2U7o/TxPHktXV0dXjvT1ed/znvcrJElCQUFB4WJFNdwXoKCgoDAQFBFTUFC4qFFETEFB4aJGETEFBYWLGkXEFBQULmo0w30BlsbT01MKCQkZ7stQUFCwMElJSbWSJHn9/PivTsRCQkJITEwc7stQUFCwMEKIorMdV8JJBQWFixpFxBQUFC5qFBFTUFC4qFFETEFB4aJGETEFBYWLGkXEFBQULmoUEVNQULioUURMQUHhokYRMYUhZ092NaOf2sbHhwuH+1IUfgUoIqYw5LRq9bR06ilp6BjuS1H4FaCImMKQY2etBkCrNw7zlSj8GlBETGHIsbOSRUzXZRjmK1H4NdCriAkhPhBCVAsh0s44Nk4IcUQIkSyESBRCTDYd/40Q4pQQIlUIcUgIMfZnY6mFECeFEJvOOBYqhDgqhDgthNgghLA2Hbcx3T9tejzEUm9aYXhxsJFFrFOZiSlYAHNmYv8Blvzs2IvAM5IkjQOeNN0HKABmS5I0GngWePdnz7sfyPzZsReAVyVJigAagNWm46uBBtPxV03nKfwKsLOWm6foDIqIKQycXkVMkqR9QP3PDwPOptsuQLnp3EOSJDWYjh8BArufIIQIBC4D3j/jmADmAV+aDq0HrjLdvtJ0H9Pj803nK1zkdOfEdMpMTMEC9Lef2APANiHEy8hCOP0s56wGtpxx/zXgz4DTGcc8gEZJkvSm+6VAgOl2AFACIEmSXgjRZDq/9ucvJIS4E7gTYMSIEf18SwpDhYOVMhNTsBz9Tez/FnhQkqQg4EFg3ZkPCiHmIovYQ6b7lwPVkiQlDeBaz4kkSe9KkhQvSVK8l9cvGj8qXGDYW8sfuy5lJqZgAforYrcAX5tufwFM7n5ACDEGOWS8UpKkOtPhGcAyIUQh8BkwTwjxMVAHuAohumeEgUCZ6XYZEGQaU4MctnaPp3ARY2vKiXUpMzEFC9BfESsHZptuzwNyAYQQI5DF7SZJknK6T5Yk6RFJkgIlSQoBrgN2SZJ0oyTbj+8GVppOvQX4znT7e9N9TI/vkhS78l8VnYqIKViAXnNiQohPgTmApxCiFHgKWAOsNc2QtJjyUcgrlR7Am6YcvF6SpPheXuIh4DMhxF+Bk/wYmq4DPhJCnEZeWLiuD+9L4SJAr7+4/yb9/pMTuNlb8+xVo4b7Uv6n6VXEJEm6/hwPTTzLuXcAd/Qy3h5gzxn38zkjHD3juBa4prfrU7g4EUCXcfBnYnd/lMjOrGpy/3apxcfemlaJp6MiYsONUrGvMCwIAXrD4M/EmrV6ugwS7Tp97yf3Aa1Oj94o4e9qZ9FxFfqOImIKw4IQAv0QzMTsTTVpdW06i46bWCSXQ4Z7O1p0XIW+o4iYwrCgEjAUFRYONnLGpKm9y6LjJhXLIjY6wMWi4yr0HUXEFIYFlRAYhmB10tEkYg3tlp2JZZY3AzA5xN2i4yr0HUXEFIYFlRDojYOfExssESusawcg0kcJJ4cbRcQUhgWVAMMQlP052coi1mzhcLKqWYutlQqVSvkKDTfK/4DCsKBSCQxDMBNztrMCoElr2dXJFq0ed3tri46p0D8UEVMYFtQqgXEIRMzFJGLNHZabibVq5fKKADelvOJCQBExhWFBIwRDoGG4mkSsrdNyM7HEIrkzVYSXkg+7EFBETGFYUKsExiHIibk5yCFfa6flWmGfMNWIjQ50tdiYCv2nv/3EFBT6RVpZE+/sy6OmpRNrzeD/DXWzk0WsrdNy4WRmhVxeMSVMKa+4EFBETGHQ2Z9bw7oDBRwrqKddJ8+IBLLbUU5VC5E+TucfYAB0z8S6X9cSFNXL5RWhHvYWG1Oh/ygipmBxjEYj3yVXsCGxmBNFjT0dXO2s1FwS4cGt00No79Rz34YU3tufz0srx/YyYv9xNJVYtFvQWam6uRM7K7VSXnGBoIiYgkWob9XxwcECtqRVUFDbhlECB2s1NlYq5kZ5sWZWGPFnVLcbjUYe/DyFvdk1Q3J9WguKWItWj5+rrcXG+18ipaSRd/fnc8UYf5aM8rXImIqIKfSbU6WNrDtQwMHcWmrP2GDt52LLnEgv7pgVSrjX2UNFlUpFuLcjOVWtNLXrcBnEmiuVAG2XZbY4NbXrMEgSAUr3CrMxGiV2ZVXz7v58jhXU42SjYXqYB5IkYQnvH0XEFMxGrzfyXUoZnyeWklLa2CMMapUgxs+JK8cGcOPU4J4QrjcuG+NHTkIu6w8Xcd/8kYN23SohLOZxebxQLq8YqXSv6BVtl4FvT5bx3v588mra8Hex5fHLYvB1tmXdwQLCvR2ZGuYx4Ncxp7PrB0C30cco07FxwNuALaAH7pEk6ZgQ4jfInVoF0AL8VpKkFCGELbAPsDG95peSJD1lGisUue++B5CE3NpaJ4SwAT5Ebr5YB1wrSVLhgN+xQp84W5gI4GijZnakFzdNHcG8aO9+5YdunRbCqwm5bDpVPqgiplYJdHrLhJMnihsBGBOklFeci4Y2HR8fKWL94UJqW3XE+Tvz6rXjUAl4e28+mRXNBLjaWax2z5w/mf8B3kAWlG66zXO3CCEuNd2fw4/muQ1CiKXI5rlTgE5gniRJrUIIK+CAEGKLJElH+NE89zMhxNvILklvcYZ5rhDiOtN51w78LSv0RneYeCC39id9uPxcbJkb5cXqmWGEW6DQ08XeGm8nG/KqWzEajYOWKNeohcVMSbIq5fKKaaEDn0H82iiqa2PdgQI+TyxB22VkTpQXt88IpbKpg9d35ZJf00aYpwMvrRzDVeMDsFJb5v/bnPbU+4QQIT8/zDnMc884p8c812Tw0Wo6bmX6J51hnnuD6bH1wNPIInal6TbI5rlvCCGEYhZiebrDxA2JpZyyQJjYF2ZHevFFUimbUyu5fKy/xccHsFKrLGbUW1TXgQCClPKKHk4WN/De/ny2plWiVgmuGhfATdOCSSlp5JGvUylr7CDGz5l/3TCBJaN8Uass64E9ZOa5Qgg1crgYAfxLkqSjQghPLGCeq9B36lt1rDtYwNZBCBP7wupLQvkiqZRPjxX3W8RatXqatDpaOrpo6tBT366jsb2Lji4DTe06OrsM6C00E6tp0fY4mP8vYzRK7Mis4r39+RwvbMDZVsPds8O5ZmIgCZlVrF6fSE1LJxNGuPLsVXHMjfK2SBL/bPRXxLrNc78SQqxCdiZa0P3gGea5l3QfkyTJAIwTQrgC3wghRgGV/b7yM1AcwM0jpaSBDw4WDnqY2Bei/Zyxt1ZzsqSxX88/WdzAde8eoVNvxNFG/ZPtRTZWKjpNs0qNgG9PlnHV+IBzDWUWrZ16Av+HVya1XQa+PlHG+/vzya9tI8DVjicvj2VJnC9fJJVy9VuHaGzvYkaEB2uvG8e0MI9BE69u+ititwD3m25/gWyWC/zEPHfpGea5PUiS1CiE2A0sAf6ByTzXNBs7m3luaW/muZIkvYucfyM+Pl4JN00MZ5jYF8YHuXIwr46MiiZi/frW7vmdvXl06o3MCPcgwNUOoRI42mhwstXgam+FvbWGb06UcjS/ngc2JFPb2skdM8P6dZ31rTqMEgS6/7pDSUmS2JNTg4+TLbH+ctaovk3HR4eL+PBwIXVtOkYHuPD69eOJD3Fj/aEiFr22j9ZOPQtivLlnbgQTRrgN2fX299PbbZ67BzPMc4UQXkCXScDsgIXAC5IkSSZBW4m8Qnk289zDKOa5ZtMdJm5JraCwbvjCxL5w/eQRHMyrY93+Av6xalyfnuvhaAPA3XPCmTnS66zn5Ne0kVjUwNJYX/76QyZVzVoeWRqDqo+5maOF8t/QkYO4TWq4SS5p5PktmRzJr2f5hADunTeSdQfy+TKpFG2XkfnR3qyZFUaQmx3v7S/g/75IQWcwctloP343N4IYP+feX8TCDJV5rh+w3pQXUwGfS5K0yfQcxTx3gKSUNLDuQCEHT184YWJfuHS0L+rPYF9u39OdXk6yiJU3dpzzHEcbNV0GiZevGYunozXv7S+gpqWTF1eO7dMm9GSTOci4X2H3ivyaVl7ens3mVNlL846ZoRTVtjHvH3uwUqm4enwAd8wMxUqt4q09eXx9shRJgqvHB/DbOeGEDePna0jMcyVJOgWMP8f4inluHzEajXyfUsHGU+UcPF3bEyZqVIJYPyeWXSBhorkMpHrfx1ne/lPZrD3nOd199rVdBp5eFoeHow2vJORQ3thBhI8Twe72BHvYE+zhwAh3+x6HpJ+TVSkvsE/9FXWvqG7WsnZnLp8dL8FGo+LyMX6UNnTw/v4CXOys+N2cCG6eHkxDWxev7zrNplPlaNQqrp88gjtnhRHoNvyh9cXxKVegVavnwyOFfHeynNPVLXT7zqqFuGDDxL5w+Rh/XknI4d+HCnlgQaTZz/N3kUWsprnznOd0i1Jrp57a1k52Zlb13N+SWkHDz/rvezramETNnmB3h57bBbVtAPj9ChL7Ldou3t2Xz/v7C+gyGIkPdqO8sYNNpyoIcrfj6StiWTUpiNyqVh77Jo2EjCocrNWsmRnG6pmheDtdOHtHFRG7gClrbOedvfnsyKiivOnHmYaXkw1zorzYmFKOQLD+9l9MZC86bpkWzCsJOfxwqqJPItadZD+fOW73TOyDAwX892gxDjZqXr9+PJeP8UMIQVNHF8V17RTVt1FU105RnfzzcF4dX58o+8lYvs42/Xh3Fw6degOfHC3m9V2nqW/TEentSFVLJ0cL6hkb6MLDS2NYFOtNUnEjd32UxP7cWlzsrLh//khumxGCq2mWXN2ivWCETBGxC4zuwsFDp+toNPWFFwJCPR24bLQfd8wM/fGD1NzJ3pwakooamBg8dKtBg0FP9X5N36r3A0wzsfNZsnWH1f8+VMiSOF+evWpUTy4N5D78owNdGB34y5VRbZeBkvp2iura+cPnycyIOPviwYWO0Six8VQ5L2/PpqS+Ax9nG6zUgpzqVhbE+HDnrDDig13Zm1vL9e8dJbGoAU9HGx5eGi2nJmw0tGi7+OxYMZ8nlpBW1szRR+f39GsbThQRG2aMRiObUiv45GgxySU/lkFYqQVjg1xYFR/ENRODzpqAvn1GCHtzanhvXx4Tb4of6ku3OLOjvPgisZSNpyq4cpx59Vy21iaH7/MYgdhbaXCy0XDTtBH8aXF0n+qWbK3UjPRxItDNnmatnpCLrFJfkiT259by/JYsMiqaeyzs6tt0rJwYxOpLQgnzdGBbeiXL/nWQtLJm/F1seWZZHNdOCsJGo+JoQT2fJ5awJbWSji4DI70d+dPiKNTqwa3/MhdFxIYBrU7P+sNFfHuyjJyq1h7/RQcbNXOivLh1eghzorx7HWd2lDfWahWH8s5aPnfRsWZmGF8klvLZsRKzRQzkurfW81iy2VipaOnUM36Ee78LL4tN3VyDPR369fzh4FRpI89vyeJQXh3Wpn2KKgH3zYvgpmkhuNlb8X1KOXd/nMTp6lZCPR14cYW8r7G2tZP39uXzRVIpxfXtONlouHpCAKvigxgb6DLoBax9QRGxYeCbk+U8tyULAE9Ha2ZHerFmZhjR/aixGRfkwrHCBk5XtRBxkdcvRfo4YW+tJrmP1fvWahVt52k/3T2LHcj+ycI6Oal/MczECmvbeGFrFlvSKukuhfN1sWHNzDBWTAxErRJ8mVTK23vzKKnvINrXiX9eP5750d7syqpm9frjHDhdiyTB9HAPHlw4kiVxfhfsditFxIaBzxKLAfju99MZGziwXNaN04I5VtjAW3vz+lwoeiEyMdiN/bm1pJU1MSrAvOp9GyvVeTu32phErHMA7XiK60wzMfcLdyZW09LJi1uz+OpEaU+R86gAF+6ZE87CWN+epP57+/Opau5kbJArT1wWi6+LLV8mlfLEt2k0dXQR4GrHvfNGcs3EQIIugt0JiogNA9fGjyClJJUvE8sGLGKXj/bjwQ0p7B6iNs+DzQ1TRrA/t5Z1Bwp49VrzRNneSn3e3lSWmom52lvhYm/V7zEGi9ZOPS9syeLTY8XoTeo1e6Qn984fSXyIO00dXby15zQfHCykvk3H1DB3nr4ijvLGDl7dkUtmRTPWGhVL4nxZFR/E9HCPPu9mGE4UERsGVk0M5PFvU9mRWcWzV40a0FgqlYoYXyfSypupaOy46GuYFsf6oBaC/bnmi7KjrYaKpnMXu9po5DBoIN1di+raCfa4sGZhnV0GXtiazcdHCtEZJFQCrhjjx4MLIwnzcqSuVZ6ZfXS4iJZOPXMivZge4UFySSP3fXaSLoPEmEAXnr1qFMvG+F+QAm0OiogNAxqNijAvR05XW6a//HWTgnj8u3Te3pfPM8viLHSVw4NKpWKkjyNZlS00tut6yknOh7OtFRLyhnfNWVZxrQcYTkqSRGWzFpcLaAfEfw8X8cwPGej0RjQqwbWTgvjz4ig8HG2oaOrgmY3pfHqsmE69kVkjvfB2smFfbg17cmpwd7Dm5mkhXBMfSLTv0O91tDQXZ3n3r4Blpt5Z/z5UOOCxrps0ApWA7ekW6Ww07Fxh+t18cKDArPNdTTOIqtazz8ZsBhhOljZ0cLq6lVNlTQPKq1mCjPJm/vxlCh8dLUSSJG6eFkzq04t4YcUY2joNPPJ1KjNf2MX6Q4WM9HYi2teJvTk1fHWilDh/F96+cQJHHpnPE5fH/ioEDJSZ2LBx24wQXknIYWNKeZ8q1M+GpWd2w83N04J5aVs2P6RW8odFUb2e724quCyt7yDA9ZeJaI1KIET/w8nEItkcpMsgkVTYwPQIz36N01+6DEa2pVfy4aEijhXWY2ul4g8LIvnNlBE42FqRWd7MQ1+fIrW0qec5EpBaJt+/YUoQ98+P7Nln+mtDEbFhwsnWCn8XW/Jr29DpjX3qpnA2rh4fwEvbsuX2KIt7/+JfyDjZWuHjbENBrXnV+16m7S/ljWefiQkhsNGo+i1ixwsbcLLV0KHTszenZshErLpFy6dHS/jkWBFVzZ0Eudvx2KUxrIoPwsFGzf7TtXyZVEpqaSPF9R3YWamZEOxKfLA7owNckIA1HyayNa2Kv145sNzr2cgob+LFbdlkV7Zw+JH5Fh/fXBQRG0YWxvmy/lAhXySV8JspwQMa65ZpIby0LZuNp8ovehEDmBPlzYbjJXyXXMHVE85f+Opj2s9Y0Xzudjw2GnW/w8nEwnomBruh0xvZm1PDI5fG9Gscc5AkiRPFjXx4uJDNqRV0GSRmR3rx3PJgZkd6k1vdwhu7c/k2uZyalk5c7a24Z044s0Z6EuXr/Isi1EWxPmzPqOIvmzJ52gL50hZtF2t35vL1iTLqTftVHWzUw7qopIjYMHLnrFDWHyrk8+MDFzFHWw0j3OwormtHq9P3bMe5WFlzSSgbjpfw2fHiXkWs28i2+oxOFnqDkYomrbyhu74Ng1HqVz6rsV1HTlUrV44LQKMSPLcli8omLb4ulgvNjEaJ3OpWjhbU8nliKWllzTjZaLhxajA3TQ3GyVaurH952wEyKpqxUgvmRnmzfEIg86K9zzuLf+OGCYx9ZjvrDxeyekZovwxOjEYj3yVX8M6+PLIrW5CQK/8njHDl/vkjmW3G7pLB5OL+pF/kONla4WCtJr282SLjLR3txzv78vnoSBFrZoVbZMzhIsLHCQdrNSmlvVfve5tmYruzqsmraaW4vp2yho6emimQ82Lu/disnFQkN0KMD3bDxd6K57ZksS+nhlWTgvo8VjddBiNpZU0cK6jneGE9xwsbaOrokvfLBrry16tGcekoXw7n1/O3HzLZk1ODwSiXQzyzLI4rxvqb/V6sNSqeXzGa+z9L5tb/HGPnH+eYfZ05VS28uDWL/bm1PaG4v6sdv5kygjUzwwacArEUiogNMU3tXSRkVrEltYL9ubXoDEbunRdhkbHvmhXOO/vy+TKp7KIXMYAJpur9U6WNjDlHN9W9OTU89W0qTjZqats6cbG3YnSAC5eN9iPYw54R7g4Eutkx+6XdqPqx3+94YYNpM74rNhoVvs627O2jiHXoDJwsbuCoSbROFjfSYdphEObpwJI4XyaFujM5xI2alk6+OlnGi1uzaNbq8XW2lbcLTQjod1vsK8cFsO5AAadKm1h/qJBbpoec89wWbRfb0yu5YmwAi17dB4C9tZplY/3505Iogi6AJog/Z6gcwIOQzXd9kBdO3pUkaa1pLHdgAxACFAKrTOa7AlgLXAq0A7dKknTCUm98KGlo05GQUcXmtAoOnq6lyyDh72LLTdOCuXS0L+ODLNNGx93RGh8nG3KrW85ZM3UxcePkIJJLGvnvkSLGrPypiJXUt/Pspgy2Z1QR6unAP68fz9xoHyRJorG9i7LGDiqatORUtbAlrQKjJM+qPjtWTJiXI2FeDng4WPe6kTmxsJ7RAS7YWskFs7MjvdiSVoHeYERzDvPXxnYdiYUNHCus51hBPWllTeiNcjFqjJ8z104KYnKoO5NC3HG203A0v55dWdV8eqyIpKJGbK1ULB3lx/IJAUwP97SIT+MHt8Yz5W+7+OsPGSyfEICT7Y+FrUajkQ2JpXxwoIDT1a1IyFu5ABys1Rx/fAH2F3B6YqgcwPXAHyVJOiGEcAKShBAJkiRlAA8DOyVJel4I8bDp/kPAUmCk6d8UZEPdKQN9w0NFbWsn29Or2JJWwaG8OgxGiSB3O26fEcrS0X4/6QRwyfO7KG3s4PRfF6PRDOzDsjDWh4+PFvPVyVKunXRx29ctjPOl/dNkdmb9WL3fqu3ipW05fHK0CIS8QdnXxZZ1Bwp59odMyhs7etoZdaMRoFHBkfy6n3T8cLbVEOrlSLinA2FeDoR5ORLq6UCopwO2Vmq0XQZOlTZx24yQnufMjvJiQ2IJKaWNTAyW21RXNmlNglXH8YIGsqtaAHlj+tggF+6cFcakUHcmBrvhbGtFdbOW3dnVPP5tKvtza2nXGbDRqLA1CccfF0axZlb/HJnOhaejLfctiODVhFzu/DCJT++cyrGCOtbuyOVoQX1P6B3oZsf1k0ewKNaPayfVseF4CZeu3c+uP86+YLsGD5UDeAVQYbrdIoTIRDbHzUB2+p5jes56ZAelh0zHPzQ5HB0RQrgKIfxMY12QVLdo2ZZWyebUSo4W1GGU5K4Hd80K49LRfsT5/3L1CKD7s/HithwevSx2QNdw15xwPj5azCfHii96EVOpVIR7OZBT1coLWzJJLmkitayJ1jP2SR7Or8PL0QZ/VzuifZ2YF+WNn6sdAa62+Lva4edih8FgZOrzu3j2qjhmj/Qmr7aVgpo28mtbya9p41BeHV+f/LGDqxDg72KHp6M1OoORkoZ23t6bh5OtBo1KoBLwxq7TuDlYc7ywnpJ6eVXU0UbDhGA3rhjrx6QQd8YGuWJrpcZolEgrb2Ld/gJ2ZVX31G/5u9hy9fgA5sd4My3MkxZtF9Oe38ULW7NYMSEQd0fL1vvdPz+Sz46VcDi/jujHN6PVy8LlbKth8Shf/rAg8icrjC+sGENhbRtHC+q5cd0xPlkz1aLXYymEOS5oJhHbdEY4GQNsQw4bVcB0SZKKfvac/wOiTeYhPx9rHzBKkqRmIUSjJEmupscE0CBJkqsQYhPwvCRJB0yP7QQekiQp8SzXd6Z57sSioqKfnzJoVDZp2ZpWwea0So4X1iNJEO4ld2FdOtqPaF+nXkOWb0+W8sCGFFztrUh+ctGAr2n8X7bTotWT89clF+xfz/PR1NHFnuxqEjKq2J5egcEIBgni/J2ZHOpOoKsdowJc8He1w0ajIqO8mfSKZtp1etp1Bto7DbR3GejQ6WnrNNDcoSOnqoURHg5MD/ckxNOBUE/ZGCTIzR5rjYq2Tj0FtW3k17aRX9NKQW0bx/LraezQoe0y8vNviUYlcLGzYlKIuymf5U6Mn1NPiNnaqedAbg27sqrZlVVDbWsnQsCEEW7Mi/ZmXrT3WT8b7+3P428/ZBHn78wP9820yO/TaJQ4nF/Hl0mlbD5Vjs4gIQHTw9z5w6Io4kPObXxiNBqZ+/JeiurbuWFyEH9fPsYi19QfhBBJJve0nzBkDuCm447AV8ADkiT9YknO5EPZZ2/JoTbPLWvsYEtqBVvSKntWr6J8nLh//kguHe1HZB8TsFeND+SBDSk0tp+7O2lfmB3pzbfJZWzLqGLpKD+LjDnYlNS3syOzioSMKo6ZwhtPR2suGx3AN8llRHg58sN9MzEYJVLLmtibXcPenGqSSxqRkP+aCiGwt1Zjb63GwVqDnem2i4M1XUZo1xn4NrmMljMaKKpVggBXO0I8HQjxsCfEw4Gxga5cOS6Al7ZlkVLSxIGH5tKuM9Ci1dOi7aKlU4+Psy3+LrY/EaGiujZ2ZlazO7uaI/l1dBkknGw1zI70Yl60N7MjvXp8Ms/FmpnhfJFYSnp5Mx8eLuTmaSH9/p3m17Ty1YlSvjlRRnmTFmdbDSvjg6ht6WRbRhW21urzChjIs+Ef7pvJjBd28smxEkI9HS64RaP+zsSaAFeT6AigSZIkZ9NjY4BvkB3AzzTQtQI2AdskSXrljOPZwBxJkiqEEH7AHkmSooQQ75huf/rz8853rfHx8VJi4i8mawOmuK6dLaYZV4qpaV+snzOXjvZlySg/IrwH5rs36smttOoMbFgzlSnhHgMaK6uimSVr9zMtzINP77wwQwCjSYwSMqrYkVlFVqWcRxrp7ciCWB8WxvowLtAVlUow/i/baero4vLRfuw/XUtDexdCwJhAV2ZHejEnyotoXyfsrNRnnfXqDUYiHtvCHxZGcu+8COrbdBTWtVNY20ZhXRsFtbIxSGFtGy1nhKpWpvbLdlZqVCqBSghTk0H5p0oIBBJavREHGw2lDXJYGe7lwPwYH+ZGeRMf4obVORYAzkV1sxcAGSAAACAASURBVJZpz+9CAMceXdCnsLKpo4tNp8r5KqmUE8WNqIS8GLFiYiALYnxM4a2Rqc/torqlk3W3xDM/xqfXcUsa2pn/8l50BiPv3jSRRXG+fXpPlsDSM7G+OoAL5Nla5pkCZqLb6ft5fukA/nshxGfICf2moc6HFdS2sTm1gi1pFaSVyRPHMYEuPLQkmqWjfAmxYKvieTE+fJ9SztOb0tly/6wBjRXt54yjjYYTJrPXCwVtl4HDeXVsz6hiZ2YV1S2dqARMCnHn8ctiWBDjQ4inA116I0nFDby8PZu9OTU0tHehUQkOnK5lbpQ3s6O8mDnSy+xaKY1ahVol0HYZEELg4WiDh6PNL8xVJEmirk1HYW0be3NqeH3XaS6J8CTC2xFJkjBKYDT9lCQjxXUdpJU30azV06EzoFbBuzeZJwrnw9vZloeXRPG3zVnc9MHRXsNKvcHYswUpIaMKnd5IlI8Tj14azVXjAvD+2Z5JlUrFh7dPZuna/fz+k5OcfGJBr8XRQW72fLJmCqveOcxvPz7BxntnEOtvXtPKwWaoHMBnADcBqUKIZNO5j0qStBlZvD4XQqwGioBVpsc3I5dXnEYusbhtYG/VPE5Xt7A5tZLNqRU9s4NxQa48emk0S0f5DVqny79fPZrvU8rJrWq1yHjTwtxJyKzmSF4dUwc4sxsI9a2d7MquISGjsmclzsFazewoLxbG+jAn0hs3B2uatV3sza7hlYQcDuXV0tqpR2+QiPaVQ3NXeyuOPbqg3836bM3YOymEwNPRBk9HG746UYadlZq3b5rYY/kG8gxye0Ylr+3IJauyhQhvR/6+fCSTQtxZ9sYB/rIpg/gQd1zsBtaba82scL5IksPKjw8XcuNZwsrsyhY5XDxZRk1LJ272VtwweQQrJwaecxGpm2g/Z26bEcIHBwtZ81ESH63ufeE/PsSdV1aN44ENySx/6xD7/jT3FwI5HAyVA/gB5LTF2cavA36xe9S0Kvm73q5voEiSRE5VK5tTK9icWkFutSwi8cFuPHF5LEtG+fZsaxlMHG01qFUCvVFCq9VjO8DeVWtmhZGQWc17+/OHXMQKa9tIyJDzW/m1rdS26vB1tmX5hAAWxvoyNcwdG42a8sYONp4qJyGjqieH5OFgzfwYbxbG+DAl3IMVb8oL3v+8bvyAuo12l0yYQ4fOwKaUcpaO9u0RMEmS2JFZzasJOWRUNBPm6cDa68Zx+Rj/njquN38zgWvfOcIfP0/m3ZviB9wd9aPVU5j+3C6e3pjB5WP9cbW3pr5Nx/fJZXx1oozUsiY0KsG8aG9WTAxkbtT5tyD9nCeviGNLmvzHZUtahVn506vGB1BY18ZrO3JZunY/Bx+aO+xb3C7cCrYh4I1duXx9soz8mjaEgMkh7jyzLI7Fcb4W3RtnLt3lBE9sSuellWMHNNbkUA9srVQcKRh8J6Tu/Nb2jEoSMqrIMc0mo32duGHyCBbG+TDKFHpkVrTw9p58EjIre0L0ME8Hbp8RysJYH8aPcOsRhb3Z1eRWtxLl4zTgzhGyiJm3AXxbeiUtnXqumRiEJEnsMc0QU8uaCPaw55VVY1k21v8Xxa4Tg9154vJYnvo+nTf3nOb380YO6Jp9nG15eKkcVi574wDRvs7szq6myyAxKsCZp66IZdlY/14XC87Hx3dMYcEre3lwQzKzI73MKmp9YEEk+TVtfJ9SzrJ/HWTr/TOHdRX8f1rEMita8HOx5fYZoSyK8xl2R+PHL4vh5g+OsyW1YsAiBjBxhBsH8+rIKG+yeP5CpzdyOL+OBJNwVTV3olYJJoXIM9hFsT4EudvTZTByvKCeZzZmkJBRRVljB0LA+CBXHloSzcJYn3Muijz8dSoAa68buAGKjUaF1swN4F8klRDgaktnl4Gr3zxEckkjgW52vLhyDFePDzhvov7macGcLG7gHwk5jAl0ZVZk/812M8qbqWiS84alDR3Ut+q4bUYoKyYEEuVrGWercC9H7p4Vzlt787j9P8f57M5pZj3vn9ePp6i+jZSSJlavT+Tftw2fC/3/tIi9fv3AQhRLMytS7gbQ2mmZ7qG3zQjhYF4db+3N4/XrJwx4vGZtF7uz5PqtPdk1tHbqsbNSMztSzm/Ni5bzWy3aLvbm1PDy9mx2Z1XTrNVjo1FxSYQn986LYH6Mz08cuM/G54klVDRpmRLq3i8ru59jY6WmXXduM5FuSurbOHi6Dj8XW279z3ECXO14bvloVkwINCtUE0Lw9+Wjyaps4b7PTrLx95f0KY9a36bju+QyvjTlw6zVKuZEerEnp4ZOvZF75oSb1bK7Lzy0NJpNp8o5VlDPxpQyrhhrnufnV3dNZ9ZLu9mdXcNfNqbz5BXD0xr9f1rELiQB68bVTkNjh55Np8q4fIz5BrJnY160N1Zqwf7c2n6PUd7Y0VO/dTivrqd+6/IxfiyM9WFGhCe2Vmoqm7RsSq2Q81t5degMRtwdrFkU58vCWB9mjvQ0e/+d0Wjkr5syEMh/8S1BqKc9OzKq+Px4yTk3b0uSxHNbMhFC7jTx7FWjWBUf2GM0Yi721hrevnEiV7xxgHv+e4Iv7p7Ws/fybOgNcp+yLxJL2ZlVRZdBYnSA3LFi2Vh/3ByseW9fHn/bnMWN7x9lk4WKYM/k49WTmf/KXv7vi1PMifL+yd7Kc6HRqNhy/0xmvLCbDw4WEubpcNYFiMHmf1rELkSuHO/P+kPFvL0nb8AiplKpGBXgwsniRorq2sxy65EkieyqFrany8LVvUUmzNOB1TNDWRTrw7ggN1QCsqtaeG9fPgmZVZwytUYO8bDnlunBLIz1ZWKwW782L7+5J49mrZ6lo3wt21JZCP781SmOF9bzlytH/cIM9qVt2WxOrQLghskjuGlq/3u8hXg68Mqqcaz5MJGnv0/n+RW/rHTPrWrhi6RSvj5RRm1rJx4mA4+VEwOJ+dnss3u1Ms0CRbBnI9jTkd/NjWDtztPc9u/jfPnb6WY9z8Xemo2/n8Gi1/bxxHfpBLnbD3l/MbOKXS8mBqvYdajQ6/XEPpWAvY16QFuQdHojnx0v5p29eZQ1arllWgjPXHn26b7eYCSxqEHe5pNR2bMXcPwIVxbF+vbkrfQGI8cK69mRUU1C5o/njQtyZWGsD4tM5w3E4l6vNxL39Db0RomUJxfhaCGHodd25LB2Zy6/nR3Om3vyiPZ14q0bJxJqqvV7Z28ez23JYuXEQL5MKiXEw549f5o74Nd9eVs2b+w+zfPLR3Pd5BE0tXfx/alyvkwsIaX0x9XFlRMDmRvtfd5820CKYM1lzku7Kaxr5+WVY1gZb367oUOna/nN+0dRqwRb7585KG705yp2VUTsAmTlW4dILGpg832X9Ckh39Su44ODBXyfUkFhbdtP9vt5OFiT9MTCnvvtOj37cmpJyKhiV1YVDe1dWGtUzAj3YFGcL/NjvPF2sqW1U8++nBrTedU0dcjnXRLhycJYn57zLMXj36Ty8dFibp4WzF8s2Bf+25NlPLAhmR1/mE1JQzsPbkjGYJB46ZoxNLZ38fDXqVw+xo+1141n7su7Ka7vIO3pxQMWUYNR4tZ/H+NIfh1TQj04VliPTm8k2teJa+KDuHKcP559WF3s2Vvp58wP91s+rCxrbGfmC7tRqwSJjy3ok+nMp8eKeeTrVOyt1Rx6eJ7Fc3eKiF1E7Mqq5vb/HGdBjDfv3zLpvOeWNLTz7t58dmRW/cRA1t/VjiVxPqyZGcbdHyeRUtrE9/fMILOqmYSMqp5unS52VsyL9mZhrA+zIr1wtNFQ3awlwZQHO3Razm+52svnLYr1YeZILxxsLJ+JaNF2Me4vCVipBWlPLbZoP7QTxQ0sf/NQzzabssYO7vnviZ4tZHOivHj3pnisNSpeTchm7c7T3D8/ggcXDtyvoL5Nx72fnOBIQT0rJgRw87SQXotRz8fiV/eRXdXCM8viztvgsL/8a/dpXtqWzYQRrnx9z4w+Pfe5zZm8sy8fHycb9j80z6LdXy297UhhEJkX7Y2dlZoDp8+ekE8ra+KdfXnsz63t2TSuEhDh7ciysf7cNiOkJzFb3aIl1NOBlNImlr15EJB70ss9o3yYFOqORiXIrW5l/aFCtmdU9XyxR7jbc9O0YBbG+hAf7HbOJoCW4k9fpGAwSvxhYaTFGzoGm1YIi+raAfl3sO7meGa9uJvpER68fv2Eni/cmpnhrN15mm9OlllExNwdrHn0shhWvHmI09WtjPQZWMj90erJTHt+F89uyuCyMb54OlpuJtyu0/e4r4f0w/H8kUtjKKhtY3tGFVe/edBinTjOhyJiFyizIz3Zml7F9vRKFsX5sie7mn8fLOR4YT3tOrkEQ6MSjA1y4dr4EayaGNjzxa9r7eTjI0VsOlXO0QK5PZBALvj88rfTiPVzxmCUSCxq4PktWezIrOr5co8NcuX/FkWyMNaXyAF+2fpCRWMH29KrcLGz4rezLdsQEGQhcbLRUFTX1nNs7c5ctHoDDy6M/EmS39FWQ4iHPYV17bRou8xaqeuNOH8XXr12HL/97wke+yaNl1aO6ffv1tvZlkeXRvPsD5nctO7YgPfadrMlrYIHNySj7TIS5GbH/Qv6V6z77s3xLF27j/TyZn77cRJv3fiLzT0WRRGxC5Q/LIpia3oVv/vvCYyShMEU9dtZqbkkwoNbp4cwL9q7p1K6pqWTvdnVfJdS3tNJNszLgXvnjeSKMX488Fky6RXNpJY2su5AAbuzquU8mFrF9AgP7pwVxoIYn2EzWL3/s5NIwJOXxwxK9bcQghEe9hTVy2J9qrSRj48Wccu0EOLOkndcPiGQVxJyeGdvvsUs8JaO9uP++SNZuzOXaF8n7pjZf7FePTOML5NKyaxo4YMDBdx+SWi/x9Lq9Kz5KIn9ubUIAXfNChuwLd13v7uEGS/sYktaJS9uzeLPS6IHNN75UETsAiXSx4lXVo3l2Y3pNHTomTnSkz8sjGT8CLnzgsEocbKkgT3ZNezJriG1rIkpoe5UNGm5a1YYl4/xJ8bPiYb2LnZkVtFlNCKAh79Ow8Fa3VO/1Z0HG04yKpo4VtiAn4stKyb230WoN4I97MmqaMFglHji2zQ8HW34w6Kzu6/fMTOUVxNy+C65zKI+nvfPH0lOVQt/35xJuLcjcwdQjvDRHZOZ+vdd/H1zJsvG+fUrrNyZWcXvPzlJR5cBPxdbPr5jCuFeA2srBbLL0rb7ZzHjhV28uSePEE8HVvVhtbMvKCJ2AbN8QiBTwzy48l8HKahtw95aw5dJpezJrmZ/bi1NHV0m/z83/m9RJPOifYjxc6KssYPt6VU8szGd44X1GCU5BxTh7UhudSttOgMZ5c2smRU67AIG8MBncmOTF1cObtfQYA8HEjKq+ORYESmlTbx27TiczxEq2ltrCPF0oKC2jaZ2XZ9W6c6HSiX4x6qxFL3Vzn2fnOSb383ody86T0dbHrsshmc2ZnDj+8fY+oD5YaVOb+SujxLZnV2DAG6fEWLxint3R2u+uWc6l71+gIe+OkWwuz1TwizfjEBZnbxAkSSJgto2kkz1WwkZVaiE3KbZy8mmpxngzAgvnO00ZFa0cCS/jq9OlPb4WEb5OLE4zodFcb49q2FpZU08uCG5p1vHxGBXXrtu/LBZcR3IreHGdceI9HFk+4OzB/W1PjtWzMNfp+JkoyEuwJlP10w9b16qe5XunjnhFg+Hyho7WPb6AZztrPj2nhm42Pc/77Z07T4yK1p47LJo1szsvevq3uxq7vnvCdp0BrydbPjw9skW2dp1LnZlVbNmfSKPXRYzoLBXKbG4wKlr7SSjopnjBfWklzdzoriBBtPKo7Othjh/FxbH+RAf4k6snzMtnXoOna5lX24tpQ3t7M+tJcTDHg9HG1m4Ys/ftHF/bg0PfZVKeWMHArnE4NVrx1m8tqc3pj+3k/ImLZvvv4RYv8Ftsnc4r47r3zuCSsC2B2b16uPYrtMT9+Q2/F3tOPjwPItfT2JhPde/d4SpYR78+9ZJ/V79rW3VMvXvu5CAww/PO2ePL73eyO8+OcG2jCoEcOPUYJ5ZFjskHShatfoB19wpJRYXCM3aLnKrWsiubCWnqqXnX22rjmB3OfFsb61mdIALl472Y3q4B+FejhgliZTSJnZkVvHkd2kklzRilGSHnRUTA7lijD9zo7173VjdzcyRXhx6eB7fJZfx9Pfp7M6uYcKzCVw5LoDnrh41JD2ivkoqobxJy+QQt0EXMJBzYu4OVvg725llRGtvrSHMy4G8mjYa23UWF/j4EHf+dtVo/vzVKf62OZOn+hnOeTra8uQVsTz5XTo3rjt61hntodO13PVxEi1aPZ4O1ny4evKQdma11M6LszEk5rnnGsd0/FdpntuhM3C6upVsk0hlV8o/zyxItbdWM9LHiXnR3kT6OOFsa8Wp0kZ2ZFZztKCe5JJGIn2c8HW24WhBPc1afU9v+d/NjWBWpBfjglz73MP9TK4cFyA7RO/P5x8JOXxzsoxNp8q5eVoIjyyJHlQD3r9sykQAa6+zzCbv3vB3taNVa6DE2G72c66ZGMTzW7N4a89pHrl0YHZ6Z2PVpCCyKlv44GAB0b5O/bbZu3laCBuOlZBe0cx7+/J6zDz0eiMPfJ7MplNyZ/drJwXx3NWjLkoXrHPRazgphJgFtCJ7QHaL2Hbg1TPMc/8sSdIcIcR05D763ea5T0uSNOVc45iOvwjUn2Ge6yZJ0kOmce9FFrEpwNrusc7HUIeTnV0GCurayK5sIbfqR9Eqrm+n+1drrVER7uVIlI8jkb5ORPk4EenjRICrHUZJorCujcyKFrIqm8mqaCGzoplyk9iphPwXYdk42Z9wRrgnbmb2lu8rRqORl7fn8P7+AnQGI3ZWau6dH8Hds8Is/qF/c89pXtyazeJYH965+RcRwqCx/M2DnChuZP+f5hLk0XseUKvTE/PkNvxcbDn0yC8aEFsEvcHITeuOcaywni/umsqE4PM7EJ2L+lYdk/++A0mCQ4/Mo6iujTUfJtLUocfN3or/3DaJsRZym+8vu7Or2ZhczsvXjO1zF5l+h5OWMM89zzhwkZnn1rR08tqOHIrq2smvacVglKhq6QRk+69QTwdG+btw9fgAWax8nQh2t0ejVlHfpiOropnMyha2plWSZZqddfd+16gE4V6OTAp1J9rXmWg/JyRJYu2OXMYGunD5GP9BfW8qlYo/L4nmgQWRPPVdGp8nlvLi1mze2ZvHY5fFWmyJXK838s+duahVgpdXDbz5Y1+4dlIQJ4obeXtfHn+7enSv59taa3pWdetbdRbfdF1S3866AwUklzSgFnDnR0lsvPcS/Fz63hLd3dGap6+I5fHv0lnwj709zk3Lxwfw8jVjhnX2JUkSb+7J4+Xt2UT7OtPY0WW20UtvDKl57s/HMR27qMxzm9q7mPniLkI8Hahs0lLb2smjl8ZwyUhPQj0dsNGo0emN5NW0/jizqmwhq6KZapPYAXg62hDj50S0r1OPYEV4O561d9XyNw+iMxjZdO/gb+E4kxZtF3/6IoVt6VVIgLeTDc8tHz1gN58nv0vjw8NF3DhlBH81Q0gsiV5vJPKJLXg72XDk0QW9P4EfN13fMTOUxwfo0N5Nckkj7+3PZ0tqBWqVYNnYABbGevPHz1OI8HZkw13n70F2Pq7610Eyypuw0aj4922Te/WWHGxaO/X83+cpbE2vZNlYf15YMeYXbZDM4YIwz+2Ni8E818XeilNPL2bdgQKe3ZTBnxZHEentyN7sGt7Zm09mRTOnq1vRG+XLsFarGOnjyMyRXibRcibK18nsBDzA4jhfntuSRWlDO4FDWArhZGvF2zfFU9Ws5YHPkjmcX8fq9YmEeNjzj1XjfmF5Zg6tWj2fHC3GRqPi6WHoBKrRqAjzcuR0davZ9V+3TAvl75uz+OFUxYBEzGiU2JlVzXv78jlWWI+TrYY7Z4Vz6/SQHk8HIQR3fZTEY9+k8fI1/dua9O3vZlDfqsPZVjOoOU1zKKht484PE8mraeXxy2JYfUmoxbey9VfEbgHuN93+Ani/+wGTee77yOa55rhUVHWHiSbz3GrT8TLgzPgl0HRsyOnUGyiuaye/VjZaza1q4fuUcjQqwUvbshlpCjf8XGyJ9nVirsmiPsbPmVBPhwEl3uFHEdueXjWgOpv+4uNsy6d3TiWvppX7Pz1JWnkzK946RJy/M/+8fnyfKrz//FUKeqPEffNHDtsXbNlYf15JyOHfhwp5YMHZK/bPxFqjYqS3IzlVrdS2avtcGa/tMvD1iTLe359Pfm0bAa52PHl5LKsmBf2i2HhxnC/3zR/JP3fmMjrAmVtn9O//ezB6jfWVXVlV3P9ZMhqV4OPVUwZs9nIuhsQ8txcuCPNco1GiollLQU0bBbWt5NXIglVQ20ZpQzvGM+Z3bvZW6A0Sk0PduXS0HzF+cqJ+sGqsQjwdiPJxYmt65bCIWDfhXo5sum8mSUUN/N8XyaSXNzP/H3uZFubBa9eN63XfZVWzli2plTjbavj93N6LMgeL22aE8EpCDhtTKswSMYDrJo3gL5syeGNXHk8vM28GuTOzir05NfxwqoK6Nh2jA1x4/frxLB3le96asAfmjySjvIlnf8gkyteZacPoG9ofjEaJf+0+zSs7cojxdeadmyYOml8rmLc62WOeC1Qhm+dmI5c/dJvn3iNJUpIQ4n1gBbIJLvxonnvWcSRJWieE8AA+B0aYnrdKkqR6U37sDWAJJvPcs+XDfk5/Vye/Sy7j/s+Se+7bW6sJ9XQgzMtR/unpQKinAyGeDjhYq5n0tx3MjvTitSEqD3hlu9wh9PhjCwZk0WVJdmZW8ejXqVS1dCKAxXE+vHTN2HN2fbj2ncMcLajnxZVjBm0fnblMe24nVc1acp5dataMUKc3Ev3EFrwcbTj62NlzaUajke+SK/j4aCGnSpvoMu3ad3ew4s3fTGRKqLvZoVSLtosr/3WQxvYuNt57yZB4n1qC1k49f/w8mW3pVVw1zp/nlvcv/3U2lIr9XihtaGdvTg2hng6Eezni7WRz3g/cHz9PISGjkqQnFg44XDSHtLImLn/9AC+sGN3vWqLB4vPEEv66KYNmrR61EKyMD+TZK0f9pCFeVkUzS9bux9fZ/IT6YPLEt2l8dKSI55aP5vrJ5v0+l762j8zKFo4+Or9n1qnTG/n0WDGfHy8hq7IFg+n75GJnxcyRnuzMrEZCIuvZpX2+xryaVq564yDBnvZ8eff0XyT6n/wuDSEEz5g5Mxxsyho7uOWDYxTUtvHopTHcPiPEovmvc4nYr6fibYAEutnzmynBTA/3xMfZttdf/sJYH5q1eo4X1g/J9cX5OxPgase29Koheb2+sCo+iOQnF/LnJVFYa1RsOF7CqKe28eLWLApqWnjyuzRWvn0YgBfOYpgxHNxp6lm24XiJ2c+5foosdq8l5PDGrlzm/2MvUU9s4anv00mvaMbNwYpV8YHs/uNsUp5axBs3TGBqmDvaLiMnixv6fI3hXo68dt040subeeTrVM6ccOj1Rr45Wcb6Q4UcGwKDZHOoaOqgqlnLP68fNygJ/HOhiFg/mTnSE2uNioSMoREVIQSL43w5kFtLa2fv/olDjUql4p45EaQ/s4g7ZoYiIdcFzf3HPj48XERrpx4bjRi05C7Iewif25xJq7b330+Qmz2udlaklzeZPf4Nphnwp8dLeHl7Dnk1rfg523L7jBCOPjqfxMcX8uLKsYSesdDR3T563YGCvr0ZE/NjfHhwQSTfnCz7yRgajYp1t8iTktXrE9HpzXM3H0zc7a3p1BvZmDy0pZyKiPUTBxsNl0R4kpBRxVCF5IvjfNAZjOzJru795GFCpVLx+GWxpD61iHhTCcaTl8fw1g0T6NRLgzpz/fBQEe/sy+fDI4VmnT89woMug2T271OjUTEmQN5vuHpGCClPLuTQI/N58oq4cy5qzImSvT8PnqPVuDn8fm4Ei+N8eG5L1k/GmRzqwar4QFq0eu7+ePibHoR5OfLggki2pleyJXXohEwRsQGwMNaH0oYOsqtahuT14kPc8XCwviBDyp9ja63hscvk7qAejjbMivLCWq1iZ+bgCXD3yu33yeVmnb/G1Fn1P4cKzX6NK8b5AWCtUZvdYyzGz5mG9i4qGjvMfp0zkXuQjSPM04Hff3KCkvof934+v3w03k427MqqYUvasG5mAWDNzFBGBTjzxHfpNLbrhuQ1FREbAPNj5K6cCUMkKmqVYEGMD7uzqunUG4bkNQfC2EBXPBys2ZVVjYONhmnhHuzKGjwRc7W3xsvJhtyqVozG3sOr8SPcsLVS9Wl2eNOUYASwuQ8zjRUT5N136w72L6QEuVvJuzfHozdK3PlREh0mnwWVSsUnd0xBCLm5ZIu2q9+vYQk0ahUvrhhLY7uOv/6QOSSvqYjYAPB2smVckCsJmUM3M1o8yofWTj2H8i6MZO75UKkEc6K82ZNdg95gZH6MNwW1beTXtA7aa86J9MIgSWxOrTTr/PFBbrR1GsiqaDbrfFtrDUHudhTXt6PVmZebvDY+EAFsTzPvms5FqKcD/7x+PFmVzfz5q1M9aYwIHyfumxdBp97IjeuODug1LEGsvzN3zw7ny6RS9ubUDPrrKSI2QBbG+nCqtInKM1rsDCbTwz1xsFazPX1gX4ihYl60N00dXZwsaWRetDxzHcyQcrUppPzkWLFZ5980NRiAd/flm/0aS0f5IQEfHTVvj2638JU0dJgtfOdibpQ3/7coio0p5T+55gcXRhHu5UhKSRPr+xAeDxa/nxdBuJcDj36dOugLUYqIDZBFsfJm6B1DNBuztVIzJ9qbhIwqDMYLv8ZvZqQnGpVgV1Y1gW72RPs6sTNr8H5X0X7OOFirOVncaNb5S0b5oFaJPs0Y1syShfLrE+bvglsc54uEvLI5UO6ZE86lo315YWsW+86407RS4gAAIABJREFU7k/umIQA3uuDIA8WtlZqXlgxhvKmDl7elj2or6WI2ACJ8HYk2MN+yEotQP5C1LbqONGP2qOhxtnWikkh7uw25cLmRXtzvLCBpvbBy91MDHGjo8vAqdLehUylUhHt40Rdm47qZvNm056Otng62pBTaV7uDeixZ/v6RKlZ558PIQQvrRxLpI8T9356kqI6ufPsirePIAFBbhdGdX98iDu3TAth/eFCEgdxVVoRsQEihGBhjA+H8+qGrH5rrmmlb9sAcyxDxbxob7IqWyhr7GB+jA8Go8Te3MHLldxsChHNrc1aPiEAgPf2mz+DmRst5942njIvwe/jbIubvRWZFS1mC9/5cLDR8M5NsintzeuOMvW5nZQ2dDBzpCf/XdNr79Ah40+Lo/B3seOhr06h7RqcxShFxCzAwli5fmvfECQxQW6RMz3Cg20ZlUNWozYQ5ppyYbuyqhkX5Iq7gzU7BzH8nhftjUYl2J9rXm3Wb6aMQECf/ijcZZpZ/feoebk3gEtGeqI3SuzJ6X/N2JkEezjwxg3j6dAZ0HYZuWdOOB+tnnJBtZ52sNHw3PLR5NW08cau04PyGhfOu72ImRjshqu91ZCHlCX1HWRWDE2N2kAI93Ig2MOe3VnVqFWCuWesWA4GKpWKKF8n6s0MEc9MvLebmXiP8HHCyVZDSol5uTeAO0yLDh8eLjT7Ob0xc6RXT7se7z70qDuTpnYdGWWNNA1SXdesSC9WTgzk7b15fdohYS6KiFkAjVrFvGhvdmVVD9oX8+csiPFBCNh2EaxSCiEL18HTtXToDMyPkVcsk4oGL6d31Xi5lbe5IeXSUXLi/b9mrjgCTA11p1Nv5IiZ5S5jg+S6NEvnh+6eHc7CWB+e/SGTw30svfn2ZBmT/raTy984yOyXdg/a9qXHL4vB1d6ah746ZfHviCJiFmJRrA9NHV0cLxyaZLuXkw3xwW4XhYiBHOJ16o38f3vnHd5Wef7v+5XlvZckx3Fix1t29nJ24hE7AUKBsiHs8APafikdlDIKBVoKLRRKoQ17hkCBQiHTdvZwduLEI3HixI7jHY843tb5/XGOjDMcH9mWbAfd15Ur0qtzpPNK1qN3PM/ns+1YFbMiA3B0EFZNfL11qrwutkrl+2Oucfzagh3He2bKU8p3NqtfSxsX4kNDSwcF/VjlodEIXr5hLKH+bjz06R5KVFQGNLe2c8tb23l4+T7aTSai9Z7UNrVz81vb+u26uuLj5sSzV8dxsKSet3tZR9od9iDWT8yKDLRpQTjIU8q8sjMUVau3IBsopo7yw83Jgcy8CjxdHJka5m/VtBQ3Jy3DfV0pqm7sdnRR1dDC57uKuf+jXSS/vBEAk4TqdcaEcH+ctRq2F6ofWZllf5ZasImgBk8XR5YunkRbu4n7P9p1yUX09fkVTHguna1Hqwn2cWXdr+ey8uHZjApwZ/eJWv6yMq9fr83MgtFBpMUZeGXt4X5NeLYHsX7C3VnLjHB/1ubabrE9Nc4ADI0ppbPWgZkRAWTmViBJEkmxOo5WnuV41VmrvWZyrB4J+HynvPguSRJ5pXX8c10B176xhcnPp/Pb/xxgf3Ed14wP5o7pI8krO8ORCvVfsLEhPpxpblc9srpqTBAaAevz+38TKDzQg1duHMfBknp+f550D8jyPQ98vJs739tJU2sHd88IZcvvEhnpLzvFf/3gdFwdHXhzw1GriQz88eo4nLUafvdlNqZ+ynPsMYgJId4VQlQIIQ52aRsnhNguhNgnhNglhJiitN8qhDgghMgWQmwVQoztck6aECJfCFGg+Eua28OEEFlK+3IhhJPS7qzcL1AeD+2XHluRFKO82H643HplNV0J8XPDGOQ1JIIYyFPKU3XN5JefITFax+hgL7Yds175lDkp9e3NhTz2VTbTX8gk7dXNfJJ1gnaTxMNJUXz385lseyyR568ZzQNzIgDLKgpuVTTG/q1yZKXRaIjQeVBxpsUqC+nJRlm656u9Jby35Xhn+96iGiY+n87Kg2X4uTvx/S9m8tR5Ri3ebk58et9UBLDkw92Uq8ybswSdlwtPXGlkx/HTfKKyqqIn1IzE3keWiO7Ki8AzkiSNA55S7gMUAnMkSRoNPIviQCSEcAD+CSwAjMDNQgizbcxfkI14I4AaZJcklP9rlPZXlOMGNZ0F4Tm2CyqpcQZ2F9VQ2cUObrDSNdViZIA7zW0mvleZZ2UJm45UsuTDXVzx6mYAjlc38r/9pxgX4sOL143hywem8+3PZvJ/yZHEB3t3ivcZvF2ID/ayKP3jqjFBOAjBujz1I6tFY+VNh/esVB7088QI5hv1PL8il81HKnjsywNc88ZW6prauGZ8MLseT8I4zPui544f4cvvF8bQ2mHi6tc390tO2/lcP3E498wM65Rq6is9BjFJkjYC50/6uzXPlSTJvLLd1Tx3ClAgSdIxSZJagc+AqxUd/UTgP8pxHwA/UW5frdxHeTxJ2EoqspfovVwYG+LDWivWBp5ParweScKma3G9Re8lB4lM5f1JjNWRVVjdZ+WFM81tvLG+gIWvbiTi9yu4/Z0drMkp52xrO14ushfOG7dO4M3bJnLD5JBLGtMmxujZU1TD6bPqRkkajYYogwdVDS1UNVx65JJXWs9vvtjPe4qaxadZJzrVKPoTWbpnLGEB7tzx7k6W7SzG01nLZ/cl8MqN43rMI7tvdjjzogMpq2/h3g/7X6dMCMGTVxqJDfLq+WAV9HZN7GHgJSFEMfBX4LGLHHMPsFK5HQx0LRo7qbT5A7WSJLWf137OOcrjdcrxFyCEWKJMa3dVVtom4bQ75hv17C+utcpQ/GJE6z0Z6e82dKaU0Tr2FNVQc7aVpBg9bR0Sm1UmpXblwMlaHlm+jynPpzP66TW8uCqfnNIzeLpoWTjawPIlCRx5fiFv3DoBgM92qpu6JMXoMEmw4bD6H6LOjP+N5+66mUwm1hwq4/Z3sjA+tYq0Vzfxxe6T1Da2E+DhSPXZNoskfSzB08WRpbdPJFzngbNWw1cPTifBAtekd+6YhMFL1il7a+NRq1xjf9HbIGY2zw0BfolsnttJF/PcR/t2eeqQJGmpJEmTJEmaFBgYaIuX7JbkWNsWhJtlq7ceraJ+gLWk1JAYq8ckwcYjlUwY4YO3qyMZKlItWttNfJpVxE/f3ErMEytZ9PoWvtpbQnVDC5E6D36RGMGuJ5LY+9R82VlolPyFnRkZiKODUJ0/NTrYm0BPZ9ItGE2bNcZWHiylsbWdtzYeZeGrG4l8YhVLPtrNpiNVSBLMCPfnjVsmcOT5NHY+ntKptWYtRgV68PIN43B1cmDxuzss2kTRaDR887OZODoI/rQir1ceAbbCVua53RnhVgM+QgitMtrqapBrPuekEEKLPG0d9CJaUXoPRvi5kZ5T3pmrZG1S4/Qs3XiMdXkVXD0uuOcTBpAxwd4EeDiRkStf69zoQNblVWAySWg0564WnKg+yzubC1mXV8HJmibMe1kezlpmj/Lj5ikjSDXqe5weRek9OXSqXpXxrUYjSIzWsSK7lLYOkyonq5rGNtydtRSdbsL41OrO9gB3J2ZFBXLPzDDigy9cg0qM0fH9AfWv0xvig7359N4EbnsnixuXbmPZfQmMUml2rPdy4a3Fk7jzvZ3c8lYW2x9LVK1ma0tsZZ67E4gUQoQhB6ebgFskSZKEEOuAnyKvk51vnnsHsE15PFMaAoWCQghSjHo+2n6Csy3tuDv39i1Wz/gQXwI9nVl9qGzQBzGNRjAnSkd6bjntHSYSY3R8s+8U+0/WMna4N6tzylm2o4g9J2o7C+oFMNzXlcRYPXfPCO1MCVDLorHDOHSqnve3nODXqdE9Hp9i1HO0soGdx08zPfzixiZ5pfX8a8MxNh6pPGf9zM/dkZsmj+DumaE9BszEGB2f7Sy+5Ov0B8ZhXiy7L4Fb3trOTUu38+l9CUTo1AWyudE6HpgTzpsbjnLtm1vJ+NVcq11nb1GTYrEMOZBECyFOCiHuAe4D/iaE2A/8CViiHP4U8rrVG+b0C+hc0/oZsBrIBT6XJOmQcs6jwCNCiALlXPPU9B3AX2l/BOhMyxjsJMfqaW23XUG4RiMHzvX5lVZTCuhPugoljh2uGG+8v5PIx1fywMd72Hi4ivYOE5NG+vKna0aT/9wCNj2ayDOL4iwOYGB59v70CH+yS+ouKAjffrSae97fSfwf5PWt/+4roa6pjfhhXvxGCY7BPq78Ni2mxwAGMCNCdszKtMFGULTBk2VLEjBJEjct3U5BhfqKgUcXxDBxpA9HK8/yyPJ9PZ9gY3ocJkiSdHM3D028yLH3Avd28zwrgBUXaT+GvHt5fnszcH1P1zcYmRyqFITnlrNgdJBNXnNhvIHD5WfYfrSauUoqw2DF312ekix+ZwdNStA93diGztOZmREB3DkjlDHDffrt9TxctOg8nTlWKet/9TT9dHPSMicqkNWHyhg/0odPs4rZX1xLi5L576zVkDDKj8UJoaTF/zCdfXvTMfLK1AcHd2ctCaNk34EnrjT2fEIfidJ78tmSBG5+K6tzRBal91R17rL7pjHlT+l8tbeEhHD/AXdw74o9Y98KaB00JEbbtiB8cpgfuafqWWNDvX+1tLebWL6ziOv/JS/K3/TWdgCa2zqINXgyN1rejPnygem8fOO4fg1gZmZFBmCSYLXKVBSz8OTDn+1nR+FpnBw0pMTqWL4kgfznFvDZkmksHBN0TkCcFi5bwG2wINs9KUbHMSv7DnQlQicHMo0Q3Lx0O3ll6rwFnLQavn5gOg5C8NiXB/q19rOv2IOYlUg26qltbGOXFZUauuKsdWBWZGBnWc9AU1rbxHPf5zDnxXVEPrGSR7/MZufxGhwdNMyJCuT6icORgKWLJ/G0kjluzVw3s/b+MpVZ4omxOkwmiWi9B2t+OZvsZ1J5647JnbueF+NOpYj8o+3qlTASuyQA24rwQA8+W5KA1kFwy1tZ5JxSF8jCAj342w1j6ZDgun9t7bNfQH9hD2JWYnaUrL6absMk1MRYHWX1zRxS+UfZ32w6Usl9H+xk7DOrmfZCJm9vKqTodCPDfFy5PWEkG34zl+xnUvng7ik8OM9c4lNOaIA7kToPq6alGId54+KoYc8Jdfpfvm5OTIvwp90kqZ5yTQnzx0mrYYcFBeEhfm5E6T1YZ2ND5FGBHixfMg1nrYZb3t7OwRJ1Ol8/GR/MjZNDqGtq58al2618leqwBzEr4eGsZXqEP2tzbecQPi9ahxC2+1VvaJZzoq54bVNnpvza3AqaWk2MDfHmmUVx5P4xlS2/S+TZn8SfsygfFuDOqED3zhyxFKOerMLTVtXeHxPsTUNLOyeq1eVLpcYZOFp5lgILCsLjh3lR39xOcY16ZZF5MTqyjp22uWdkaIA7ny1JwM3RgVvfziL7pLpA9vRVcXi6aGlsbbdKWZKl2IOYFUkx6jlR3WiRKkJfCPR0ZuxwH6tKPx8uP8OjXx5g2p8ziH96Nc+vyOPQqfpzMuUPP7+Abx6ayR3TQ3Fx6n7vKClGx/ZjsjdBilHW3rfmiOQas4mtSj2rFMXJypJqiOsmKq+xSb1mVlKMnnaTpFpOuz8Z6e/O8vun4eGs5da3t/eoVFta18T1/97KmeZ2bpoyclBIYQ/8FVzGmLP3bVnXmByrY//JOtXOPT1hMpn4dn8Jt729HeNTq5j/ykaW7yymvL6ZUQHuPDg3nB2/vzBTXg1JsXLZ0abDlYwd7kOgp7NV36vrJsgmtmpHqkHerowd7m2Rx+f1E0MQWFax0Vm5YMOa266E+Lnx2ZIEvFwdue2drG6z8/cW1bDo9S0cr2rk3Tsnda4zDjT2IGZF9F4ujB3ubdMglqQEzr6MaE43tPLymnySX95AxOMr+cWyfWwuqEaSYNoof165YRyHn11A5q/n8tu0GHRePedEXYxJI33xctGSkVeBRiNIjtWxPr+Clnbr5Lo5aTWE+LpSUtOkWoZ5fpyB/SfrKK3rWS218zX85NdQu/CtddAwNzqQ9fkV/aaxZSkhfm4sv38avm5OLH5nxwXS4d/sK+HGpdtxcZTrMBNj9ANynRfDHsSsTIpRz77i2n4bGfVEjMGTYd4uFtX+Aew+UcPPl+1hwrNrmfDcWl7LLKCgooFAD2eunzScFf83k9xn01i2JIFrJgSj1fb9T0f+8upYl1dBh0kixajnbGuHxTrxlpCoCCX+Z7c6/0ez8KQlP0TzFaPc5bvUe0wmxuioPtvKfhVemdYi2MeVz5Yk4OfhxB3v7mD3idPUNrby6y/288HW44wL8eGbh2aq3uiwFfYgZmWSlXUVNUXO/YEQgqRYPZuPVF0ye7+13cQnWSe49o0tRD+xkuve3Mr/9pdS39SGMciT36ZFk/30fLIeT+aln47FGHRx/am+khQrf3n3FdcyPTwANycH66ZazDK7d6sLMBE6D0YFulu0LnaP4j701V71QWxOVCAaG27KdMcwH1eWL5lGoKczt76VxdyX1vP13hLmRAXy8T1T8XO/fGon7agkWu9JiJ8ra3PKO/XVrU1irI6Ptp9g27Fq5kX/kL1fXNPIO5sKycgtP6eg2stFy4wIf25LCGVuVIBNF2vnRulw0Agy88qZONKX2ZGBpOeW8+zV8RcUhPcHIb5ueLpoVacUgDwaW7rxGLWNrfioKIAO8nHFx9VRdf4VyEYak0b6kZFbwa/m91zfaU0M3i58tiSBez/YxemzrXx6XwLGYf2j/WUN7CMxKyM7hBvYXFDFWRs5hE8b5Y+rowMZOeVk5lVwz/s7GfP0amb9ZR3vbz3OyZomQnxduXN6KJsenceBp1N5984pJMbobL7b5O3myKSRvp2L2ilGPeX1LWRbEGQsZeJIX5rbTRxQOXVLjTPQYZIsWnifGuZHW4fE1gL1O46JsTpySutVr79ZE72XC8YgLxpb24kNGlzTx/OxBzEbkGzU0dpusskWemNrOx9tP45WI/gkq4i7399JRl4FLe0mJozw4flr4sl/bgEbH03k6UVxhPi6Wf2aeiI5Vk9e2RlO1jSSGCOPzKw5pbx5sjwi7qpBfynGBHtj8HJhjQWy42YLuA8skKBOGoDs/UsRP9ybmsY2VRZwA4l9OmkDpoT64e0qO4SnxRv6/fmLaxp5e1Mh6TnlF/zBzY4M4P+So5jYT3rm1iAxVsfzK3LJzKtg8bRQJo30ZW1OuSrZnN6QYtThIASbVY6SzCohX+wupqm1A1cnhx7PmR4he2tmWZC9H6HzYLivK+vyKmymRXcp4pUp5MGSOoYPgh+77rCPxGzADw7h5f1WEL79aDVLPtzF2GfkaeIHW49zqraJUH83HpgTzuqHZyEETBjpO6gDGMi1fGEB7p07qilGPfnl1vPT1Gg0hOvcqTzTojpLPjXOQHObiY1H1MsrGYd5UdvURqnKkYwQgqQYHZsLLr0pYyuCvF3QCMg61r+O5f2NPYjZiORYPTWNbewp6t0Wulme+Zo3thD1uKwEsSannKZWE+NH+HTqbq3/zTweXRBDtMGLCSN8h4SBCCjZ+0erOdvSznyjPFq1ZPpmKQuUEbHaYu2po+TRtCW7lNeOV7L3t6jP3k+M1dPcZrJqmklPnKxp5Jn/HSLxbxsQAj7bcYJ8CySGbI09iNmIOdFyQbgldm5VDc38ZWUec19aR/QTK/n919nsLarF1UnDfKOeT++dyuHnF/D1gzO4ZeoInM7L3Uox6jl0qn7Qr2mAPKVs7ZDXDUf4uxGt97RqAL5jmpwG8d3+U6qOd3TQkBSjIyO3gjaVo+kbJ8kVApZk/E8Nk53SM/Js/+NzsKSOXyzby5yX1vPRthOkxRv44K6peLg6cd+Hu6i1gk9mf9Df5rkxQohtQogWIcSvz3ue/xNCHBRCHBJCPNyl3U8IsVYIcUT531dpF0KI1xTz3ANCiAn9123b4+GsZVq4P2tzLl0QfuBkLb9YtpcJz65l0nMZvLnhKMerZSWIO5TdxP1/SGXp4klMj7i0pLG59s+WShq9ZXKoH54uWjKVL2+KUc/O46epUWmdZil+Hk74uTtZZHQ8P05PXVMbO1Wuc7k4aQn2daX4tPoKARdHB2Z0cUq3NpIksfFwJbe9ncWV/9hMZl4Fd88IZeNv5/HyDeOYGRnAv26bSFldMz9fttdm+niW0N/muaeBXyDbuHUihIhHlrSeAowFrhRCRCgP/w7IkCQpEsjgBxnqBUCk8m8J8KbqXg1Sko16jlc3nqOKYDKZ+GZfCTct3UbMk7KLz7f7T1Hf1EZckBePXxFDjqIE8YyFu4nhgXKi5lCYUpp1xjLzKjEp2fsmybo7ddPDZakdtSKGs6MCcdZqLJpSJisVAl/sLu7xWDNJXZzSrUVbh4n/7i1h4WubWfzuDrmwPy2GLb9L5PErjAzz+cGbc+JIX579SRybjlTxwso8q11Tb1EjT71RCBF6fjMXN8+tACqEEFecd3wskCVJUiOAEGIDcC1y8LsamKsc9wGy+cijSvuHijnIdiGEjxAiSJIk6xj12YCUWD1P/vcg/9t/CgcHwfcHSimoaMBcLufu7MDsqAAWJ4zst5ytFKOedzYVUtfUhrerY5+fz5okx+r57kCpYhrig95LLgg3K0P0N4unjeS7A6V8vP0Ec6J7lvR2c5JH06sOlfH0orhO5/BLcc+sMN7fepwvd59UveNodkrPyK0gxtC/SaZnW9r5bGcx724upKS2iQidBy/+dAxXjxuGs7b7XdcbJ4/g0Kl63t5ciHGYF9dOsM5n0ht6m2LxMLBaCPFX5NHc9B6OPwg8L4TwB5qAhYDZWljfJTCVAebK0u4Mdy8IYkKIJShmJSNG2CYr3lK2H63mkx0n0GrgtcyCznadpzNzogO5b9Yoq9SkzTfq+feGY6zPH/x2bnOjfyi9GT/Cl+RYPV/vLaG5rQMXx57TGixlSpg/Tg4adh7vXn23oaWdnYWn2Xq0iq1Hq8k5Vc8IPzf2F9cybkTPu74hvm54uWg5aEH2vt7LhdHB3mTmVfDQvIieT+gBSZLYV1TLF7uLySs7w56iWqaE+vHHq+OYF61TXRnx5JVG8svO8LuvsonQeVhFRrw39DaImc1zvxRC3IDsTJTc3cGSJOUKIf4CrAHOAvuAC/aQFQs3ixcCJElaCiwFmDRp0sBrMwMV9c18uO0Ea3PKOVrZQLsy3DL/eN8/J4wH50RY3cdvXIgvAR5OrM0pH/RBzFx6k66U3qQY9XySVcTWo1VWU02IDfJk/8k6yuub0Xu50GGS2FtUw87jp0nPrWB/cS3tJgknBw0TR/ry4NwI/r2xgBUHy1QFMYApYXKfdhRWMyVMnVRRYoyO1zKPcPpsa6/rFYuqG/l6bwn/3VdCYdVZxgz3JiLQg6euNKq+9q44Omh449YJLHp9C/d/tJtvfjYDnWfvFEz6k343z+0OSZLeQbFjE0L8CXlkBVBuniYKIYIA8wJFd4a7g5L2dhPfHyzlyz0n2VdUS33zDyVG/u5OTAnz46bJIfi5O3LV61uJCPS0iRGpg0aQFKNnRXYpre2mC3YwBxtJsTr+vDKPU7VNTAv3x8NZy9qccqsFsavHBbP/ZB2PfXUAD2dHNh6ppLaxjYRRfpgkifvnjGJ6eAATR/p2jgZzSuv4/kApjy2IUTWlvGN6KOm5Fby/9bhFQezVjCOsz6+waOpWc7aVjLxylu0oZveJGoSAhDB/HpgTTlq8Hi/Xvv3N+Xs4s3TxRK57cysPfryHT+9LGPC/qX41z70UQgidJEkVisHutUCC8pDZJPcFLjTP/ZkQ4jNgKlA3GNfDDpys5aFP9nCytgnzZpKzVsPYEG+uHB3ETVNG4Onyw1qUJEkYvFzIyK3gehvZXqUY9SzfVcz2Y9XMjgq0yWv2FnMQy8ir4PaEkcyJCiQ9t4LnL+IQ3heOVjaQkVvOqkNlilBiJf7uTiTG6EiM0TEzIqDbYu8rxgxj3Rf72Vdcy3gVI5pZkYE4OgiLcr9GB3sT4OFMZl7PQay5rYOM3Aq+3lvC+vwKNELgpNXwaFoMV48bds4ifX8QN8ybl346lp8v28sfvj3En68d3a/Pbyk9BjHFPHcuECCEOAn8AXmn8VUhhBZoRlmPEkIYkNe6vACTkkphlCSpHvhSWRNrAx6SJMmc9fkC8LliynsCuEFpX4G8dlYANAJ39b27/Y/ey4WS2iaCfVyZFRHA7dNHXlK2RghBYqyOb/aW0NLeccnF1P5iZmQAro6yxM1gD2LhgR6M9HcjI7ec2xNGkmLU8312KftO1jKhF1MgM+0dJnafqCE9t5yM3AqOVck6+8YgL9ydtZxtaWfbo4k4qSgpSjHqcXQQrMguVRXEQNZ5yy6p75y29oRGI0iMCWTlwTLaOkw4Opw72ukwSWQdq+brvSWsOljGmZZ29F7O3DUjVKnXlHhgbriqa+sNV40dRk5pPW+uP0rcMC9uSxi4Mqn+Ns8tQ572Xex5ZnXTXg0kXaRdAh7q6foGGr2XCwXPL7BoJzE5VsenWUVkHTttk6Di4ujArMgA0nPL+ePV6nbVBgq59EbPx1knaGxtZ170DwXhlgaxM81tbDhcSUZuBevyK6htbMPRQTAtPIC7ZoSSGKsn2MeVx7/O5pOsIv6XfYrrJvY8OvZ2dWRWZCArssv4/cJYVe/nT8YFk11Sz7ubC3lsYayq60+M0fP5rpPsOl7DtHB5GppbWs9/95bwzb5TlNU34+GsJS3ewDXjg0kY5Y+DRrCvuJadx2s4UX22V47pavn1/GhyS+t5+ttDROo8LJIm708G9wLJEMHSVIjp4QG4OGqsauhxPilGPaV1zRwsGRg7N0tIipVVPzYfqcLbzZGpYX6qc92KTzfy/pZCbn8niwnPruVnn+5lfX4FiTE63rx1Anufms+Hd0/h9mmhBCvTrLsVrXhLlFivGB1ESW0T+3ow1jAjuPGJAAAgAElEQVRz81R519ySHLOZkXIR+bf7S3hz/VHS/r6RBa9u4p3NhcQHe/H6LePZ9UQyf71+LDMiAnBQptvXWmiI0lscNIJXbxrPCD83Hvxkz4BVhthVLAYAF0cHZkYEkJFXwdOLJJuMjJJi9WgErM0pY/Rw66i09heTQ/3wdNaSkVvB/DgDKUY9z/wvh8Kqs4QFnDuyMJkk9p+sJSO3gvTccvKUGr/wQHfunhFGslHPhBG+nV/wixEe6IGHs4NqfTGQE5cdlVw/NVNKNyctw3xcOXG6kfZ2U4/y3serzrImpwxXrYYvdp2k3SQpSafxXDE66JI7ltdNGM7vv8pmXV6FnG1pRbxdHVm6eBLX/HML93+0iy/un65K5aM/sQexASIxRk96bgWHyxuINlhfdM7PXU5fWJNTziMDrBzaE05aDbOjA8lUjDPMQSw9p5z7Zo+iqbWDzQVVpOeUk5FXQVVDCw4awaSRvjxxRSxJsfoLgl1PTBjpy8bDVRw4Wasq/8nb1ZHZkYGsyC7l9wtjVW06JMXIirtf7j3JjZPPzWeUJImDJfWsySljzaHyzmx9g5cz9S0tfHDXZFUJuSC/f8N9XTmpGKJYe/cwQufB328ax70f7uLRLw/w6k3jbLpkYZ9ODhBJsfIfpDVdr88nxSiLDxafto7ETX+SFKOj8oys8Drc141InQefZJ3gnvd3Mu6Pa7jvw12syC5l6ig//n7jOHY/kczy+6dx76xRFgcwgNuUbHq1QokAV4wJ4lRdM/tUjuDuVfT9zSYlbR0mthZU8fS3h5jxQiZXvb6Zf64rwMfNkSevNLLpt/P45mczAdiv0tjWjKWGKH0lKVbPr1Ki+Hb/KZZuPGaT1zRjH4kNEP2dla2GFKOe51fksjanvHMdaLAyO1LO3n/u+xwaWzs4UtGAm5MDre0mbp4yguRYPVPC/PptlJEcK28gWKK+m2zU4+Sg4fsDpao2HUb6u+Ph7MDeohoe+XwfGbkV1DW14azVMCsykF+mRJEUq79gqjhppC8rD5bxi6RI1dd274wwPth6nK/3nuSWqbapYnloXgS5pWf4y6o8YoK8mGOjnXD7SGwASYzRsaeohuqGFpu8XmiAO1F6j0FbEN7S3sG6/Ap+/3U2C1/bhCTBnqIa3JwcuH3aSBpbO3gkJYqnF8UxMzKgX6dJGo2GSJ0HVQ0tqiVnvFwcmR0VwMrs0m79Ik0miQMna/nnugJu+Pc2zrZ0IIRgzaEykmJ0/Ou2iex9KoW375jE9ZNCLrrWlRZvILe0nhPVZ1X3J8TfDQ9nrVW9Cs5HCMFL148hSu/J419nq5Ys6iv2IDaAJMfqkSRYn69eLbSvpBj17Dh+etBoQ9U1tvH13pM8+MluJvxxLXe9t5P/7i1h4khfFo4OosME/7h5As9cFYfO05nMPpgC98SVY4IAeN8CXXzzlHJvl13KsrpmvthVzM+X7WXic2tZ9PoWXlqdT0NzOzdMDqGtQ+JX86N5+cZxpMUbcHO69ITILGm+8qBlIpETRvrQ3GayyNmpr7g5aXlr8SQ+uHvKBblt1sI+nRxA4oO90Hs5k5FnPaWG80kxGvjnuqOsy6/gmvEDo0RQfLqRtTnlrM0pZ8fx03SYJAI9nVk0Lpj5Rj3Twv1xcXTgcPkZvs8uJSOvnFunjiQpVsf/9luvfOr2hJH8dc1hVmSX8nBylKpzkmL1OGoESzceJcTXjU1HqjoX5QM8nJkXrWNWVAAzIwIJ9HQGYGfhaTLzKrhrhrop/XBfN8YM92Zldin/b476BNabp4xg4+Eq3ttSyN9uGKf6vL4S4mdbPX57EBtAhBAkxlj3i3k+Y4K90XnKEje2CmLmnbe1OWWsyfkhDSJS58H9s0eRYtQzdrjPBTt8kToPQvxcycyVjTOSYvQs21FMVmE1syL7f73F280JnaczRysaMJlMqvL/vFwcWTQ2iO+yy5CQTWGunRDMrMhAYoM8L7pLl2LU8+6WQuqb2/ByUSePlBZv4MVV+Z3VIWpINepxENjEZWsgsU8nB5ikGD0NLe3ssMAVpy9oNIJko571+ZVWNaNoae9gS0ElT/73INOVnbfX1xXg5eLI4wtjWf/ruax9ZA6/TYth/Ajfi6YomLP3NxdU0dTawYyIAJy1Gov8Hy1lTlQgHRKsOqh+3XDqqABa2k0sX5LAx/dO5f454RiHeXWbZpBs1NPWIbHBgmWEBfHyVHeVBVNKjUZDWKAHFRYYogxF7EFsgDF/MW2datHY2tHvZhSldU18mlXEvR/sYvwf13L/R7v5JOsEo4O9eemnY9j5eDKf/79p3Dd7FKEq0yCSYnW0tJvYerQKVydZujkj79IS333hrpmhAHy6Q52BCMDcGHlUuFXl+zlhhC/+7k4WbbCEBbgTY/Bk1UHLNBDS4uT1tE+ziiw6byhhD2IDjC2+mOczPdwfdycH1vRxl7K9w8TO46d5cVUeaX/fyLQ/Z/L7r7PJLa3nugnDEcgjkTdumcD1k0Lw93C2+DWmhPnh7uTQaeeWFKuj+HQTRyrUa+NbgjHIG1dHB4tcqXSeP6TLqMFBIy8jrMtXbzoC8pRy14kaKs40qz7nzhly/tu3Kg1RhiL2IDYIMH8xC6z0xTwfZ60Dc6IDSc8t7zY1oDsqzjTz5e6TPP1NNhOeXcv1/9rG0o3H8HFz5LEFMaz95Ww2PzqPZ38Sz3UTg3Fy0PD5HvX68he71tlRgWQqQT5J0RWz5sh1XIgPja0dHLZA496cLnNapbFJslHPmWbLlhEWxAchSbD6kPq+B3i44OvmqKovkiRxpPwMy3cOrVGbPYgNAhJjzNn7trOvTzHqqTzTwv4ess1b201sP1bNX1blsfDVTUx5PoNffbGf97cV4eXiyBu3TmDPUyl8tmQa988JJ1L/w2L2PbNG0dxuYvnO3gcxkN+f8voWDp2qx+DtQnywl1XXxW6cLCtZWFJAnRijQ5Jgw2F11zUrUl5GsGRKGaX3YFSAu8VTyoRR/rR1SGy+iPGvSVGyfWFlHkl/20DKKxt57Ktsm+Uu9gf2IDYICPJ2JW6YV6ddmS3oKnFzPsWnG/l4+wmWfLiLCc+u5aal23lr4zE8XLT8JjWa734+EycHDWda2lg4OqjbHbYQXzf0ns6cqm3GZOp94uO8GB1C0Bm4kmL0Fo16LGXR2CA0AtUuSNBVxFDdYr2bk5ZZkQE9Wvh1RQhBWryB7cdOW9T3O6aFAvCxYhTc1mFi0xF502XaCxlc88ZW3t50jGE+rjx7dRxbf5fUq6n/QGFPsRgkJMXoeH1dATVnW/Htpaa6Jfi4OTElVJa4+UVSJNuPVbPhcCUbDldyrFLODA/2cWXRuGHMiQpkerj/OQq1syMDSM+rIOdUHcZh3atiTI8I4Ou9JazILuPKscN6da0BHs6MC/EhI6+c/0uOJClWlm5el1dhlfw6jUZDWIAHRysbaGhux8Ol56+JRiOYFx3I6kNltHeY0KpI9EyOlUUAckvPYBymztVoQXwQb6w/ytqcsguKyLsjIdwfRwfBxiNV/HL5PjJyy6lvbsfFUbbJS40zkBSjx9ttcLthdYctzXN/qRjnHhRCLBNCuCjtYUKILMUkd7kQwklpd1buFyiPh/ZnxwcbSbGyz+I6K2akd6X4dCPero4cqWhg9B9Wced7O/k0q4jhvm48eaWR9EfmsPnRefzpmtGkxhnOCWAAN02Rp1z/6OLcdDEeUtRFP9h2vE/Xmxyr58DJOirqm4kfJue6WdMle4GSJW8evaghMUZHfXM7u090757UlaRYPUJYtr4XH+zFcF9XVdn7Z5rb+GZfCf/vo910mCTaOkxk5JaTbNTz79snsvfJ+fz79klcO2H4kA1gYDvz3GClfZIkSfGAA3CT8vBfgFckSYoAaoB7lPZ7gBql/RXluMuW0cHeBHo6k2Els1jzTuILK/OY/8oGZr24jlWHytBqYNwIPz64ewr7/yALBt4zM4wInccl5VSSjQZcHTW0tl861yxC74mXi1a1eGB3mNcN1+VXoNEIkmJ1bDxcpdpZ21LuVrLpv92v3pvGLGKodpcy0NOZ8SE+Fq2LCSFYEG9gS0EVdU0X5n6dPtvK5zuLueu9HUx8Np3/+2wfe4pqSFFy0/5wVRwv3zCO1DiDzXW/rEWPQUySpI3IwemcZroxz5UkaSeyjv75aAFXRZffDTgl5G9JIvAf5ZgPgJ8ot69W7qM8niQGs65yH9FoBInROjbmV/bbF7OuqY3/7T/FL5fvY9Lz6Vz/r228vekYAR7OPHmlkXW/nku0wQtJkpgTFWiRt2NDcyuujg7UnO05iXJ2VCBtHRLpOZbV/nUlxuBJsI/rD6kWSpJwVmH/5rqZ8fNwws/dicPlDarX8zxdHJkS5meRa3myUU92SR2ldepVUdPig2jrkDrXUMvrm/lw23FueWs7k59P57dfHuBIRQN3TB/Jlw9MY/tjSbx560QMXi6sskBZdqhgE/NcSZJKlGOLkM1z10iStEYIEQDUSpJk9jczG+RCF/NcSZLahRB1gD9w2dZQJMXqWL6rmJ3HTzMjIqBXz3GssoHMPFnldOfxGjpMEr5ujiTG6EiK0TMrKuCchfj5RgN/zzhM5ZmWzto+Nbg5aTnd2Eawb89f8AfnhvPdgVLe2XycZKOhV/0yl2j9Z/dJmtvOzd63RgkSwMyIAL7df4r1h6s6R4I9MS9ax3Pf51J8ulFVDeF8o54XV+WTniu7O6lhfIgPAR5OvLn+KB9vL+qcvoYHuivWbAbiLlIxkBZv4NMdRTS0tOPhfPksh/d2d9JsnhsC/BLFT7I7hBC+yCOrMGAY4C6EuK2Xr32x51+irM3tqqy0nSJEf2OWl7EkfaCtQ85mf/a7HOb9dT2Jf9vAc9/nUtvYxv2zR/HlA9PY9UQKL98wjivGXLiTOD9OVtKwVO9fo9Hg6CCoauh5l8w4zBsPZy17itStFXVHUqyOprYOth2r7nOS8D3v7+Qn/9xyyWPumhEKwEfbjltwjXIem9rRWHigB2EB7qqmlKdqm3h3cyE3/Hsb7R0m6praaG7r4FcpUaQ/MpuMX83l16nRxAd7X3Qp4IoxQbS2m2zq7WALbGWemwwUSpJUCSCE+Ap59PYJ4COE0Cqjsa4GuWbz3JPKFNQbuOjcYTA6gPcGNyct08P9ycgr58kru3fROX22lfX5FWTkVbAxv5IzLe04OWiYFu7PXTNCmRetU60kEGPwJMTPldWHyrhpimXieRGB7lQ19DydPN3QSoCHE8erG9mQX6FaZvl8Ekb54+bkQGZuBfOidSTF6sjMq+BIRQNResskvgurznKs6iyNre3dSuFoAI2AncfVJ6SGBbgTFuBORl4Fd0wP7fF4IQTJsTre33qcM81tF2ygFJ9uZOXBUlZkl3WuK47wc6O2qZ2nU6K4c7p6ccuJI3zRezmzIrt00LvBW4KtzHOLgAQhhBvydDIJ2CVJkiSEWAf8FPiMC81z7wC2KY9nSraqyxlAkmL1PPnfgxytPEuEzgOQM6kPlzeQkVdOZm4Fe4pqMEnywvDC0UEkxspmr+69mCIIIUg1Gvhw2wmLpxn+Hs7kljVQUH6GiPOCSHF1I29uKCA9t4KKMz8kTn6w7Xivg1inwYpiPZcUo+dxDpKeW25xEEuNM/DmhqN8knWC+2bJO6it7Sa+2F3MquxSdhyvQSPAJMHZlg4KKxsIC/RQ9dyJipb+pQJkV1KMBt7aVMjGw1VcMSaIY5UNrDxYxsqDpZ3uVKODvflNajQL4g2M9HdnyvPp7DlRy52XXMg5F41GsCA+iGU7ijjb0t6rv5fBiK3Mc7OEEP8B9gDtwF6UkRPwKPCZEOI5pd08NX0H+EgIUYC8sWDezbysSYzR8SSytVdJrTeZubIZxskaeeE3PtiLnyVGkhyrI36Yd7+4Ys+PM/D25kI25FdyhSIMqIarxg5jc0E1H2cV8fSiOA6W1PGvDUfZfKSKWmXnTCPkTPNrxw/n5bX57Dze9ymlWc4nNsirM3v/wbmWSXzfNSOUNzcc5T+7TlJe38KaQ2UUn25CAjxdtDhrNUwO82OYtwsfbS9i6cZj/Pm6MaqeOzFGxzubC9lSUE2KUd/j8RNG+ODp7MA/Mg7zj8wjnVJF40f48PuFMSyID7pgZJ1i1PPdgVKLDZgXjg7i/a3HycirYFEv8/YGG7Y0z/0DcgA8v/0YMOUi7c3A9T1d3+VEXWMbOwqr8XLR8sqafNolcHHUMDMigIfmRTAvWofBu2f3aEuZOFJWVVh9qMyiIHb12GE8+mU2y3cW8fmuYhpb5XQLRwfBuBAfbp4SwnXjh3fak63NLWP3iVqKqxsJ8e+dcN48ZRSXkVtObJAXSTF6Xss8wumzrZe0MTsfnZcLPq5a8ssbyC9vQADBvq4kxeq5d1YYIb7y9bW3m/gkq8iiHcfJoX54OGvJzCvvNoi1tpvYUXia9Nxy0nPLOdPSQWF1I6OHe/OHq4ykxhkYdgndsNR4A5/tLGZLQRWJMT0HSjOTRvqi83RmxYHSH08Qs2NdSuuaWJtTzppD5Ww/Vk27ScLdyYF2CV69cRyp8QaLUh96g4NGkByrZ0W2ZeKMLk5aYvTu5JWfxVkrmBnhz53TQ0mM0V1UUPC6CSHsPlHL21sKeWZRXK+uVeflwtjh3mTkVfCzxL5l7+94PIU//u8Q4ToPbp4cgstFpn5arYbwQA+OVDRQ19iKt1vPgdJJq2FWZACZeRVI0g++orWNrazPr2RtbnnnWqb5R2petDwF/b+kSFW7rdPD/fF01rLqYJlFQUyeUsoB8HKZUg79HgwxJEniaGUDqw+Vs+ZQWacV16hAd+6bPYr5Rj2ODhqu/Mdmmto6rB7AzMyP07N8VzHbj1Uz2wKXmtHDfckrP8tL149l0dhLLxb/dOJwHv86m4zc8l4HMZA9O/+ecZiqhpZzsvctDWJOWg3PXTO6x+OuGjuMl9ce5t0thfwyRZ1n57wYHSsPlrE2p5wiRY5714maTinuK8YEkRyrZ0ZEAK5ODjS3dfCf3SdZdbBMVRBz1jqQGKtjbU656jInMwtHB/HBthNk5lVw1WUwGrMXgNsAk0liTxelgOSXN/LS6nwQgt+kRpP+yBwyfzWXRxWV07hhXozwc7NpYuKMiADcnBxYY2FC6j2K9duyrJ6VKpy0GkL8XCmpaaK5tb3H47sjKVZWjFiXZ5vsfXOqxXcHelaPMKe87CuqQasRLPloN899n0tdUxsPzAnnvw/NIOuxJF64bgzJRn1n1ryLowPzYgJZk6NeHiktzkBNYxs7LNg9BZgU6kegp7xLeTlgH4lZCbOEzepD8q9xxZkWtBpBwig5DSLZqCfI++JrHkIIUuP0vL/1uEU67H3BxdGBOVGBrDlUzh8XxaveMIgJ8sLNyUF1WVGK0cA7mwv5fPdJFivqCpYSN8wLg5cLGbkVXD8pxOra+54ujgR5u3Cs6izt7abONT4zVQ0trM+vJDOvnE2HqzpTXlwdNXi7OrFsSYKqlJfUOAMrssvYW1zDxJF+PR4/JzoQZ62G1QfLmB6uPjnaQZlSyuuY6nZQBzP2kVg/k192hl8s28vEZ9ey+N0dfLVHth975cax7H4ihY/vncrt00K7DWBm0uINtHVIrLNSLeXFSI0zUKFCY+x8Jo70pamtQ5U12N2K/PNXe9TXJJ6PEILEWB2bjlTS0m4b7X2zvd7nu08qxid1vJZxhKv/uYXJz6fz6y/2s+t4DQtHB8nF1U+lcPfMUZTUNaled5oXo8PRQajW0Xdz0jInKpDVhywXt1w4OojmNpNFGxaDFXsQ62fMWk1p8QbeXjyJvU+l8OZtE7lmvGVKAeNDfAn0dGa1DaeU86J1aDXCYtnqxxbE8OZtEzAG9ZyrFezjhrerlpxT9b29TECWLjrb2kHWsdM2kfhePF0uCfrbmnym/imDK/+xmVfSDwPwcFIU3/18JtsfS+IvPx1DapwBd2etxUKJXi6OzIgIYNWhMtX9SIs3UFbfbPEPz+RQPwI8Lo8p5dAeRw5C4oZ5sfPxZIsWWi+GRiNPKb/cXUKzjRb4vd0cSRjlz+pDZTyaFqP6POMw70tqip3PlFA/1uZWsKOwmilh/r25VGZEBODiqCEzr4LZUYEkxerYfKSSI+UNRBksS3ztjor6ZjLyKkjPKWdzgVyyW9fURopRR2KMnrnRukvWm8pCiU6sy6tUbY+XFmfgd19lq9YYS4rRo9UIVh0qY/wIX3Ud44cp5Re7h/6U0j4S62eEEH0OYGbS4oJoautg42Hb1YPOj9NzrPKsVfX+FyvlOB9Y4LR9Pi6ODswIDyA99wftfY1GkN4HjTFJksgrq+f1THmaOOVPGTz2VTb55We4ecoI7pweSrtJ4pGUaK6fFNJjwbxGI5gTpWPD4UraVRqCJBv1aASqN3W83RyZFu7P6oPqR29mzFPKdSrVaAcr9iA2iJk6yg9vV0eb7lKakzMt3aW0hFmRgTg6CNUWZ92RFKvnZI3sfGTwdiFC50GmhetibR0mthRU8fS3h5j14jrS/r6Jv645jAB+PT+KVQ/PYtNv5/H0ojgeUAQeLZniJ8boqGtqU73xEeDhzKRQP1Zb4C+ZFm/geHVjp/O4WqaEXR5TSnsQG8Q4OmhIitWRnlNukbVXXwjydmXscG/WWOCo0xui9Z7UNLZRUa/efux8zPI45gX9RAu19w+W1DHh2bXc+nYWy3YUEWPw5IVrR7Pj90n896EZ/CwxkhjDD5I2ei8Xxo/wsehHZWZkAA4a9UKJIE8p88vPUFh1VtXxKUZZIdYSY12Qp5Rp8Xoy8ypoarWekbK1sQexQU5anIH65na2H7OO+N/FmB9nYF9xLWV1vQ8wPXH1eDnJ8v0+TCl/cD6SA25yrA6TBOtVSnxH6Dy4ckwQby2exL6n5vP2HZO5acoIdF7dl3alxRk4WFLPyZpGVa/h7erIpJG+rLPA7TtVkcZWO+LTebowaaSvxUEM5CllU1uHzWTRrYE9iA1yZkcF4uroYNNdytQ4eUq51oq6U7dOlXf7evPF60rX0Vdn9r7KKaWLowN/vnYMKV2STnsiNc4cYNS/N4kxOnJL61Wrtwb7uDJmuLdF701qnIG8sjMcVzl6MzM1zJ8ADye+H8JTSnsQG+SYM7l7kwvUW8IDZX/DNVYMnG5OWoK8XTheLSeQ9pauoy+N4qy94XCl1abfoQHuxBg8LfpRmWf2B7BgAT1VGQ2rDXw/BFfLp5SpcQYyc4fulNIexIYAqXEGKs+0sLe4bzI2ahFCkBKnZ9vR6ouaUfQXc6MCMUnwPxXlPN0RP+xcg5UH5obz/S9m4thPO8QX41fzozsX+dUQqfMg2MfVoimbOSipXZsM8XNjdLB3rzaBrlCmlGqn4YMNexAbAiTG6HBy0PR56mUJ840G2k2SVf+wzXWXy3cV9fo5NBrBO3dM4s/XyoXcI/3dGenv3i/X1x0pRn2nJJAahBDMiwlkS0EVLT24Q5mJ0HkQofOwaGSVFm9gb5Hla5lTwvzwdx+6U0p7EBsCeLo4MiPC36JM7r4yPsSHQE9nq+5SRug9cXdyYH9xz+VKl2LMcB+b1Jf2hcQYHY2tHewoVF+snRZnIKtQvdt35+jNwvQYrYOG1HgDmXkVNLcNvSmlPYgNEVLjDBSfbiKntG/lOmrRaAQpRj3r8637hz1BqbvMOdW3QDbYmTZKru+0JNUiNc5Ah0lSba5rHr31ZsR+xeggGluH5pTSJg7gQoho5Vjzv3pFuhohhJ8QYq0Q4ojyv6/SLoQQrykO4AeEEBP6v/tDB3MmtyVJkH1lvlHP2dYOth61nkvezZNlc5J3Nhda7TUGA65ODkwL92e9BakW8cFeBPu4Wpb4auHozczUMD/83J34Pnvo+VLaxAFckqR8SZLGKcdPBBqBr5WHfwdkSJIUCWQo9wEWAJHKvyXAm+q7dfkR4OHM5FA/i7b2+8r08AA8nbVWnVKmxetxEHSKQ17OJMboKKw6qzqJVZZkMrCpoIqGFnX6a2nxlo3ezGgdNKTG6cnILR9yU0pbOoCbSQKOSpJ0Qrnf1en7fAfwDyWZ7cjWbuoF4C9D0uLlTO5jldara+yKk1bD3Bgd6bnldFgpvUOj0bDmkTmkPzLHKs8/mDBvBliUvR9voLXdpHqaFzdMHr31NvFVnlIOrVrK3q6JPQy8JIQoRh51PWbBuTcBy7rc10uSZN4WKQPMguGdDuAKXd3Bz+FyMc/tid4kWvaV+UY9VQ2tfTa+vRThKq3Qhjohfm5E6DwsWncym7ioDUpCCNLiDWw+UsWZZsvSY6aN8sfXzZGVB4fWLqVNHMDNCCGcgEXIhrsXoPhKWvyTL0nSUkmSJkmSNCkw0DqW9oOBYT5yXaMtC8LnRgfi5KCxauLrj4nEGB1Zx05zVuX00EEjmB+nZ50FO4dp8QZaO0wWlTqBeUppICN3aO1S9jaI3QF8pdz+gotYrnXDAmCPJEldhxLl5mmi8r/5Z8rsAG6mqzv4j5b5cQb2F9dyqlZdJndf8XRxZHqEP2tyrCc4+GNibnQgrYpyhlpS4wwWbbBMGOFLgIdzrzaBFo4OoqGl3abyT32lt0HM7AAO6hzAzdzMuVNJ+MHpGy50AF+s7FImAHVdpp0/WtLizZnctk18PVHdyOFy26zFXc6YPSktyd43b7ConVJ2jt56kR4zLVyupTxiRT25/kZNisUyYBsQLYQ4KYS4B9kB/G9CiP3An+jiAK64hD8CPKEc76U85g6k8MMIzswLQIoQ4giQrNwHWAEcAwqAt4AH+9TTy4TwQA8idR42nVImG3UIYXldnp0LcXSQPSnX5VWqHtk6aTXn2LOpIS3OQGNrB5uOWJYe4+igYfOjiTw0zzJH9YHElg7gZ4ELtIglSapG3rE8v10CHurp+n6MpMUb+Oe6Aotdr8DKn+UAAAfLSURBVHuLztOFCSN82a9S2M/OpTF7UqqVoAY5KH2z7xQ7jp9W5WyUMMofLxd59NadC3l32MrrtL+wZ+wPQVLjDJgkSLfQ0KMvvL14Em/fMclmr3c5Mzda3nyyZEpptmdTm7PnpNWQHKsnPdd2gpoDhT2IDUHihnkx3NfVplNKX3enToVTO31D5+nC6GBvi+z4zPZsqw6WqZZkSo03UNfURtYxy8x1hxr2IDYEMWdy9yYXyM7gYF6Mjj1FNdRYUB6UGifbsx1Q4e8JMDvS9oKaA4E9iA1RepsLZGdwMC9a1lLbeET955cUK/uCqt2ldHVy4MN7pvDoAvX2e0MRexAbovQlF8jOwDN2uA/+7k4WTSl93JxkezYLJJnMKR2XM/YgNkTpSy6QnYFHoxHMiQ6kqsEytYnUOAOFVWeHVB6XtbEHsSGMORdos4W5QHYGBy9eN4aP751q0TnzjXrGDPe2qmz4UMMexIYwCUrB7uEKy0xT7QwOeuMUr/Ny4dufzWRyqJ8VrmhocnlPli9znLQatv4uSbXdmB07lyP2kdgQxx7A7PzYsQcxO3bsDGnsQcyOHTtDGnsQs2PHzpDGHsTs2LEzpLEHMTt27Axp7EHMjh07Qxp7ELNjx86Qxh7E7NixM6QRl5uDjRCiEjjR44G9JwC4HIoV7f0YfFwufbFWP0ZKknSBJ+NlF8SsjRBilyRJQ16n2d6Pwcfl0hdb98M+nbRjx86Qxh7E7NixM6SxBzHLWTrQF9BP2Psx+Lhc+mLTftjXxOzYsTOksY/E7NixM6SxBzE7duwMaX40QUwIcVwIkS2E2CeE2KW0vSSEyBNCHBBCfC2E8FHaHYUQHyjH5wohHjvvuRyEEHuFEN91aQsTQmQJIQqEEMuFEE5Ku7Nyv0B5PHSw9EUI4SOE+I9yXq4QYprS7ieEWCuEOKL876u0CyHEa0pfDgghJgySfvxSCHFICHFQCLFMCOGitNvkM7GwH05CiPeU4/cLIeZ2eZ6JSnuB8j4Lpd0mn0d/9UUI4SaE+F4555AQ4oUuz9/tey+EeExpzxdCpKq+aEmSfhT/gONAwHlt8wGtcvsvwF+U27cAnym33ZRzQ7uc9wjwKfBdl7bPgZuU2/8CHlBuPwj8S7l9E7B8sPQF+AC4V7ntBPgot18Efqfc/l2X51oIrAQEkABkDXQ/gGCgEHDt8jncacvPxMJ+PAS8p9zWAbsBjXJ/h/K+CuV9XmDLz6O/+qJ8PvO6/F1t6tKXi773gBHYDzgDYcBRwEHNNf9oRmIXQ5KkNZIktSt3twPDzQ8B7kIILeAKtAL1AEKI4cAVwNvm51F+MROB/yhNHwA/UW5frdxHeTzJ/As7kH0RQngDs4F3lPNbJUmqvcg1n9+XDyWZ7YCPECJoIPuhPKYFXJXH3IBTA/2ZXKIfRiBTOaYCqAUmKe+jlyRJ2yX5W/1hN9dr08+jN32RJKlRkqR1SnsrsKfLOd2991cj/0i1SJJUCBQAU9Rc348piEnAGiHEbiHEkos8fjfyrxrIb+5ZoBQoAv4qSdJp5bG/A78FTF3O9Qdqu3zQJ5FHCCj/FwMoj9cpxw90X8KASuA9IU+N3xZCuCvn6CVJKlVulwH68/ui0LWfA9IPSZJKgL8qbaVAnSRJa7DtZ2JJP/YDi4QQWiFEGDARCFGu6WSXc7per60+j/7qSyfK1PMqIOP8az7vve91X35MbkczJUkqEULogLVCiDxJkjYCCCEeB9qBT5RjpwAdwDDAF9gkhEhH/uWpkCRpd9e1jAGgP/qiBSYAP5ckKUsI8SryVOXJri8kSZIkhLBWHk5/9KMG+Vc8DHkk8IUQ4jZglZWuua/9eBeIBXYh1/huRe6XKqz8eUA/9kUZGS8DXpMk6Zi1LvhHMxJTfrHNw96vUYaqQog7gSuBW5VhPMjrL6skSWpTjt8CTAJmIP/yHAc+AxKFEB8D1chDefOPwnCgRLldgvLrpDzurRw/0H05CZyUJClLOe4/yEENoNw8LVH+rzi/Lxfp50D1IxkolCSpUpKkNuArYDo2/Ews6YckSe2SJP1SkqRxkiRdDfgAh5VrGt7labter00+j37si5mlwBFJkv7epa27977XfflRBDEhhLsQwtN8G3mh8qAQIg15arhIkqTGLqcUIa+nmI9PAPIkSXpMkqThkiSFIi9KZkqSdJvyoa4DfqqcfwfwjXL7W+U+yuOZXb6YA9mXMqBYCBGtHJcE5Fzkms/vy2JlVywBeepmnuYMSD+U9gRlR0wo/ci11WdiaT+U63RXbqcA7ZIk5SjvY70QIkHpx+Jurtcqn0d/9kW5/xxygHr4vJfp7r3/FrhJyLuXYUAk8kZHz0gqVv+H+j9gFPL8fT9wCHhcaS9AnofvU/6Zd008gC+UY3OA31zkOedy7u7kKOVNL1DOdVbaXZT7BcrjowZLX4BxyFOBA8B/AV+l3R95DeMIkA74Ke0C+CfyzlE28iLuYOjHM8gB7SDwUZf33uqfSS/6EQrkA7nKezuyy3NNUvpwFHidHypqrP559GdfkEdRktJuPse8C97tew88rvQlH2U3U80/e9mRHTt2hjQ/iumkHTt2Ll/sQcyOHTtDGnsQs2PHzpDGHsTs2LEzpLEHMTt27Axp7EHMjh07Qxp7ELNjx86Q5v8DP5P5yKBxKw0AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1188,19 +1175,11 @@ "execution_count": 37, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:34.560985Z", - "start_time": "2021-03-15T10:18:33.751970Z" + "end_time": "2021-03-31T10:37:55.925127Z", + "start_time": "2021-03-31T10:37:53.082223Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "data": { "text/plain": [ @@ -1230,16 +1209,16 @@ "execution_count": 38, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.035762Z", - "start_time": "2021-03-15T10:18:34.562433Z" + "end_time": "2021-03-31T10:37:56.600932Z", + "start_time": "2021-03-31T10:37:55.927527Z" } }, "outputs": [ { "data": { "text/plain": [ - "(,\n", - " )" + "(,\n", + " )" ] }, "execution_count": 38, @@ -1248,7 +1227,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1260,7 +1239,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1292,8 +1271,8 @@ "execution_count": 39, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.045839Z", - "start_time": "2021-03-15T10:18:35.041063Z" + "end_time": "2021-03-31T10:37:56.623257Z", + "start_time": "2021-03-31T10:37:56.603441Z" } }, "outputs": [ @@ -1324,8 +1303,8 @@ "execution_count": 40, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.224761Z", - "start_time": "2021-03-15T10:18:35.049787Z" + "end_time": "2021-03-31T10:37:57.369202Z", + "start_time": "2021-03-31T10:37:56.626589Z" } }, "outputs": [ @@ -1336,12 +1315,14 @@ "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1353,7 +1334,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 40, @@ -1378,8 +1359,8 @@ "execution_count": 41, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.250495Z", - "start_time": "2021-03-15T10:18:35.235821Z" + "end_time": "2021-03-31T10:37:57.400767Z", + "start_time": "2021-03-31T10:37:57.377007Z" } }, "outputs": [ @@ -1413,8 +1394,8 @@ "execution_count": 42, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.272423Z", - "start_time": "2021-03-15T10:18:35.258712Z" + "end_time": "2021-03-31T10:37:57.563644Z", + "start_time": "2021-03-31T10:37:57.405392Z" } }, "outputs": [ @@ -1423,19 +1404,19 @@ "output_type": "stream", "text": [ "attribute\n", - "├── route_short_name: ['205', '113', 'N55', 'N20', '98']\n", + "├── route_short_name: ['134', '94', 'N5', '113', 'N55']\n", "├── mode: ['bus']\n", "├── trips\n", - "│ ├── trip_id: ['VJ710332b1c05c07b488b27f8286583ad6baffc26d_03:31:00', 'VJ7d15712cd6ebb243627513798f23afa2b6f7315d_13:26:00', 'VJ78bd0b30c4ad6891c60965a6c3a198a7aebc3c06_09:17:00', 'VJ3810d00fb986abbf91e897b7559f021b8425c127_17:28:42', 'VJ59fbbf6be34b98c8c0540c5d660450506e8d78c4_06:14:00']\n", - "│ ├── trip_departure_time: ['00:39:30', '07:42:00', '19:14:00', '06:03:10', '14:41:00']\n", - "│ └── vehicle_id: ['veh_977_bus', 'veh_1651_bus', 'veh_1643_bus', 'veh_352_bus', 'veh_2040_bus']\n", - "├── arrival_offsets: ['00:01:50', '00:11:00', '00:06:40', '00:06:16', '00:02:18']\n", - "├── departure_offsets: ['00:01:50', '00:11:00', '00:06:40', '00:06:16', '00:02:18']\n", + "│ ├── trip_id: ['VJ50c1d517dd74632bf372027931173c682c3b4bc6_12:33:42', 'VJ881eec29ebba8f74dbaa8d5d40abc5b808b72b23_12:03:00', 'VJ8bb61f6de5639d30345173f3914dd53ab0881fd0_06:46:00', 'VJ43cd459f15733ae9eae813b970c5e2517bf4b781_19:55:00', 'VJ8fdd6622c914d27f32279be48fbff4ad0ec976d3_10:40:34']\n", + "│ ├── trip_departure_time: ['09:56:00', '15:17:00', '19:35:00', '11:29:13', '12:33:42']\n", + "│ └── vehicle_id: ['veh_795_bus', 'veh_1012_bus', 'veh_627_bus', 'veh_1947_bus', 'veh_1834_bus']\n", + "├── arrival_offsets: ['00:01:09', '00:03:20', '00:02:49', '00:02:18', '00:03:08']\n", + "├── departure_offsets: ['00:01:09', '00:03:20', '00:02:49', '00:02:18', '00:03:08']\n", "├── route_long_name: ['']\n", - "├── id: ['VJe6ba07ef9f19ae40517261ad626bf34dd656491a', 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e', 'VJ1cf651142378958b52229bfe1fa552e49136e60e', 'VJ93d8207ae8540b4ff59d47c9ee1ec5689084522d', 'VJd9dbeefeca6d74ef2594a17514ebc08ee2d503b2']\n", - "├── route: ['1868', '2354', '980', '1788', '1187']\n", + "├── id: ['VJ235c8fca539cf931b3c673f9b056606384aff950', 'VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13', 'VJ93d8207ae8540b4ff59d47c9ee1ec5689084522d', 'VJ26095b8f9f9db92ca2e53d4c086a7dcd82a13be9', 'VJb93a17a405fe502c5b3a2d6544105b0311da9fe2']\n", + "├── route: ['1079', '2919', '1786', '428', '2425']\n", "├── await_departure: [True]\n", - "└── ordered_stops: ['490004695A.link:3017', '490000173JB.link:1663', '490015042T.link:622', '490010531OS.link:1868', '490015196OF.link:1311']\n" + "└── ordered_stops: ['490000078Q.link:2725', '490010689KB.link:981', '490000091H.link:1912', '490000173W.link:1868', '490000191A.link:2354']\n" ] } ], @@ -1448,8 +1429,8 @@ "execution_count": 43, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.283945Z", - "start_time": "2021-03-15T10:18:35.277582Z" + "end_time": "2021-03-31T10:37:57.575515Z", + "start_time": "2021-03-31T10:37:57.566657Z" } }, "outputs": [ @@ -1458,8 +1439,8 @@ "output_type": "stream", "text": [ "attribute\n", - "├── id: ['12430', '17732', '14134', '18853', '14073']\n", - "└── name: ['205', '113', 'N55', 'N20', '98']\n" + "├── id: ['14073', '14134', '20274', '15234', '18915']\n", + "└── name: ['134', '94', 'N5', '113', '98']\n" ] } ], @@ -1479,8 +1460,8 @@ "execution_count": 44, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.303727Z", - "start_time": "2021-03-15T10:18:35.287894Z" + "end_time": "2021-03-31T10:37:57.601403Z", + "start_time": "2021-03-31T10:37:57.577260Z" } }, "outputs": [ @@ -1536,10 +1517,10 @@ " Great Titchfield Street Oxford Circus Station...\n", " \n", " \n", - " 490015196OG.link:2954\n", - " -0.144820\n", - " 51.515865\n", - " Holles Street (Stop OG)\n", + " 490000235P.link:15\n", + " -0.128295\n", + " 51.516762\n", + " Tottenham Court Road Station New Oxford Stree...\n", " \n", " \n", "\n", @@ -1551,14 +1532,14 @@ "490000235YB.link:574 -0.134044 51.516098 \n", "490014214HE.link:3154 -0.135392 51.515923 \n", "490010689KB.link:981 -0.139893 51.515472 \n", - "490015196OG.link:2954 -0.144820 51.515865 \n", + "490000235P.link:15 -0.128295 51.516762 \n", "\n", " name \n", "490000235X.link:834 Tottenham Court Road Station (Stop X) \n", "490000235YB.link:574 Oxford Street Soho Street (Stop YB) \n", "490014214HE.link:3154 Wardour Street (Stop OM) \n", "490010689KB.link:981 Great Titchfield Street Oxford Circus Station... \n", - "490015196OG.link:2954 Holles Street (Stop OG) " + "490000235P.link:15 Tottenham Court Road Station New Oxford Stree... " ] }, "execution_count": 44, @@ -1575,8 +1556,8 @@ "execution_count": 45, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.318846Z", - "start_time": "2021-03-15T10:18:35.305408Z" + "end_time": "2021-03-31T10:37:57.623521Z", + "start_time": "2021-03-31T10:37:57.605619Z" } }, "outputs": [ @@ -1612,23 +1593,23 @@ " bus\n", " \n", " \n", - " VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e\n", + " VJ812fad65e7fa418645b57b446f00cba573f2cdaf\n", " N55\n", " bus\n", " \n", " \n", - " VJ812fad65e7fa418645b57b446f00cba573f2cdaf\n", + " VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e\n", " N55\n", " bus\n", " \n", " \n", - " VJe6ba07ef9f19ae40517261ad626bf34dd656491a\n", - " 94\n", + " VJ235c8fca539cf931b3c673f9b056606384aff950\n", + " 205\n", " bus\n", " \n", " \n", - " VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e\n", - " 205\n", + " VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13\n", + " 94\n", " bus\n", " \n", " \n", @@ -1638,10 +1619,10 @@ "text/plain": [ " route_short_name mode\n", "VJ375a660d47a2aa570aa20a8568012da8497ffecf N55 bus\n", - "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e N55 bus\n", "VJ812fad65e7fa418645b57b446f00cba573f2cdaf N55 bus\n", - "VJe6ba07ef9f19ae40517261ad626bf34dd656491a 94 bus\n", - "VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e 205 bus" + "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e N55 bus\n", + "VJ235c8fca539cf931b3c673f9b056606384aff950 205 bus\n", + "VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13 94 bus" ] }, "execution_count": 45, @@ -1658,8 +1639,8 @@ "execution_count": 46, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.336475Z", - "start_time": "2021-03-15T10:18:35.326489Z" + "end_time": "2021-03-31T10:37:57.639372Z", + "start_time": "2021-03-31T10:37:57.625795Z" } }, "outputs": [ @@ -1697,20 +1678,20 @@ " N55\n", " \n", " \n", - " 12430\n", - " 205\n", - " \n", - " \n", - " 17732\n", - " N20\n", + " 14073\n", + " 94\n", " \n", " \n", " 14134\n", " 98\n", " \n", " \n", - " 18853\n", - " N8\n", + " 15234\n", + " 134\n", + " \n", + " \n", + " 18915\n", + " N5\n", " \n", " \n", "\n", @@ -1720,10 +1701,10 @@ " name\n", "service_id \n", "20274 N55\n", - "12430 205\n", - "17732 N20\n", + "14073 94\n", "14134 98\n", - "18853 N8" + "15234 134\n", + "18915 N5" ] }, "execution_count": 46, @@ -1747,8 +1728,8 @@ "execution_count": 47, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.347082Z", - "start_time": "2021-03-15T10:18:35.339152Z" + "end_time": "2021-03-31T10:37:57.650320Z", + "start_time": "2021-03-31T10:37:57.641889Z" } }, "outputs": [ @@ -1772,8 +1753,8 @@ "execution_count": 48, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.357054Z", - "start_time": "2021-03-15T10:18:35.348825Z" + "end_time": "2021-03-31T10:37:57.715137Z", + "start_time": "2021-03-31T10:37:57.653614Z" } }, "outputs": [ @@ -1811,8 +1792,8 @@ "execution_count": 49, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.384585Z", - "start_time": "2021-03-15T10:18:35.358691Z" + "end_time": "2021-03-31T10:37:58.219700Z", + "start_time": "2021-03-31T10:37:57.722398Z" } }, "outputs": [ @@ -1843,8 +1824,8 @@ "execution_count": 50, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.466420Z", - "start_time": "2021-03-15T10:18:35.387982Z" + "end_time": "2021-03-31T10:37:58.498930Z", + "start_time": "2021-03-31T10:37:58.225186Z" } }, "outputs": [ @@ -1974,8 +1955,8 @@ "execution_count": 51, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.530333Z", - "start_time": "2021-03-15T10:18:35.481216Z" + "end_time": "2021-03-31T10:37:58.521497Z", + "start_time": "2021-03-31T10:37:58.507707Z" } }, "outputs": [ @@ -2000,8 +1981,8 @@ "execution_count": 52, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.552115Z", - "start_time": "2021-03-15T10:18:35.546307Z" + "end_time": "2021-03-31T10:37:58.532100Z", + "start_time": "2021-03-31T10:37:58.523973Z" } }, "outputs": [ @@ -2009,8 +1990,8 @@ "data": { "text/plain": [ "['VJ375a660d47a2aa570aa20a8568012da8497ffecf',\n", - " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e',\n", - " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf']" + " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf',\n", + " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e']" ] }, "execution_count": 52, @@ -2028,8 +2009,8 @@ "execution_count": 53, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.574842Z", - "start_time": "2021-03-15T10:18:35.557897Z" + "end_time": "2021-03-31T10:37:58.556972Z", + "start_time": "2021-03-31T10:37:58.534496Z" } }, "outputs": [ @@ -2038,8 +2019,8 @@ "text/plain": [ "['490000235YB.link:574',\n", " '490000235P.link:15',\n", - " '490000235Z.link:15',\n", - " '490000173W.link:1868']" + " '490000173W.link:1868',\n", + " '490000235Z.link:15']" ] }, "execution_count": 53, @@ -2074,15 +2055,15 @@ "execution_count": 54, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.590632Z", - "start_time": "2021-03-15T10:18:35.580431Z" + "end_time": "2021-03-31T10:37:58.568880Z", + "start_time": "2021-03-31T10:37:58.562137Z" } }, "outputs": [ { "data": { "text/plain": [ - "['12430', '17732', '14134', '18853', '14073']" + "['14073', '14134', '20274', '15234', '18915']" ] }, "execution_count": 54, @@ -2099,8 +2080,8 @@ "execution_count": 55, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.602541Z", - "start_time": "2021-03-15T10:18:35.596368Z" + "end_time": "2021-03-31T10:37:58.578845Z", + "start_time": "2021-03-31T10:37:58.571732Z" } }, "outputs": [ @@ -2108,10 +2089,10 @@ "data": { "text/plain": [ "['VJ375a660d47a2aa570aa20a8568012da8497ffecf',\n", - " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e',\n", " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf',\n", - " 'VJe6ba07ef9f19ae40517261ad626bf34dd656491a',\n", - " 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e']" + " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e',\n", + " 'VJ235c8fca539cf931b3c673f9b056606384aff950',\n", + " 'VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13']" ] }, "execution_count": 55, @@ -2128,8 +2109,8 @@ "execution_count": 56, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:35.616432Z", - "start_time": "2021-03-15T10:18:35.608874Z" + "end_time": "2021-03-31T10:37:58.590280Z", + "start_time": "2021-03-31T10:37:58.582047Z" } }, "outputs": [ @@ -2140,7 +2121,7 @@ " '490000235YB.link:574',\n", " '490014214HE.link:3154',\n", " '490010689KB.link:981',\n", - " '490015196OG.link:2954']" + " '490000235P.link:15']" ] }, "execution_count": 56, @@ -2171,19 +2152,11 @@ "execution_count": 57, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:36.117140Z", - "start_time": "2021-03-15T10:18:35.622289Z" + "end_time": "2021-03-31T10:38:00.527688Z", + "start_time": "2021-03-31T10:37:58.593669Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "data": { "text/plain": [ @@ -2219,19 +2192,11 @@ "execution_count": 58, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:36.720362Z", - "start_time": "2021-03-15T10:18:36.118567Z" + "end_time": "2021-03-31T10:38:02.116704Z", + "start_time": "2021-03-31T10:38:00.540606Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "data": { "text/plain": [ @@ -2255,27 +2220,19 @@ "execution_count": 59, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.244169Z", - "start_time": "2021-03-15T10:18:36.725395Z" + "end_time": "2021-03-31T10:38:02.732900Z", + "start_time": "2021-03-31T10:38:02.122932Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" - ] - }, { "data": { "text/plain": [ - "['VJ15419796737689e742962a625abcf3fd5b3d58b1',\n", - " 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e',\n", - " 'VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa',\n", - " 'VJ235c8fca539cf931b3c673f9b056606384aff950',\n", - " 'VJ06cd41dcd58d947097df4a8f33234ef423210154']" + "['VJ235c8fca539cf931b3c673f9b056606384aff950',\n", + " 'VJ948e8caa0f08b9c6bf6330927893942c474b5100',\n", + " 'VJ15419796737689e742962a625abcf3fd5b3d58b1',\n", + " 'VJ06cd41dcd58d947097df4a8f33234ef423210154',\n", + " 'VJ8f9aea7491080b0137d3092706f53dc11f7dba45']" ] }, "execution_count": 59, @@ -2293,8 +2250,8 @@ "execution_count": 60, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.255035Z", - "start_time": "2021-03-15T10:18:37.246102Z" + "end_time": "2021-03-31T10:38:02.839175Z", + "start_time": "2021-03-31T10:38:02.777123Z" } }, "outputs": [ @@ -2328,8 +2285,8 @@ "execution_count": 61, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.422120Z", - "start_time": "2021-03-15T10:18:37.258567Z" + "end_time": "2021-03-31T10:38:03.184806Z", + "start_time": "2021-03-31T10:38:02.841689Z" } }, "outputs": [ @@ -2355,16 +2312,16 @@ " \n", " \n", " service_name\n", + " arrival_time\n", + " mode\n", + " from_stop_name\n", " to_stop\n", + " from_stop\n", " route_name\n", - " departure_time\n", - " from_stop_name\n", " route\n", - " service\n", " to_stop_name\n", - " from_stop\n", - " arrival_time\n", - " mode\n", + " service\n", + " departure_time\n", " trip\n", " vehicle_id\n", " \n", @@ -2373,80 +2330,80 @@ " \n", " 0\n", " 205\n", + " 2020-01-01 16:35:25\n", + " bus\n", + " Euston Square (Stop P)\n", " 4900020147W.link:2634\n", + " 490000078P.link:1383\n", " 205\n", - " 2020-01-01 16:33:42\n", - " Euston Square (Stop P)\n", " VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3\n", - " 12430\n", " University College Hosp Warren Street Stn (Sto...\n", - " 490000078P.link:1383\n", - " 2020-01-01 16:35:25\n", - " bus\n", + " 12430\n", + " 2020-01-01 16:33:42\n", " VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:...\n", " veh_388_bus\n", " \n", " \n", " 1\n", " 205\n", + " 2020-01-01 16:37:08\n", + " bus\n", + " University College Hosp Warren Street Stn (Sto...\n", " 490000252V.link:1182\n", + " 4900020147W.link:2634\n", " 205\n", - " 2020-01-01 16:35:25\n", - " University College Hosp Warren Street Stn (Sto...\n", " VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3\n", - " 12430\n", " Warren Street Station (Stop V)\n", - " 4900020147W.link:2634\n", - " 2020-01-01 16:37:08\n", - " bus\n", + " 12430\n", + " 2020-01-01 16:35:25\n", " VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:...\n", " veh_388_bus\n", " \n", " \n", " 2\n", " 205\n", + " 2020-01-01 16:38:51\n", + " bus\n", + " Warren Street Station (Stop V)\n", " 490000091G.link:1242\n", + " 490000252V.link:1182\n", " 205\n", - " 2020-01-01 16:37:08\n", - " Warren Street Station (Stop V)\n", " VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3\n", - " 12430\n", " Great Portland Street (Stop G)\n", - " 490000252V.link:1182\n", - " 2020-01-01 16:38:51\n", - " bus\n", + " 12430\n", + " 2020-01-01 16:37:08\n", " VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:...\n", " veh_388_bus\n", " \n", " \n", " 3\n", " 205\n", + " 2020-01-01 16:40:34\n", + " bus\n", + " Great Portland Street (Stop G)\n", " 490000191B.link:305\n", + " 490000091G.link:1242\n", " 205\n", - " 2020-01-01 16:38:51\n", - " Great Portland Street (Stop G)\n", " VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3\n", - " 12430\n", " Regent's Park (Stop B)\n", - " 490000091G.link:1242\n", - " 2020-01-01 16:40:34\n", - " bus\n", + " 12430\n", + " 2020-01-01 16:38:51\n", " VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:...\n", " veh_388_bus\n", " \n", " \n", " 4\n", " 205\n", + " 2020-01-01 16:42:17\n", + " bus\n", + " Regent's Park (Stop B)\n", " 490007807W.link:2922\n", + " 490000191B.link:305\n", " 205\n", - " 2020-01-01 16:40:34\n", - " Regent's Park (Stop B)\n", " VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3\n", - " 12430\n", " Harley Street (Stop L)\n", - " 490000191B.link:305\n", - " 2020-01-01 16:42:17\n", - " bus\n", + " 12430\n", + " 2020-01-01 16:40:34\n", " VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:...\n", " veh_388_bus\n", " \n", @@ -2455,40 +2412,47 @@ "" ], "text/plain": [ - " service_name to_stop route_name departure_time \\\n", - "0 205 4900020147W.link:2634 205 2020-01-01 16:33:42 \n", - "1 205 490000252V.link:1182 205 2020-01-01 16:35:25 \n", - "2 205 490000091G.link:1242 205 2020-01-01 16:37:08 \n", - "3 205 490000191B.link:305 205 2020-01-01 16:38:51 \n", - "4 205 490007807W.link:2922 205 2020-01-01 16:40:34 \n", + " service_name arrival_time mode \\\n", + "0 205 2020-01-01 16:35:25 bus \n", + "1 205 2020-01-01 16:37:08 bus \n", + "2 205 2020-01-01 16:38:51 bus \n", + "3 205 2020-01-01 16:40:34 bus \n", + "4 205 2020-01-01 16:42:17 bus \n", "\n", - " from_stop_name \\\n", - "0 Euston Square (Stop P) \n", - "1 University College Hosp Warren Street Stn (Sto... \n", - "2 Warren Street Station (Stop V) \n", - "3 Great Portland Street (Stop G) \n", - "4 Regent's Park (Stop B) \n", + " from_stop_name to_stop \\\n", + "0 Euston Square (Stop P) 4900020147W.link:2634 \n", + "1 University College Hosp Warren Street Stn (Sto... 490000252V.link:1182 \n", + "2 Warren Street Station (Stop V) 490000091G.link:1242 \n", + "3 Great Portland Street (Stop G) 490000191B.link:305 \n", + "4 Regent's Park (Stop B) 490007807W.link:2922 \n", "\n", - " route service \\\n", - "0 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 12430 \n", - "1 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 12430 \n", - "2 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 12430 \n", - "3 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 12430 \n", - "4 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 12430 \n", + " from_stop route_name \\\n", + "0 490000078P.link:1383 205 \n", + "1 4900020147W.link:2634 205 \n", + "2 490000252V.link:1182 205 \n", + "3 490000091G.link:1242 205 \n", + "4 490000191B.link:305 205 \n", "\n", - " to_stop_name from_stop \\\n", - "0 University College Hosp Warren Street Stn (Sto... 490000078P.link:1383 \n", - "1 Warren Street Station (Stop V) 4900020147W.link:2634 \n", - "2 Great Portland Street (Stop G) 490000252V.link:1182 \n", - "3 Regent's Park (Stop B) 490000091G.link:1242 \n", - "4 Harley Street (Stop L) 490000191B.link:305 \n", + " route \\\n", + "0 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 \n", + "1 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 \n", + "2 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 \n", + "3 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 \n", + "4 VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3 \n", "\n", - " arrival_time mode trip \\\n", - "0 2020-01-01 16:35:25 bus VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", - "1 2020-01-01 16:37:08 bus VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", - "2 2020-01-01 16:38:51 bus VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", - "3 2020-01-01 16:40:34 bus VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", - "4 2020-01-01 16:42:17 bus VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", + " to_stop_name service \\\n", + "0 University College Hosp Warren Street Stn (Sto... 12430 \n", + "1 Warren Street Station (Stop V) 12430 \n", + "2 Great Portland Street (Stop G) 12430 \n", + "3 Regent's Park (Stop B) 12430 \n", + "4 Harley Street (Stop L) 12430 \n", + "\n", + " departure_time trip \\\n", + "0 2020-01-01 16:33:42 VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", + "1 2020-01-01 16:35:25 VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", + "2 2020-01-01 16:37:08 VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", + "3 2020-01-01 16:38:51 VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", + "4 2020-01-01 16:40:34 VJ03f4f8905d6dc7868242f3fd29828ee9b366a906_16:... \n", "\n", " vehicle_id \n", "0 veh_388_bus \n", @@ -2528,15 +2492,15 @@ "execution_count": 62, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.432536Z", - "start_time": "2021-03-15T10:18:37.423734Z" + "end_time": "2021-03-31T10:38:03.204481Z", + "start_time": "2021-03-31T10:38:03.192854Z" } }, "outputs": [ { "data": { "text/plain": [ - "['20274', '12430', '17732', '14134', '18853']" + "['20274', '14073', '14134', '15234', '18915']" ] }, "execution_count": 62, @@ -2553,8 +2517,8 @@ "execution_count": 63, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.442144Z", - "start_time": "2021-03-15T10:18:37.435211Z" + "end_time": "2021-03-31T10:38:03.230534Z", + "start_time": "2021-03-31T10:38:03.219464Z" } }, "outputs": [ @@ -2579,8 +2543,8 @@ "execution_count": 64, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.598469Z", - "start_time": "2021-03-15T10:18:37.443911Z" + "end_time": "2021-03-31T10:38:03.732232Z", + "start_time": "2021-03-31T10:38:03.235036Z" } }, "outputs": [ @@ -2591,12 +2555,14 @@ "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAACZCAYAAACi7wp2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAcYklEQVR4nO3deXCb13ku8Of7sG8kFmLlTgIUCWq1Za10Eqdx4jqO08RLvZuSHHfGjZ3Jbe4kTetO7kzSZm7be6d32t5OppIcO3acm8WKXUd25EURKZHavEgiKAokRYokiI0guACkuEj3D4CQFFsyLZEAPvL5zWi0DYmjvx6dc97zvsLFixdBRERE1ybmegFERERSwMAkIiKaBwYmERHRPDAwiYiI5oGBSURENA/ya/2l2WxmCS0RES0rsVhM+Lg/5w6TiIhoHhiYRES0LPyPb30TTz755HV/PQOTiIiWNLfRgOdub8AddgsuTExc9/cRrtXph3eYREQkVQaFAs+srcPdVaX4tw9P46WObszMo7vd1e4wr1n0Q0REJDWiANzjrsC313nx9rlB/OmefYidn7rh78vAJCKiJWOd1YxnN6zB1IULeOKtQ/DF4gv2vRmYREQkeTaNGt+5uR6bHTb84/FTePVs34J/Bot+iIho3ixqFV7+n/+Av//Rj3K9FACAUhTxjXoPXrv7TxBKTuKOPfsWJSwB7jCJiGgeak2FaPS68YVSJz7oaEdLfzDXS8Jni+34m1tW4+zoOO7/3X70jiUW9fMYmERE9LEEALeVONDodaOy0IAXT3fj9ld+j+EFKKC5ERUFevzNLatRZtDhh0dP4MBAKCufy8AkIqIraOUyfN1djsfr3BibmsZzvk7s7e3H9IXcvjTUyeV4avUK3OupwE9OncFT77ZkdU0MTCIiAgA4dRo8WluNe9zlOBaK4q8PHsex8FCulwUBwN1VpfjOzStxKBDGXa++jcjEZNbXwcAkIlrm1haZ0Oj1YKvLhle6enHv6++ibzyZ62UBAFZajHh2wxrIRRFPv9uKD6LDOVsLA5OIaBmSCQK+VO7CNq8HFrUKz7d34m9b3sP49EyulwYAMKtV+G/rvLitxIn//X4bft3Zi1y3nmNgEhEtIwVKBe73VODR2moMJJL4yakzeLsvgBxfT2bIBQEP11bhqdW12NN1Dnfs2Yex6elcLwsAA5OIaFmoKNDjsbpqfKWyFPv7g3jq3Va0LWAXnIWwxWnF325Yg1ByAg+9cQBdI2O5XtIVGJhEREvYJocV27xurLWa8fKZs/jyb99COAcFM9dSotfir9evQp3ZiB8dPYG3+wZzvaSPxWklRERLjFIU8ZWqUjxeVw2FKOI5Xyd+292HydnZXC/tCmqZDH+xqgYPr6jCbl8ndrb5MXXhQq6XxWklRERLnUWtwoMrKvHQiiq0x0bwj8fb0BwI5bxY5uP8aXkxvrd+Fd6LDOHu195BMHn9cyqzhYFJRCRxK0wFaKxz4/YyF/b2DOCxN5vQmWf3f3NWmArw7IY1KFAq8J3mozgayv07z/liYBIRSZAA4HPptnXVedS27moKlQp8a50Xd5YX4/982I5fnOnB7DyGOecTBiYRkYRo5DJ8vbocj9dVIzEzg92+TuztyX3buqsRBeDPPZV4Zm0d9vYO4Et79mFkKj+eiXxaDEwiIglwaDV4tLYK93oqcCwUxfcPvZcXbeuu5Ra7Bc9uWIPRqWk07mtGx/Borpd0QxiYRER5bE2RCY1eNxpc9rxrW3c1Dq0G312/EjdZLfjxsZPY2zuQ6yUtCD4rISLKMzJBwBfLXGj0umHVqPH86S78yt+TN23rrkYpithR78E2rxsvdnTjJ6fOYGImv56yzAeflRAR5TmDQoH7a1Jt6wKJJHa2+fFWHrWtuxqZIOCfvvffsQVTONbSgq+//i7683wXfD0YmEREOVZm0OHxOjfurirFH/qD+Ob+Vpwayq+2dR9HJ5fjXk9qbqahtgYvv/UO/nn/4Vwva9HwSJaIKEc2OoqwzevBunTbupc6uhFK5lfbuo/j0GrwWF017nWXoyUYwe42f07Hbi20qx3JMjCJiLJIKYq4q7IEjV43lKKI59q7sKfrXN61rfs4XrMRO+rd+EyxA6909eL59q4lefTKO0wiohwyq1V4qKYSD66oQsdwfretu5wA4LYSB7bXe1Bm0OH59i78oPXDvBm5lU0MTCKiRVRjLECj140vlrmwt3cAj+9rQmc8P9vWXU4tk+Fr1WVo9LqRnJnBrjY/9vYMYEZi3XkWEo9kiYgWmADgs8WptnVuY6pt3S/OnEUsT9vWXa5IrcIjtdV4oKYC70di2O3rxJFQNNfLyioeyRIRLTKNPLUre6zOjcmZWez2+fG7PG5bdzmPsQDb0jvh13v68cAbB9AzOp7rZeUV7jCJiG6QQ6vBI7VVuM9TgWPhITzn80tmCkeDy4ZtXg9qTYV4saMLP+84m7cN3LOFVbJERAtsdZEJ29Jt6/Z0ncPz7Z1537YOuDRgepvXDQDY7evEa919eTG8OR8wMImIFoBMEHB7um2dTUJt6wDAqFLiwZpKPFxbhTPDo9jl86M5EM71svIO7zCJiG6AQaHAfZ5yPFpXjWBiArvb/Hirb1ASMx0rCvRorHPjrsoS7DsXwPZ9B3EmLu3JIbnAwCQiuoZU27pq3F1VhgMDQTyz/whODkmjq80GexG2ed3pTkI9uGPPPkQnz+d6WZLFI1kioo8xFzY32Sz4xZkevNjRJYm2dXJBwB0Vxdju9UCvkOO59k78plManYTyBY9kiYg+gVIU8eXKEjTWuaGSpdrWffvAUUmEjV4hx5/XVOKx2mr0jSfwrydO492+wbzvJCQlDEwiWvbMKiUeXFGFh9Jt6/75/TY0DeR/2zoAKNZp8bi3Gl+rLseBgSD+UiKTTqSIgUlEy5bHWIDGOje+VO7CGxJqWwcAa4pM2F7vwWaHFb/u7MVXXn0bweRErpe1pPEOk4iWFQHAD57+S9wkuwDTQA9e6ujGyx3SaFsnCsAXSl3Y5nXDodPgp75O/NLfi8RM/j9pkRLeYRLRsqYURdxdVYrt9R64NqzHG61H8He/flMSj/W1chnucZej0etGbHIKO9v82HcuIIknLUsJd5hEtKTNPdZ/pLYa7bE4dvn8ODQYyfWy5sWuVeOR2mrc76nA0VAUO9v8eD8Sy/WyljzuMIloWUm9n3Tjq1WleKtvENv2NUvmsX6dqRDb6t24rcSJV7vP4b7f7ce5sUSul7XscYdJREvK2iITdtTXYIOjCL8404Ofne5CeCL/30/OjQTbVu9GVYEBL5zuwstnzmJ0avkNas417jCJaMkSBeBPSl3YUe+BTaPGc75OfPfgMSRn8v/9pEom4qtVZdjudeP87AXs9PmxVyIjwZYbBiYRSZZaJsPX3eXY5nVj5PwU/lNCxTBmtQoPr6jCQysqcTI6jB8c/hCtQWncrS5XDEwikhyLWoVHaqvwYE0l3ovE8L2Dx3E8LI35k9WFBmzzunFHeTH29gzgkTeb0DUijbefyx0Dk4gk4/Kweb2nHw+8cQA9o+O5Xta8bHZYsb3eg5UWI17s6MYXX/m9JN5+0iUs+iGivLfBXoQn6j1YVWTCix3deOl0tyTCRiEK+HJFKbbXu6EQRezydeK3Xeck8fZzOeMAaSKSFJkg4I7yYuyo90CnkGNXmx97us/h/Gz+h02hUoEHairxSF01uuJj2OXzS6Y3LbFKlogkQieX476aCjTWuTEwnsC/ftiOd/uDkgibMoMOjV437q4sxdt9g/jGW4dwengk18uiBcLAJKK84NBq8FhdNe51l+PQYATP/OEwTkSlMaj5ZpsF271urLen3n7e+du3JPH2kz4dHskSUU7VmgqxPd3VZk/XOfy0vRP948lcL+sTyQQBXyp3YbvXA6NKid2+TvymqxcTEnj7SdfGI1kiyisNLhueqPeg2liAF9q78MMjJyTR1UavkONeTwUer6vGYGIC/3GyA+/0D4J9BpY+BiYRZY1SFHFXZQm213tw8SKwy+fHf53tk0RXG6cudWR8T3U5Dg6G8a0/HJHMkTEtDAYmES26gnTV6KN11eiMj+LHx06iORDO9bI+kUwmwwNf+DzWT8Sx1WnDb7rO4c/+6x0EEhzUvBzxDpOIFk2JXovGOje+Wl2Gd/oGsdvXmfdVo8U6LTY7rdjosOLzDVtR9u3v4+/uvB0vnPBhfJqDmpcDvsMkoqxZXWTCjnoPNjms+JW/By+c7kYwmZ+7MptGjU0OKzY5rdjksEIjl6E1GEHLYAStwQhiFwWMj0ujmxAtDAYmES0qAcBtpU48Ue+BU6fBT32d+KW/F4mZ/NqVmVRKbHQUYZPDhk1OK8wqJY6GomgJRtA6GEEn+7oue6ySJaJFoZKJ+Fp1amLI+PQMdradwZu9+TMxxKBQ4BZHETY5irDJYUWJXodjoShagxH8P/9ZtMdGJNEUgXKPO0wiui5mlRIP11bjoRWV+DA6jJ1tZ3A0lPuJIRq5DDfbLNjssGKj04rqQgM+jMTQMhjB4WAEp4bimMmTMKf8xCNZIloQlQV6bPO6cWdFCfb2DGC3z4/uHE4MUYoi1lrN2Jy+g6wzG+GLxdN3kGF8GBlms3P6VBiYRHRD1tss2FHvwTqrGS91nMXPOroRmzyf9XXIBQGrikyZQp01RWb446NoTd9BHg8PYXKW3Xbo+jEwiehTkwkCvljmwo6VHhQoFNjt68QrXeeyGkiiANSZjJkq1vU2C86NJdASTB2xHg1F+dyDFhQDk4jmTSuX4T5PBR6vcyOYnMCuNn9W2795jAWZO8gN9iJEJyYzVaxHQlHEJTALk6SLgUlEn8imUePRumrc76nA4WAEu9r8+CAL7d/KDTpsdtqwyWHFRkcRkjMzmXeQh4NRRDj5g7KIgUlEV1VjLMCOeg8+X+rEq93n8JyvE32LODHEpdNk7iA3O2wAgJZgGK3pkGTrOcolBiYRfcRWpw3b6z1YYUpNDHn5zFmMLMLEEKtGjU2OImx0WLHZaYVOLk/fQUbRMhhG71hiwT+T6HoxMIkIAKAQBdxZUYId9R7IBAG7fJ14rbtvQZ9eGFVKbLQXZQp1ijRqHAlF0ToYRmswCn98dME+i2ihMTCJljmDQoEHairwWJ0bXSNj2NnmR1MgtCDfW6+Q4xZ7qpPOZmeqm87x8FCmJ+vp4TjnRZJkMDCJlimXToNGrxtfqy7H/v4gdrX50X6DE0PmuulsdFix2WFFtdGADyPDOByMoCUYwanoMLvpkGQxMImWmZUWI3bUe7DVacOvOnvxfHvXdU8MmeumM1eo401305kr0vkgEmM3HVoyGJhEy4AA4HMlDuyo96BUr8Nz7Z34pb/nUz/slwkCVlmM2JR+6rHGakLXyFgmII+HhzAxw246tDRxWgnREqYURfxZdRm2e92YmJ3FzjY/3ugZmPexqCgAtSYjNjmKsNlpw802C/rHE2gNRvB8eyeO7Gc3HSLuMIkkzKRS4qEVVXi4tgqnosPY6fPjcDA6r691Gw2pIh2HFRscVgylu+kcTj/3GGY3HVqmeCRLtISUG3TY5vXgrsoSvNkbwG6f/xMHH5cZdNicvoPc6LBicmY2M9HjcDCKMLvpEAFgYBItCTdZzdixsgbrbRb8vOMsfna6C9GrTAxxznXTSf8QRSFzB9k6GMFAYvE6+RBJGQOTSKJEAbi91IUd9R6Y1Srs8nXila7ejxTdWNSqy9rNWaFXyNEajGaeevTkcGYlkZSw6IdIYjRyGe5xl2Ob143IxHn8Z5sfb/UFMg0ACpUKbHRYM+3mbJluOhG80N4Ff3wU/B8v0cLhDpMoz1g1ajxSW4UHaipxNBTFzjY/3o/EoFfIsd52qd1cueHKbjrt7KZDtCB4JEuU59xGA7Z7Pbi9zIXXzvbh5x3d6ablNmx2WuE2GnAimu6mMxjBSXbTIVoUDEyiPLXJYcWOeg+8ZiP29w9i+PwU1lnNqLeY0B6LpyZ6BMN4P8xuOkTZwDtMojwiFwTcVVGCp9bUokCpQGxyCjqFDLVmI1oHw/iPk2dwPBxFkt10iPIGA5MoSwQA66xmfGNlDRpcdshFAcHEBF4724+WYARHg1GMTS/8LEoiWhgMTKJF5C40YKPDis+VOLDJYYVCFNA3nsC/fODDbzp7EWM3HSLJYGASLaAygy4zE3KL0wbt2vUY6e+DPhbBK129+L8nOzCYuL6JIUSUWwxMoutkUauwpsiEzxbbsdpqRmWBAQpRwPSFi1DJRMQmz+PCmvVoi4/jr37yPJuXE0kcq2SJrkKvkKNEr0OJXosSgw6leh2qCvSoNhpQpFZDFICLACITk+iMj+G98BA+iMbQN5bAYGKCFa1EEsUqWaI/ohRFuPRalOi1KP2jYCzRa6GSyRBIJJCcmYVCFGFRq6FTyHEyOoyftXfjD4Egzgyzmw7RcsHApCVLAGDXalBq0KZ3iqkgLDWkfraoVQgmJ9A3lkT/eAL940kcGAjCoFCgvECPtVYzKgr0eC8cyzQL8MXimGWzAKJliUeyJGlGlTK1M9TrUJYOwrlgdOm1GDk/jb7xBPrHUoHYP55I/z6JYHICclHATVZLpt3cClMhTkaHUxM9ghGciMYwzX5zRMsKO/2QJKllMpQYLjsy1esyO8RSvQ4XcBH96R3iuXQQzu0W+8cTOD975T2iQhSwusicmQu50mJCx/BIph/r+5Ghj3wNES0vDEzKS3JBgFOnSe0KLwvCuaNTvUKBgUTyyh3iWAJ96V+PTl39ob9MEFBZqIfXbITXbMRDP/wx9ENhfPDS85mRV8dDQ0jMsHqViC5hYFLOFKlVKDHoUKbXocRw6ci0RK+DXatGZOL8pV3hWPrIdDyJvrEEIhOT8yqqUYoiVpgK4TUXot6SCkiPsQDhiUn4YnH4huKYLi7D0bO9OHnGv+j/ZiKSLgYmLRq9Qp7aFRou7QzndonFei0mZmYz94aX3yf2jScwmEh+6jtCg0KBOnMhvBYjvOZCeM1GlBv0ODs6hvbYCNqG4vDF4jg9PMK3j0T0qTEw6bopRRHFmftD7R9Vm+qgEMUrdoip+8TUrwfGkzd05GnVqDOh6DUb4bUUwqJWo2N4JLVzjI3ANxSHPz7Kd49EtCAYmHRVogDYNJorq0zTwViq18GsVmIwMZGuMP3ofeJC9UMtM+jgNReiLh2O9RYj5IIAX2wE7bF4JiDPjo5xUDIRLRoG5jJnUimv2BmWXhaKTp0G8fNTmXvD/svuEPvHEwglJxf07aFcEFBVaMjcNc6F5Pj0dGbH6IvF0RaLs+8qEWUdA3OJ08hl6R3hpR1i6dxjfYMWsxcuXvEOMfNYfyyBgURy0Z5SqGUy1JoK4LUYMztHj9GAwcREphhnbgfJyR1ElA/YGk/i5IKQaeM217WmNHNsqoVOocDA+KXnFv3jSRwPDWXCMRtzFguUisyOMXXfaESpXoeukbH0cWocr3T24vTwCAcjE5HkcIeZR6wa9UeqTOd2iDZN6vnFFUeml1Wczvf5xUKxa9WXFeKkQtKoUuJ0bOSKO0d/fJSdcohIUngkmwc8VZUo02shiw9f0ei7NN3GLTk9kwnCS/1NU4EYGE9iJgc9TAWkinEu3TemwlEQhMyRalu6GKd3dJyNyIlI8hiYOeI2GnCry45bXXZ8/q++i4nzU9j/L//0ka41A+OJnB9TKkQB7sKCzI6xzmxEnakQI1PTl903psIxmGQxDhEtTQzMLClUKrDFacOtxXY0uGyYvXgRTQMhNAXCOBqJYXx6BjN50IpNI5eh1nTl+8bqQgMGxpNXvG9sHx5BnMU4RLSMMDAXiUwQsKrIlN5F2uAxFuBYeCgdkiGcHR3P9RJhVCkzhTj16WpVl06DzvjYpXCMxdExPIIJFuMQ0TLHwFxADq0GDS4bPlNsx2anDcHEBJoDIRwYCOF4eCinHWccWs0V7xu9ZiMKlAq0D1/5vrErPpaTO1EionzHwLwBKpmIW+xFqV1ksR0WtQqHBsNoGgihORBGeGIy62sSBaDCoE/fN166c7xw8SJ8l/VT9cXi6BtLsBiHiGieGJifkrvQgIbiVLHOTTYzTsdG0BwIoykQwqmh4ay1ZpPL5dBrNHApZKkdYzogV5gKMDw5lQlF31DqWDUX4U1EtJQwMD9BwVyxjsuOW4ttuHARaAqE0DQQQstgJCsP/+eIArDKkroXfezpZ+BYtRYn//7ZzF2jLxZHe2zkmrMgiYjo+jAw/4goAKstpswusiZdrNOcDsnuLBfrOHUaNKQLhzY7bQglJ9AUCOFEcgrnpi+izc8ZjkRE2cDARKo7za0uOxpcdmxxWhGemERTIITmgTCOhqJZLdbRymXYYLfi1mIbtrrsMKmUOJg+8j2Yo3tRIiJapoGpFEVscBRldm5WjRqHBiOpkAyEEEpmL5QEAHVmIxpcqWPfVUUmnIwOp9cSRnsszsIcIqI8sGwCs7rQgFtdNjS47LjZZkFHfBTN6TeRJ7NYrAMANo0aW9MBucVpRXxqGgcDITQNhHEkFMl5Zx8iIvqoJRuYBoUCW5zWzF2kAGR2kIcGI1ktjJl7fjIXknatBi2DYTQFwjgYCCHA2Y5ERHlvyQTm5RWkDcV2rDAV4L1wDE0DQTQFwugaGcvqemqMBalj1mI71lpTz0/m7iKzvaMlIqIbJ+nAtGnUmd6sW5w2RCcm0RQIozkQwtFQdNGGH38cs1qFrU4rGlx2bHXZMDV7IfP8pDUYwfh07vvEEhHR9ZNUYCpFEevtlkxnHbtWc0VnnWxOylCKItbZzOnCITvKDDq0BiNoTgf2ubFE1tZCRESLL+8Ds6pAn95F2rHeZoE/PoqmQBhNA0GcyPLRZlWBHg2u1I72FnsRukbGMgH5QSTGHqxEREtY3gWmXiHPdNZpKLZBJghoGkjd/bUMhjGSxWKdQqUCm502NKSra0UBaBpIBWRLMMLxVkREy0jOA1MAsNJiwq3FqZCsNRfi/XAsc//XmcViHbkgYI3VnAlId6Eh0+WnOQeFQ0RElD9yEphWjRq3pitItzhtiE2eR1N6DFa2i3XKDDo0uFJddTY5itA3lswE5Hs5HslFRET5IyuBqRRF3GyzZCpanTpt5h1i00Aoq8U6eoUcmxzWzF2kRi5Hc7rt3MHBMIYmz2dtLUREJB2LEpharRY3V1eiYnoCnyl2YL3Ngs6RMTQNhHAgEMLJ6DBms1QgIwrpI9/0c486cyE+iMQyxTodw6NZWQcREUnbogTmk08+ie8//U38/C8acWAghENZLtaZm/DR4LJhsyPVTL05R+8ziYhoaViUwJTJZCgsLEQsFrvB5c2PRi7DRrs1Xaxjg0mtwsF0QB4cDGe1mToRES1NOa+SvR6pCR+FmV3kqiITTkXjmWIdHyd8EBHRArtaYMqzvZBPYtWosdVpS82JdNowMjWN5kAIu32dOBKMIjHD1nNERJR9OQ9MlUzEelsRGoptaHDa4dRp0JKeWfm/3vNhIJHM9RKJiIhycyTrmZvw4bJjnc2MjuHUzMrmQAgnh+JZq6wlIiL6Yzm9wzSrlNiS7qqz1WXD9OwFNAdCaAqE0ToYwdh09ipriYiIriWrd5gKUcA6qyU14aPYhnKDHoeDETQFwvj3E6c54YOIiCRnwQKzskCf6c16i70I3aNjOBgI40dHTnDCBxERSd4NHcl+95mnUR4NoO78OGSCgOZ0CzxO+CAiIqlalCNZ7+o1CLWM4onXf88JH0REtKTldeMCIiKibLvaDlPM9kKIiIik6Jo7TCIiIkrhDpOIiGgeGJhERETzwMAkIiKaBwYmERHRPDAwiYiI5oGBSURENA//H3J84GgohXTmAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2608,7 +2574,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 64, @@ -2632,8 +2598,8 @@ "execution_count": 65, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.606845Z", - "start_time": "2021-03-15T10:18:37.600317Z" + "end_time": "2021-03-31T10:38:03.745265Z", + "start_time": "2021-03-31T10:38:03.734927Z" } }, "outputs": [ @@ -2641,10 +2607,10 @@ "data": { "text/plain": [ "['VJ375a660d47a2aa570aa20a8568012da8497ffecf',\n", - " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e',\n", " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf',\n", - " 'VJe6ba07ef9f19ae40517261ad626bf34dd656491a',\n", - " 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e']" + " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e',\n", + " 'VJ235c8fca539cf931b3c673f9b056606384aff950',\n", + " 'VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13']" ] }, "execution_count": 65, @@ -2661,8 +2627,8 @@ "execution_count": 66, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.620926Z", - "start_time": "2021-03-15T10:18:37.612399Z" + "end_time": "2021-03-31T10:38:03.757152Z", + "start_time": "2021-03-31T10:38:03.748493Z" } }, "outputs": [ @@ -2687,8 +2653,8 @@ "execution_count": 67, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.765236Z", - "start_time": "2021-03-15T10:18:37.623805Z" + "end_time": "2021-03-31T10:38:04.251828Z", + "start_time": "2021-03-31T10:38:03.760394Z" } }, "outputs": [ @@ -2697,7 +2663,9 @@ "output_type": "stream", "text": [ "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -2714,7 +2682,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 67, @@ -2738,8 +2706,8 @@ "execution_count": 68, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:18:37.779974Z", - "start_time": "2021-03-15T10:18:37.775032Z" + "end_time": "2021-03-31T10:38:04.295006Z", + "start_time": "2021-03-31T10:38:04.287695Z" } }, "outputs": [ @@ -2758,18 +2726,11 @@ "stop = n.schedule.stop('490007807E.link:1154')\n", "stop.print()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/4.2. Using Network - Road Pricing.ipynb b/notebooks/4.2. Using Network - Road Pricing.ipynb index 3be4fff9..a42b6eb4 100644 --- a/notebooks/4.2. Using Network - Road Pricing.ipynb +++ b/notebooks/4.2. Using Network - Road Pricing.ipynb @@ -21,8 +21,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.233767Z", - "start_time": "2020-12-17T10:17:48.480684Z" + "end_time": "2021-03-31T10:57:27.521453Z", + "start_time": "2021-03-31T10:57:22.685884Z" } }, "outputs": [ @@ -99,14 +99,24 @@ } ], "source": [ + "from genet import read_matsim\n", "import pandas as pd\n", - "from genet import Network\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.link_attribute_summary()" ] }, @@ -163,8 +173,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.254260Z", - "start_time": "2020-12-17T10:17:52.242046Z" + "end_time": "2021-03-31T10:57:27.538464Z", + "start_time": "2021-03-31T10:57:27.523859Z" } }, "outputs": [], @@ -284,8 +294,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.290289Z", - "start_time": "2020-12-17T10:17:52.257740Z" + "end_time": "2021-03-31T10:57:27.557260Z", + "start_time": "2021-03-31T10:57:27.540516Z" } }, "outputs": [ @@ -379,11 +389,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.325624Z", - "start_time": "2020-12-17T10:17:52.316204Z" + "end_time": "2021-03-31T10:57:27.577336Z", + "start_time": "2021-03-31T10:57:27.567268Z" } }, "outputs": [], @@ -401,11 +411,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.513723Z", - "start_time": "2020-12-17T10:17:52.338671Z" + "end_time": "2021-03-31T10:57:27.650345Z", + "start_time": "2021-03-31T10:57:27.579173Z" } }, "outputs": [ @@ -413,7 +423,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2/2 [00:00<00:00, 16.31it/s]\n" + "100%|██████████| 2/2 [00:00<00:00, 48.24it/s]\n" ] } ], @@ -444,11 +454,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.537416Z", - "start_time": "2020-12-17T10:17:52.517271Z" + "end_time": "2021-03-31T10:57:27.665049Z", + "start_time": "2021-03-31T10:57:27.652131Z" } }, "outputs": [ @@ -504,7 +514,7 @@ "1 546461337 A3211 Byward Street True" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -518,11 +528,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.573364Z", - "start_time": "2020-12-17T10:17:52.546660Z" + "end_time": "2021-03-31T10:57:27.687054Z", + "start_time": "2021-03-31T10:57:27.667609Z" } }, "outputs": [ @@ -594,7 +604,7 @@ "1 2.9 00:00 23:59 " ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -609,11 +619,11 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.638469Z", - "start_time": "2020-12-17T10:17:52.602486Z" + "end_time": "2021-03-31T10:57:27.699021Z", + "start_time": "2021-03-31T10:57:27.694226Z" } }, "outputs": [], @@ -631,11 +641,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T10:17:52.710288Z", - "start_time": "2020-12-17T10:17:52.648912Z" + "end_time": "2021-03-31T10:57:27.728619Z", + "start_time": "2021-03-31T10:57:27.700952Z" } }, "outputs": [], @@ -657,7 +667,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -671,7 +681,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/4.3. Using Network - Routing.ipynb b/notebooks/4.3. Using Network - Routing.ipynb index 57b3f2a7..0670d00d 100644 --- a/notebooks/4.3. Using Network - Routing.ipynb +++ b/notebooks/4.3. Using Network - Routing.ipynb @@ -37,14 +37,23 @@ } ], "source": [ - "# read sample network\n", - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.print()" ] }, @@ -208,7 +217,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -222,7 +231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/5.1. Modifying Network - Basics.ipynb b/notebooks/5.1. Modifying Network - Basics.ipynb index 3c779df6..c0550ebd 100644 --- a/notebooks/5.1. Modifying Network - Basics.ipynb +++ b/notebooks/5.1. Modifying Network - Basics.ipynb @@ -13,49 +13,47 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:24.432738Z", - "start_time": "2021-02-23T20:44:20.074138Z" + "end_time": "2021-03-31T10:57:07.774953Z", + "start_time": "2021-03-31T10:57:00.936146Z" } }, "outputs": [ { - "data": { - "text/plain": [ - "\n", " \n", " 0\n", - " 2021-02-23 20:44:24\n", + " 2021-03-31 11:57:07\n", " add\n", " link\n", " None\n", @@ -504,7 +502,7 @@ " \n", " \n", " 1\n", - " 2021-02-23 20:44:24\n", + " 2021-03-31 11:57:07\n", " add\n", " node\n", " None\n", @@ -515,7 +513,7 @@ " \n", " \n", " 2\n", - " 2021-02-23 20:44:24\n", + " 2021-03-31 11:57:07\n", " add\n", " link\n", " None\n", @@ -526,7 +524,7 @@ " \n", " \n", " 3\n", - " 2021-02-23 20:44:24\n", + " 2021-03-31 11:57:07\n", " modify\n", " node\n", " proposed_index\n", @@ -537,7 +535,7 @@ " \n", " \n", " 4\n", - " 2021-02-23 20:44:24\n", + " 2021-03-31 11:57:07\n", " modify\n", " node\n", " proposed_index\n", @@ -552,11 +550,11 @@ ], "text/plain": [ " timestamp change_event object_type old_id \\\n", - "0 2021-02-23 20:44:24 add link None \n", - "1 2021-02-23 20:44:24 add node None \n", - "2 2021-02-23 20:44:24 add link None \n", - "3 2021-02-23 20:44:24 modify node proposed_index \n", - "4 2021-02-23 20:44:24 modify node proposed_index \n", + "0 2021-03-31 11:57:07 add link None \n", + "1 2021-03-31 11:57:07 add node None \n", + "2 2021-03-31 11:57:07 add link None \n", + "3 2021-03-31 11:57:07 modify node proposed_index \n", + "4 2021-03-31 11:57:07 modify node proposed_index \n", "\n", " new_id old_attributes \\\n", "0 proposed_index None \n", @@ -594,8 +592,8 @@ "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:24.972269Z", - "start_time": "2021-02-23T20:44:24.965821Z" + "end_time": "2021-03-31T10:57:08.555304Z", + "start_time": "2021-03-31T10:57:08.549452Z" } }, "outputs": [ @@ -619,8 +617,8 @@ "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:24.979999Z", - "start_time": "2021-02-23T20:44:24.974217Z" + "end_time": "2021-03-31T10:57:08.569438Z", + "start_time": "2021-03-31T10:57:08.558118Z" } }, "outputs": [ @@ -644,8 +642,8 @@ "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:24.987164Z", - "start_time": "2021-02-23T20:44:24.981816Z" + "end_time": "2021-03-31T10:57:08.580033Z", + "start_time": "2021-03-31T10:57:08.571615Z" } }, "outputs": [ @@ -676,8 +674,8 @@ "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:25.674664Z", - "start_time": "2021-02-23T20:44:24.989134Z" + "end_time": "2021-03-31T10:57:09.627482Z", + "start_time": "2021-03-31T10:57:08.581876Z" } }, "outputs": [ @@ -685,7 +683,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:25,667 - Changed Link attributes for 3166 links\n" + "2021-03-31 11:57:09,617 - Changed Link attributes for 3166 links\n" ] } ], @@ -709,8 +707,8 @@ "execution_count": 18, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:25.685698Z", - "start_time": "2021-02-23T20:44:25.678609Z" + "end_time": "2021-03-31T10:57:09.665129Z", + "start_time": "2021-03-31T10:57:09.654559Z" } }, "outputs": [ @@ -769,8 +767,8 @@ "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:25.696773Z", - "start_time": "2021-02-23T20:44:25.690892Z" + "end_time": "2021-03-31T10:57:09.677997Z", + "start_time": "2021-03-31T10:57:09.669585Z" } }, "outputs": [], @@ -792,8 +790,8 @@ "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.136654Z", - "start_time": "2021-02-23T20:44:25.698366Z" + "end_time": "2021-03-31T10:57:10.217452Z", + "start_time": "2021-03-31T10:57:09.679346Z" } }, "outputs": [ @@ -801,13 +799,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:26,133 - Added Route with index `new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'new_route', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']} to Service `20274` within the Schedule\n" + "2021-03-31 11:57:10,205 - Added Route with index `new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'new_route', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']} to Service `20274` within the Schedule\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 20, @@ -850,8 +848,8 @@ "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.172105Z", - "start_time": "2021-02-23T20:44:26.138329Z" + "end_time": "2021-03-31T10:57:10.289271Z", + "start_time": "2021-03-31T10:57:10.220479Z" } }, "outputs": [ @@ -859,15 +857,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:26,151 - Route with ID `new_route` within this Service `new_service` already exists in the Schedule. This Route will be reindexed to `new_service_new_route`\n", - "2021-02-23 20:44:26,158 - Reindexed Route from new_route to new_service_new_route\n", - "2021-02-23 20:44:26,167 - Added Service with index `new_service`, data={'id': 'new_service', 'name': 'N55'} and Routes: ['new_service_new_route']\n" + "2021-03-31 11:57:10,242 - Route with ID `new_route` within this Service `new_service` already exists in the Schedule. This Route will be reindexed to `new_service_new_route`\n", + "2021-03-31 11:57:10,254 - Reindexed Route from new_route to new_service_new_route\n", + "2021-03-31 11:57:10,278 - Added Service with index `new_service`, data={'id': 'new_service', 'name': 'N55'} and Routes: ['new_service_new_route']\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 21, @@ -891,8 +889,8 @@ "execution_count": 22, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.185499Z", - "start_time": "2021-02-23T20:44:26.174295Z" + "end_time": "2021-03-31T10:57:10.303375Z", + "start_time": "2021-03-31T10:57:10.294731Z" } }, "outputs": [], @@ -918,8 +916,8 @@ "execution_count": 23, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.208264Z", - "start_time": "2021-02-23T20:44:26.197625Z" + "end_time": "2021-03-31T10:57:10.320631Z", + "start_time": "2021-03-31T10:57:10.313983Z" } }, "outputs": [ @@ -943,8 +941,8 @@ "execution_count": 24, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.226893Z", - "start_time": "2021-02-23T20:44:26.215627Z" + "end_time": "2021-03-31T10:57:10.340717Z", + "start_time": "2021-03-31T10:57:10.324482Z" } }, "outputs": [ @@ -952,13 +950,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:26,222 - Added Route with index `another_new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']} to Service `20274` within the Schedule\n" + "2021-03-31 11:57:10,334 - Added Route with index `another_new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']} to Service `20274` within the Schedule\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 24, @@ -975,35 +973,35 @@ "execution_count": 25, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.234393Z", - "start_time": "2021-02-23T20:44:26.228682Z" + "end_time": "2021-03-31T10:57:10.356435Z", + "start_time": "2021-03-31T10:57:10.342584Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'services': ['18853', '20274', '14134'],\n", - " 'routes': ['VJ256e98df611ff48afe737ddc81cbcde82e4e81c8',\n", - " 'new_route',\n", + "{'services': ['18853', '14134', '20274'],\n", + " 'routes': ['another_new_route',\n", + " 'VJf9a22035ae6f25bb420df833474943ad76065c89',\n", + " 'VJd78967364a302cf232c5139d40622dcb6c238c9e',\n", " 'VJf3e316e5e605bb512147dee2a989be5a82ef1b5f',\n", - " 'VJ2aba67e3ed98f2ed5f5966c1ac394cbf6d1943d7',\n", - " 'VJa7f37392e276aeac26c7e73bbc05e6a71af38dba',\n", - " 'another_new_route',\n", + " 'VJ375a660d47a2aa570aa20a8568012da8497ffecf',\n", + " 'VJ256e98df611ff48afe737ddc81cbcde82e4e81c8',\n", " 'VJ4e2b897edf0e7b8a8e3b5516ab43ce56f72c5cff',\n", + " 'new_route',\n", " 'VJdf3936da1a51eb33db594ef99738802c14b19995',\n", - " 'VJ12ba6089dfb2733e29c415a1a0015fef30fd5305',\n", - " 'VJ375a660d47a2aa570aa20a8568012da8497ffecf',\n", - " 'VJf9a22035ae6f25bb420df833474943ad76065c89',\n", - " 'VJd78967364a302cf232c5139d40622dcb6c238c9e'],\n", + " 'VJ2aba67e3ed98f2ed5f5966c1ac394cbf6d1943d7',\n", + " 'VJa7f37392e276aeac26c7e73bbc05e6a71af38dba',\n", + " 'VJ12ba6089dfb2733e29c415a1a0015fef30fd5305'],\n", " 'id': '490000235X.link:834',\n", " 'x': 529981.7958802709,\n", " 'y': 181412.0975758662,\n", " 'epsg': 'epsg:27700',\n", " 'name': 'Tottenham Court Road Station (Stop X)',\n", - " 'lat': 51.51668503324075,\n", - " 'lon': -0.12809598708996447,\n", - " 's2_id': 5221390722025467597,\n", + " 'lon': 51.51668503324075,\n", + " 'lat': -0.12809598708996447,\n", + " 's2_id': 2507584377443783851,\n", " 'additional_attributes': {'isBlocking', 'linkRefId', 'name'},\n", " 'linkRefId': '834',\n", " 'isBlocking': 'false'}" @@ -1023,8 +1021,8 @@ "execution_count": 26, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:26.269272Z", - "start_time": "2021-02-23T20:44:26.236192Z" + "end_time": "2021-03-31T10:57:10.391008Z", + "start_time": "2021-03-31T10:57:10.367522Z" } }, "outputs": [ @@ -1032,13 +1030,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:26,257 - Added Route with index `another_new_route_2`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_2', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']} to Service `20274` within the Schedule\n" + "2021-03-31 11:57:10,385 - Added Route with index `another_new_route_2`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_2', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']} to Service `20274` within the Schedule\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 26, @@ -1078,8 +1076,8 @@ "execution_count": 27, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.070100Z", - "start_time": "2021-02-23T20:44:26.273529Z" + "end_time": "2021-03-31T10:57:11.462538Z", + "start_time": "2021-03-31T10:57:10.394784Z" } }, "outputs": [ @@ -1087,14 +1085,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,058 - The following stops will inherit the data currently stored under those Stop IDs in the Schedule: ['490000235X.link:834', '490010689KB.link:981'].\n", - "2021-02-23 20:44:27,064 - Added Route with index `another_new_route_3`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_3', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']} to Service `20274` within the Schedule\n" + "2021-03-31 11:57:11,446 - The following stops will inherit the data currently stored under those Stop IDs in the Schedule: ['490000235X.link:834', '490010689KB.link:981'].\n", + "2021-03-31 11:57:11,454 - Added Route with index `another_new_route_3`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_3', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']} to Service `20274` within the Schedule\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -1139,8 +1137,8 @@ "execution_count": 28, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.079177Z", - "start_time": "2021-02-23T20:44:27.072775Z" + "end_time": "2021-03-31T10:57:11.482502Z", + "start_time": "2021-03-31T10:57:11.464235Z" } }, "outputs": [ @@ -1164,8 +1162,8 @@ "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.465665Z", - "start_time": "2021-02-23T20:44:27.080781Z" + "end_time": "2021-03-31T10:57:11.911256Z", + "start_time": "2021-03-31T10:57:11.486696Z" } }, "outputs": [ @@ -1173,14 +1171,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/PycharmProjects/ABM/genet/genet/schedule_elements.py:1037: UserWarning: DataFrame columns are not unique, some columns will be omitted.\n", - " self.vehicles = {**df.T.to_dict(), **self.vehicles}\n" + "/Users/kasia.kozlowska/PycharmProjects/ABM/genet/genet/schedule_elements.py:1186: UserWarning: DataFrame columns are not unique, some columns will be omitted.\n", + " self.vehicles = {**df.T.to_dict(), **self.vehicles}\n", + "2021-03-31 11:57:11,900 - The following vehicle types are missing from the `vehicle_types` attribute: {'bus'}\n", + "2021-03-31 11:57:11,904 - Vehicles affected by missing vehicle types: {'fun_bus_1': {'type': 'bus'}, 'fun_bus_2': {'type': 'bus'}, 'some_bus_2': {'type': 'bus'}}\n" ] }, { "data": { "text/plain": [ - "True" + "False" ] }, "execution_count": 29, @@ -1198,8 +1198,8 @@ "execution_count": 30, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.473655Z", - "start_time": "2021-02-23T20:44:27.469483Z" + "end_time": "2021-03-31T10:57:11.925152Z", + "start_time": "2021-03-31T10:57:11.921089Z" } }, "outputs": [ @@ -1223,8 +1223,8 @@ "execution_count": 31, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.499200Z", - "start_time": "2021-02-23T20:44:27.475558Z" + "end_time": "2021-03-31T10:57:11.949736Z", + "start_time": "2021-03-31T10:57:11.929296Z" } }, "outputs": [ @@ -1262,7 +1262,7 @@ " \n", " \n", " 0\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1273,7 +1273,7 @@ " \n", " \n", " 1\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " service\n", " None\n", @@ -1284,7 +1284,7 @@ " \n", " \n", " 2\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1295,7 +1295,7 @@ " \n", " \n", " 3\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1306,7 +1306,7 @@ " \n", " \n", " 4\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:11\n", " add\n", " route\n", " None\n", @@ -1321,11 +1321,11 @@ ], "text/plain": [ " timestamp change_event object_type old_id new_id \\\n", - "0 2021-02-23 20:44:26 add route None new_route \n", - "1 2021-02-23 20:44:26 add service None new_service \n", - "2 2021-02-23 20:44:26 add route None another_new_route \n", - "3 2021-02-23 20:44:26 add route None another_new_route_2 \n", - "4 2021-02-23 20:44:27 add route None another_new_route_3 \n", + "0 2021-03-31 11:57:10 add route None new_route \n", + "1 2021-03-31 11:57:10 add service None new_service \n", + "2 2021-03-31 11:57:10 add route None another_new_route \n", + "3 2021-03-31 11:57:10 add route None another_new_route_2 \n", + "4 2021-03-31 11:57:11 add route None another_new_route_3 \n", "\n", " old_attributes new_attributes \\\n", "0 None {'route_short_name': 'N55', 'mode': 'bus', 'tr... \n", @@ -1370,8 +1370,8 @@ "execution_count": 32, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.511711Z", - "start_time": "2021-02-23T20:44:27.500921Z" + "end_time": "2021-03-31T10:57:11.975889Z", + "start_time": "2021-03-31T10:57:11.957111Z" } }, "outputs": [ @@ -1379,7 +1379,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,509 - Reindexed Service from new_service to more_appropriate_id\n" + "2021-03-31 11:57:11,971 - Reindexed Service from new_service to more_appropriate_id\n" ] } ], @@ -1392,8 +1392,8 @@ "execution_count": 33, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.532095Z", - "start_time": "2021-02-23T20:44:27.512956Z" + "end_time": "2021-03-31T10:57:12.000784Z", + "start_time": "2021-03-31T10:57:11.991194Z" } }, "outputs": [ @@ -1401,7 +1401,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,529 - Reindexed Route from new_route to more_appropriate_route_id\n" + "2021-03-31 11:57:11,997 - Reindexed Route from new_route to more_appropriate_route_id\n" ] } ], @@ -1414,8 +1414,8 @@ "execution_count": 34, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.566519Z", - "start_time": "2021-02-23T20:44:27.537419Z" + "end_time": "2021-03-31T10:57:12.038616Z", + "start_time": "2021-03-31T10:57:12.003847Z" } }, "outputs": [ @@ -1453,7 +1453,7 @@ " \n", " \n", " 0\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1464,7 +1464,7 @@ " \n", " \n", " 1\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " service\n", " None\n", @@ -1475,7 +1475,7 @@ " \n", " \n", " 2\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1486,7 +1486,7 @@ " \n", " \n", " 3\n", - " 2021-02-23 20:44:26\n", + " 2021-03-31 11:57:10\n", " add\n", " route\n", " None\n", @@ -1497,7 +1497,7 @@ " \n", " \n", " 4\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:11\n", " add\n", " route\n", " None\n", @@ -1512,11 +1512,11 @@ ], "text/plain": [ " timestamp change_event object_type old_id new_id \\\n", - "0 2021-02-23 20:44:26 add route None new_route \n", - "1 2021-02-23 20:44:26 add service None new_service \n", - "2 2021-02-23 20:44:26 add route None another_new_route \n", - "3 2021-02-23 20:44:26 add route None another_new_route_2 \n", - "4 2021-02-23 20:44:27 add route None another_new_route_3 \n", + "0 2021-03-31 11:57:10 add route None new_route \n", + "1 2021-03-31 11:57:10 add service None new_service \n", + "2 2021-03-31 11:57:10 add route None another_new_route \n", + "3 2021-03-31 11:57:10 add route None another_new_route_2 \n", + "4 2021-03-31 11:57:11 add route None another_new_route_3 \n", "\n", " old_attributes new_attributes \\\n", "0 None {'route_short_name': 'N55', 'mode': 'bus', 'tr... \n", @@ -1554,8 +1554,8 @@ "execution_count": 35, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.590333Z", - "start_time": "2021-02-23T20:44:27.579801Z" + "end_time": "2021-03-31T10:57:12.054863Z", + "start_time": "2021-03-31T10:57:12.040975Z" } }, "outputs": [ @@ -1563,7 +1563,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,588 - Removed Service with index `more_appropriate_id`, data={'id': 'more_appropriate_id', 'name': 'N55'} and Routes: {'new_service_new_route'}\n" + "2021-03-31 11:57:12,051 - Removed Service with index `more_appropriate_id`, data={'id': 'more_appropriate_id', 'name': 'N55'} and Routes: {'new_service_new_route'}\n" ] } ], @@ -1576,8 +1576,8 @@ "execution_count": 36, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.603400Z", - "start_time": "2021-02-23T20:44:27.592096Z" + "end_time": "2021-03-31T10:57:12.072069Z", + "start_time": "2021-03-31T10:57:12.058232Z" } }, "outputs": [ @@ -1585,7 +1585,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,600 - Removed Route with index `more_appropriate_route_id`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'more_appropriate_route_id', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']}. It was linked to Service `20274`.\n" + "2021-03-31 11:57:12,069 - Removed Route with index `more_appropriate_route_id`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'more_appropriate_route_id', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']}. It was linked to Service `20274`.\n" ] } ], @@ -1598,8 +1598,8 @@ "execution_count": 37, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.631988Z", - "start_time": "2021-02-23T20:44:27.605740Z" + "end_time": "2021-03-31T10:57:12.107846Z", + "start_time": "2021-03-31T10:57:12.077397Z" } }, "outputs": [ @@ -1607,9 +1607,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,614 - Removed Route with index `another_new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']}. It was linked to Service `20274`.\n", - "2021-02-23 20:44:27,620 - Removed Route with index `another_new_route_2`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_2', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']}. It was linked to Service `20274`.\n", - "2021-02-23 20:44:27,629 - Removed Route with index `another_new_route_3`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_3', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']}. It was linked to Service `20274`.\n" + "2021-03-31 11:57:12,091 - Removed Route with index `another_new_route`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']}. It was linked to Service `20274`.\n", + "2021-03-31 11:57:12,095 - Removed Route with index `another_new_route_2`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['some_trip_1'], 'trip_departure_time': ['16:23:00'], 'vehicle_id': ['some_bus_2']}, 'arrival_offsets': ['00:00:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_2', 'route': [], 'await_departure': [True, True], 'ordered_stops': ['490000235X.link:834', '490010689KB.link:981']}. It was linked to Service `20274`.\n", + "2021-03-31 11:57:12,104 - Removed Route with index `another_new_route_3`, data={'route_short_name': 'N55', 'mode': 'bus', 'trips': {'trip_id': ['fun_trip_1', 'fun_trip_2'], 'trip_departure_time': ['03:53:00', '16:23:00'], 'vehicle_id': ['fun_bus_1', 'fun_bus_2']}, 'arrival_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'departure_offsets': ['00:00:00', '00:02:00', '00:04:00', '00:06:00'], 'route_long_name': '', 'id': 'another_new_route_3', 'route': [], 'await_departure': [True, True, True, True], 'ordered_stops': ['490000235X.link:834', 'new_stop', 'other_new_stop', '490010689KB.link:981']}. It was linked to Service `20274`.\n" ] } ], @@ -1623,8 +1623,8 @@ "execution_count": 38, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.664104Z", - "start_time": "2021-02-23T20:44:27.633368Z" + "end_time": "2021-03-31T10:57:12.136602Z", + "start_time": "2021-03-31T10:57:12.112638Z" } }, "outputs": [ @@ -1662,7 +1662,7 @@ " \n", " \n", " 7\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " remove\n", " service\n", " more_appropriate_id\n", @@ -1673,7 +1673,7 @@ " \n", " \n", " 8\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " remove\n", " route\n", " more_appropriate_route_id\n", @@ -1684,7 +1684,7 @@ " \n", " \n", " 9\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " remove\n", " route\n", " another_new_route\n", @@ -1695,7 +1695,7 @@ " \n", " \n", " 10\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " remove\n", " route\n", " another_new_route_2\n", @@ -1706,7 +1706,7 @@ " \n", " \n", " 11\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " remove\n", " route\n", " another_new_route_3\n", @@ -1721,11 +1721,11 @@ ], "text/plain": [ " timestamp change_event object_type old_id \\\n", - "7 2021-02-23 20:44:27 remove service more_appropriate_id \n", - "8 2021-02-23 20:44:27 remove route more_appropriate_route_id \n", - "9 2021-02-23 20:44:27 remove route another_new_route \n", - "10 2021-02-23 20:44:27 remove route another_new_route_2 \n", - "11 2021-02-23 20:44:27 remove route another_new_route_3 \n", + "7 2021-03-31 11:57:12 remove service more_appropriate_id \n", + "8 2021-03-31 11:57:12 remove route more_appropriate_route_id \n", + "9 2021-03-31 11:57:12 remove route another_new_route \n", + "10 2021-03-31 11:57:12 remove route another_new_route_2 \n", + "11 2021-03-31 11:57:12 remove route another_new_route_3 \n", "\n", " new_id old_attributes new_attributes \\\n", "7 None {'id': 'more_appropriate_id', 'name': 'N55'} None \n", @@ -1763,8 +1763,8 @@ "execution_count": 39, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.677613Z", - "start_time": "2021-02-23T20:44:27.666358Z" + "end_time": "2021-03-31T10:57:12.163273Z", + "start_time": "2021-03-31T10:57:12.148333Z" } }, "outputs": [ @@ -1772,7 +1772,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,673 - Removed Stop with index `new_stop`, data={'id': 'new_stop', 'x': 529500.0, 'y': 181300.0, 'epsg': 'epsg:27700', 'name': 'New Stop', 'lat': 51.51578819710296, 'lon': -0.1350768098744082, 's2_id': 5221390696585158415, 'additional_attributes': set()}. Routes affected: []. Services affected: [].\n" + "2021-03-31 11:57:12,160 - Removed Stop with index `new_stop`, data={'id': 'new_stop', 'x': 529500.0, 'y': 181300.0, 'epsg': 'epsg:27700', 'name': 'New Stop', 'lon': -0.1350768098744082, 'lat': 51.51578819710296, 's2_id': 5221390696585158415, 'additional_attributes': set()}. Routes affected: []. Services affected: [].\n" ] } ], @@ -1792,8 +1792,8 @@ "execution_count": 40, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.692771Z", - "start_time": "2021-02-23T20:44:27.680352Z" + "end_time": "2021-03-31T10:57:12.184947Z", + "start_time": "2021-03-31T10:57:12.172103Z" } }, "outputs": [ @@ -1801,8 +1801,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,687 - Removed Stop with index `other_new_stop`, data={'id': 'other_new_stop', 'x': 529502.0, 'y': 181302.0, 'epsg': 'epsg:27700', 'name': 'Other New Stop', 'lat': 51.515805712413496, 'lon': -0.1350472687576662, 's2_id': 5221390696583632715, 'additional_attributes': set()}. Routes affected: []. Services affected: [].\n", - "2021-02-23 20:44:27,689 - Removed Stops with indecies `['other_new_stop']` which were not used by any Routes.\n" + "2021-03-31 11:57:12,180 - Removed Stop with index `other_new_stop`, data={'id': 'other_new_stop', 'x': 529502.0, 'y': 181302.0, 'epsg': 'epsg:27700', 'name': 'Other New Stop', 'lon': -0.1350472687576662, 'lat': 51.515805712413496, 's2_id': 5221390696583632715, 'additional_attributes': set()}. Routes affected: []. Services affected: [].\n", + "2021-03-31 11:57:12,181 - Removed Stops with indecies `['other_new_stop']` which were not used by any Routes.\n" ] } ], @@ -1825,8 +1825,8 @@ "execution_count": 41, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.703722Z", - "start_time": "2021-02-23T20:44:27.694787Z" + "end_time": "2021-03-31T10:57:12.202147Z", + "start_time": "2021-03-31T10:57:12.191872Z" } }, "outputs": [ @@ -1856,12 +1856,16 @@ " \n", " \n", " \n", - " 14073\n", - " 94\n", + " 18915\n", + " N5\n", " \n", " \n", - " 20274\n", - " N55\n", + " 14134\n", + " 98\n", + " \n", + " \n", + " 17732\n", + " N20\n", " \n", " \n", " 18853\n", @@ -1871,21 +1875,17 @@ " 15660\n", " 113\n", " \n", - " \n", - " 15234\n", - " 134\n", - " \n", " \n", "\n", "" ], "text/plain": [ " name\n", - "14073 94\n", - "20274 N55\n", + "18915 N5\n", + "14134 98\n", + "17732 N20\n", "18853 N8\n", - "15660 113\n", - "15234 134" + "15660 113" ] }, "execution_count": 41, @@ -1910,8 +1910,8 @@ "execution_count": 42, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.714071Z", - "start_time": "2021-02-23T20:44:27.705367Z" + "end_time": "2021-03-31T10:57:12.222707Z", + "start_time": "2021-03-31T10:57:12.208350Z" } }, "outputs": [ @@ -1941,12 +1941,16 @@ " \n", " \n", " \n", - " 14073\n", - " Service_94\n", + " 18915\n", + " Service_N5\n", + " \n", + " \n", + " 14134\n", + " Service_98\n", " \n", " \n", - " 20274\n", - " Service_N55\n", + " 17732\n", + " Service_N20\n", " \n", " \n", " 18853\n", @@ -1956,21 +1960,17 @@ " 15660\n", " Service_113\n", " \n", - " \n", - " 15234\n", - " Service_134\n", - " \n", " \n", "\n", "" ], "text/plain": [ " name\n", - "14073 Service_94\n", - "20274 Service_N55\n", + "18915 Service_N5\n", + "14134 Service_98\n", + "17732 Service_N20\n", "18853 Service_N8\n", - "15660 Service_113\n", - "15234 Service_134" + "15660 Service_113" ] }, "execution_count": 42, @@ -1995,8 +1995,8 @@ "execution_count": 43, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.722478Z", - "start_time": "2021-02-23T20:44:27.715619Z" + "end_time": "2021-03-31T10:57:12.262073Z", + "start_time": "2021-03-31T10:57:12.230257Z" } }, "outputs": [ @@ -2004,7 +2004,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,719 - Changed Service attributes for 9 services\n" + "2021-03-31 11:57:12,250 - Changed Service attributes for 9 services\n" ] } ], @@ -2017,8 +2017,8 @@ "execution_count": 44, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.739626Z", - "start_time": "2021-02-23T20:44:27.724322Z" + "end_time": "2021-03-31T10:57:12.290217Z", + "start_time": "2021-03-31T10:57:12.271060Z" } }, "outputs": [ @@ -2056,58 +2056,58 @@ " \n", " \n", " 18\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 15234\n", - " 15234\n", - " {'id': '15234', 'name': '134'}\n", - " {'id': '15234', 'name': 'Service_134'}\n", - " [(change, name, (134, Service_134))]\n", + " 15660\n", + " 15660\n", + " {'id': '15660', 'name': '113'}\n", + " {'id': '15660', 'name': 'Service_113'}\n", + " [(change, name, (113, Service_113))]\n", " \n", " \n", " 19\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 18915\n", - " 18915\n", - " {'id': '18915', 'name': 'N5'}\n", - " {'id': '18915', 'name': 'Service_N5'}\n", - " [(change, name, (N5, Service_N5))]\n", + " 12430\n", + " 12430\n", + " {'id': '12430', 'name': '205'}\n", + " {'id': '12430', 'name': 'Service_205'}\n", + " [(change, name, (205, Service_205))]\n", " \n", " \n", " 20\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 17732\n", - " 17732\n", - " {'id': '17732', 'name': 'N20'}\n", - " {'id': '17732', 'name': 'Service_N20'}\n", - " [(change, name, (N20, Service_N20))]\n", + " 14073\n", + " 14073\n", + " {'id': '14073', 'name': '94'}\n", + " {'id': '14073', 'name': 'Service_94'}\n", + " [(change, name, (94, Service_94))]\n", " \n", " \n", " 21\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 14134\n", - " 14134\n", - " {'id': '14134', 'name': '98'}\n", - " {'id': '14134', 'name': 'Service_98'}\n", - " [(change, name, (98, Service_98))]\n", + " 15234\n", + " 15234\n", + " {'id': '15234', 'name': '134'}\n", + " {'id': '15234', 'name': 'Service_134'}\n", + " [(change, name, (134, Service_134))]\n", " \n", " \n", " 22\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 12430\n", - " 12430\n", - " {'id': '12430', 'name': '205'}\n", - " {'id': '12430', 'name': 'Service_205'}\n", - " [(change, name, (205, Service_205))]\n", + " 20274\n", + " 20274\n", + " {'id': '20274', 'name': 'N55'}\n", + " {'id': '20274', 'name': 'Service_N55'}\n", + " [(change, name, (N55, Service_N55))]\n", " \n", " \n", "\n", @@ -2115,25 +2115,25 @@ ], "text/plain": [ " timestamp change_event object_type old_id new_id \\\n", - "18 2021-02-23 20:44:27 modify service 15234 15234 \n", - "19 2021-02-23 20:44:27 modify service 18915 18915 \n", - "20 2021-02-23 20:44:27 modify service 17732 17732 \n", - "21 2021-02-23 20:44:27 modify service 14134 14134 \n", - "22 2021-02-23 20:44:27 modify service 12430 12430 \n", + "18 2021-03-31 11:57:12 modify service 15660 15660 \n", + "19 2021-03-31 11:57:12 modify service 12430 12430 \n", + "20 2021-03-31 11:57:12 modify service 14073 14073 \n", + "21 2021-03-31 11:57:12 modify service 15234 15234 \n", + "22 2021-03-31 11:57:12 modify service 20274 20274 \n", "\n", " old_attributes new_attributes \\\n", - "18 {'id': '15234', 'name': '134'} {'id': '15234', 'name': 'Service_134'} \n", - "19 {'id': '18915', 'name': 'N5'} {'id': '18915', 'name': 'Service_N5'} \n", - "20 {'id': '17732', 'name': 'N20'} {'id': '17732', 'name': 'Service_N20'} \n", - "21 {'id': '14134', 'name': '98'} {'id': '14134', 'name': 'Service_98'} \n", - "22 {'id': '12430', 'name': '205'} {'id': '12430', 'name': 'Service_205'} \n", + "18 {'id': '15660', 'name': '113'} {'id': '15660', 'name': 'Service_113'} \n", + "19 {'id': '12430', 'name': '205'} {'id': '12430', 'name': 'Service_205'} \n", + "20 {'id': '14073', 'name': '94'} {'id': '14073', 'name': 'Service_94'} \n", + "21 {'id': '15234', 'name': '134'} {'id': '15234', 'name': 'Service_134'} \n", + "22 {'id': '20274', 'name': 'N55'} {'id': '20274', 'name': 'Service_N55'} \n", "\n", " diff \n", - "18 [(change, name, (134, Service_134))] \n", - "19 [(change, name, (N5, Service_N5))] \n", - "20 [(change, name, (N20, Service_N20))] \n", - "21 [(change, name, (98, Service_98))] \n", - "22 [(change, name, (205, Service_205))] " + "18 [(change, name, (113, Service_113))] \n", + "19 [(change, name, (205, Service_205))] \n", + "20 [(change, name, (94, Service_94))] \n", + "21 [(change, name, (134, Service_134))] \n", + "22 [(change, name, (N55, Service_N55))] " ] }, "execution_count": 44, @@ -2157,8 +2157,8 @@ "execution_count": 45, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.746994Z", - "start_time": "2021-02-23T20:44:27.741050Z" + "end_time": "2021-03-31T10:57:12.312423Z", + "start_time": "2021-03-31T10:57:12.302923Z" } }, "outputs": [ @@ -2166,7 +2166,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,743 - Changed Route attributes for 1 routes\n" + "2021-03-31 11:57:12,307 - Changed Route attributes for 1 routes\n" ] } ], @@ -2184,8 +2184,8 @@ "execution_count": 46, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.756087Z", - "start_time": "2021-02-23T20:44:27.748659Z" + "end_time": "2021-03-31T10:57:12.331313Z", + "start_time": "2021-03-31T10:57:12.320111Z" } }, "outputs": [ @@ -2193,7 +2193,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,751 - Changed Stop attributes for 1 stops\n" + "2021-03-31 11:57:12,323 - Changed Stop attributes for 1 stops\n" ] } ], @@ -2208,8 +2208,8 @@ "execution_count": 47, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.778274Z", - "start_time": "2021-02-23T20:44:27.759671Z" + "end_time": "2021-03-31T10:57:12.360958Z", + "start_time": "2021-03-31T10:57:12.339853Z" } }, "outputs": [ @@ -2247,40 +2247,40 @@ " \n", " \n", " 20\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 17732\n", - " 17732\n", - " {'id': '17732', 'name': 'N20'}\n", - " {'id': '17732', 'name': 'Service_N20'}\n", - " [(change, name, (N20, Service_N20))]\n", + " 14073\n", + " 14073\n", + " {'id': '14073', 'name': '94'}\n", + " {'id': '14073', 'name': 'Service_94'}\n", + " [(change, name, (94, Service_94))]\n", " \n", " \n", " 21\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 14134\n", - " 14134\n", - " {'id': '14134', 'name': '98'}\n", - " {'id': '14134', 'name': 'Service_98'}\n", - " [(change, name, (98, Service_98))]\n", + " 15234\n", + " 15234\n", + " {'id': '15234', 'name': '134'}\n", + " {'id': '15234', 'name': 'Service_134'}\n", + " [(change, name, (134, Service_134))]\n", " \n", " \n", " 22\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " service\n", - " 12430\n", - " 12430\n", - " {'id': '12430', 'name': '205'}\n", - " {'id': '12430', 'name': 'Service_205'}\n", - " [(change, name, (205, Service_205))]\n", + " 20274\n", + " 20274\n", + " {'id': '20274', 'name': 'N55'}\n", + " {'id': '20274', 'name': 'Service_N55'}\n", + " [(change, name, (N55, Service_N55))]\n", " \n", " \n", " 23\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " route\n", " VJ375a660d47a2aa570aa20a8568012da8497ffecf\n", @@ -2291,13 +2291,13 @@ " \n", " \n", " 24\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " stop\n", " 490000235YB.link:574\n", " 490000235YB.link:574\n", - " {'services': ['18853', '20274', '14134'], 'rou...\n", - " {'services': ['18853', '20274', '14134'], 'rou...\n", + " {'services': ['18853', '14134', '20274'], 'rou...\n", + " {'services': ['18853', '14134', '20274'], 'rou...\n", " [(add, , [('new_attribute', 'hello!')])]\n", " \n", " \n", @@ -2306,44 +2306,44 @@ ], "text/plain": [ " timestamp change_event object_type \\\n", - "20 2021-02-23 20:44:27 modify service \n", - "21 2021-02-23 20:44:27 modify service \n", - "22 2021-02-23 20:44:27 modify service \n", - "23 2021-02-23 20:44:27 modify route \n", - "24 2021-02-23 20:44:27 modify stop \n", + "20 2021-03-31 11:57:12 modify service \n", + "21 2021-03-31 11:57:12 modify service \n", + "22 2021-03-31 11:57:12 modify service \n", + "23 2021-03-31 11:57:12 modify route \n", + "24 2021-03-31 11:57:12 modify stop \n", "\n", " old_id \\\n", - "20 17732 \n", - "21 14134 \n", - "22 12430 \n", + "20 14073 \n", + "21 15234 \n", + "22 20274 \n", "23 VJ375a660d47a2aa570aa20a8568012da8497ffecf \n", "24 490000235YB.link:574 \n", "\n", " new_id \\\n", - "20 17732 \n", - "21 14134 \n", - "22 12430 \n", + "20 14073 \n", + "21 15234 \n", + "22 20274 \n", "23 VJ375a660d47a2aa570aa20a8568012da8497ffecf \n", "24 490000235YB.link:574 \n", "\n", " old_attributes \\\n", - "20 {'id': '17732', 'name': 'N20'} \n", - "21 {'id': '14134', 'name': '98'} \n", - "22 {'id': '12430', 'name': '205'} \n", + "20 {'id': '14073', 'name': '94'} \n", + "21 {'id': '15234', 'name': '134'} \n", + "22 {'id': '20274', 'name': 'N55'} \n", "23 {'route_short_name': 'N55', 'mode': 'bus', 'tr... \n", - "24 {'services': ['18853', '20274', '14134'], 'rou... \n", + "24 {'services': ['18853', '14134', '20274'], 'rou... \n", "\n", " new_attributes \\\n", - "20 {'id': '17732', 'name': 'Service_N20'} \n", - "21 {'id': '14134', 'name': 'Service_98'} \n", - "22 {'id': '12430', 'name': 'Service_205'} \n", + "20 {'id': '14073', 'name': 'Service_94'} \n", + "21 {'id': '15234', 'name': 'Service_134'} \n", + "22 {'id': '20274', 'name': 'Service_N55'} \n", "23 {'route_short_name': 'N55', 'mode': 'piggyback... \n", - "24 {'services': ['18853', '20274', '14134'], 'rou... \n", + "24 {'services': ['18853', '14134', '20274'], 'rou... \n", "\n", " diff \n", - "20 [(change, name, (N20, Service_N20))] \n", - "21 [(change, name, (98, Service_98))] \n", - "22 [(change, name, (205, Service_205))] \n", + "20 [(change, name, (94, Service_94))] \n", + "21 [(change, name, (134, Service_134))] \n", + "22 [(change, name, (N55, Service_N55))] \n", "23 [(change, mode, (bus, piggyback)), (add, , [('... \n", "24 [(add, , [('new_attribute', 'hello!')])] " ] @@ -2369,8 +2369,8 @@ "execution_count": 48, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.817042Z", - "start_time": "2021-02-23T20:44:27.780887Z" + "end_time": "2021-03-31T10:57:12.470325Z", + "start_time": "2021-03-31T10:57:12.376367Z" } }, "outputs": [], @@ -2383,8 +2383,8 @@ "execution_count": 49, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.829567Z", - "start_time": "2021-02-23T20:44:27.818482Z" + "end_time": "2021-03-31T10:57:12.493796Z", + "start_time": "2021-03-31T10:57:12.482089Z" } }, "outputs": [ @@ -2409,8 +2409,8 @@ " \n", " \n", " \n", - " route_id\n", " service_id\n", + " route_id\n", " trip_id\n", " trip_departure_time\n", " vehicle_id\n", @@ -2419,69 +2419,69 @@ " \n", " \n", " 0\n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da\n", - " 18915\n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da_02:...\n", - " 2021-01-01 02:30:50\n", - " veh_2240_bus\n", + " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " VJ8375f7a9e68d59d39ae5113ce44ef920c56adb79_20:...\n", + " 2021-01-01 20:50:08\n", + " veh_443_bus\n", " \n", " \n", " 1\n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da\n", - " 18915\n", - " VJ7a1c3f9bb726eccef85048922c7c33efdbffb4c2_02:...\n", - " 2021-01-01 02:56:50\n", - " veh_2239_bus\n", + " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " VJf8c1b44c2d6396d5223bdc5d1ec70c9a17daafc1_21:...\n", + " 2021-01-01 21:32:08\n", + " veh_452_bus\n", " \n", " \n", " 2\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", - " VJee5949960e8d68cc29695963d4ac264533bcd16d_17:...\n", - " 2021-01-01 17:45:50\n", - " veh_483_bus\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " VJ5613941368b37ea4be1853f94b1a993f6a56dad7_22:...\n", + " 2021-01-01 21:10:08\n", + " veh_439_bus\n", " \n", " \n", " 3\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", - " VJ24f3641389386064f42016207679f6852563e23a_17:...\n", - " 2021-01-01 17:36:50\n", - " veh_486_bus\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " VJ53d627cc50ee4d371871f32182de9ba5247ec443_06:...\n", + " 2021-01-01 06:35:08\n", + " veh_437_bus\n", " \n", " \n", " 4\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", - " VJ7756ecc177b1698ee28e2a02d506a50f7f6f077c_17:...\n", - " 2021-01-01 17:18:50\n", - " veh_487_bus\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " VJc81124c0faec85bb098d18f9fb8005b15e83f999_05:...\n", + " 2021-01-01 06:46:08\n", + " veh_442_bus\n", " \n", " \n", "\n", "" ], "text/plain": [ - " route_id service_id \\\n", - "0 VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da 18915 \n", - "1 VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da 18915 \n", - "2 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 \n", - "3 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 \n", - "4 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 \n", + " service_id route_id \\\n", + "0 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 \n", + "1 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 \n", + "2 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 \n", + "3 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 \n", + "4 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 \n", "\n", " trip_id trip_departure_time \\\n", - "0 VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da_02:... 2021-01-01 02:30:50 \n", - "1 VJ7a1c3f9bb726eccef85048922c7c33efdbffb4c2_02:... 2021-01-01 02:56:50 \n", - "2 VJee5949960e8d68cc29695963d4ac264533bcd16d_17:... 2021-01-01 17:45:50 \n", - "3 VJ24f3641389386064f42016207679f6852563e23a_17:... 2021-01-01 17:36:50 \n", - "4 VJ7756ecc177b1698ee28e2a02d506a50f7f6f077c_17:... 2021-01-01 17:18:50 \n", + "0 VJ8375f7a9e68d59d39ae5113ce44ef920c56adb79_20:... 2021-01-01 20:50:08 \n", + "1 VJf8c1b44c2d6396d5223bdc5d1ec70c9a17daafc1_21:... 2021-01-01 21:32:08 \n", + "2 VJ5613941368b37ea4be1853f94b1a993f6a56dad7_22:... 2021-01-01 21:10:08 \n", + "3 VJ53d627cc50ee4d371871f32182de9ba5247ec443_06:... 2021-01-01 06:35:08 \n", + "4 VJc81124c0faec85bb098d18f9fb8005b15e83f999_05:... 2021-01-01 06:46:08 \n", "\n", - " vehicle_id \n", - "0 veh_2240_bus \n", - "1 veh_2239_bus \n", - "2 veh_483_bus \n", - "3 veh_486_bus \n", - "4 veh_487_bus " + " vehicle_id \n", + "0 veh_443_bus \n", + "1 veh_452_bus \n", + "2 veh_439_bus \n", + "3 veh_437_bus \n", + "4 veh_442_bus " ] }, "execution_count": 49, @@ -2505,8 +2505,8 @@ "execution_count": 50, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.846117Z", - "start_time": "2021-02-23T20:44:27.832010Z" + "end_time": "2021-03-31T10:57:12.522834Z", + "start_time": "2021-03-31T10:57:12.499756Z" } }, "outputs": [ @@ -2531,8 +2531,8 @@ " \n", " \n", " \n", - " route_id\n", " service_id\n", + " route_id\n", " trip_id\n", " trip_departure_time\n", " vehicle_id\n", @@ -2541,62 +2541,62 @@ " \n", " \n", " 0\n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da\n", - " 18915\n", + " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", " trip_0\n", - " 2021-01-01 02:30:50\n", - " veh_2240_bus\n", + " 2021-01-01 20:50:08\n", + " veh_443_bus\n", " \n", " \n", " 1\n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da\n", - " 18915\n", + " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", " trip_1\n", - " 2021-01-01 02:56:50\n", - " veh_2239_bus\n", + " 2021-01-01 21:32:08\n", + " veh_452_bus\n", " \n", " \n", " 2\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", " trip_2\n", - " 2021-01-01 17:45:50\n", - " veh_483_bus\n", + " 2021-01-01 21:10:08\n", + " veh_439_bus\n", " \n", " \n", " 3\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", " trip_3\n", - " 2021-01-01 17:36:50\n", - " veh_486_bus\n", + " 2021-01-01 06:35:08\n", + " veh_437_bus\n", " \n", " \n", " 4\n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", " 12430\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", " trip_4\n", - " 2021-01-01 17:18:50\n", - " veh_487_bus\n", + " 2021-01-01 06:46:08\n", + " veh_442_bus\n", " \n", " \n", "\n", "" ], "text/plain": [ - " route_id service_id trip_id \\\n", - "0 VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da 18915 trip_0 \n", - "1 VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da 18915 trip_1 \n", - "2 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 trip_2 \n", - "3 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 trip_3 \n", - "4 VJ8f9aea7491080b0137d3092706f53dc11f7dba45 12430 trip_4 \n", + " service_id route_id trip_id \\\n", + "0 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 trip_0 \n", + "1 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 trip_1 \n", + "2 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 trip_2 \n", + "3 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 trip_3 \n", + "4 12430 VJeae6e634f8479e0b6712780d5728f0afca964e64 trip_4 \n", "\n", - " trip_departure_time vehicle_id \n", - "0 2021-01-01 02:30:50 veh_2240_bus \n", - "1 2021-01-01 02:56:50 veh_2239_bus \n", - "2 2021-01-01 17:45:50 veh_483_bus \n", - "3 2021-01-01 17:36:50 veh_486_bus \n", - "4 2021-01-01 17:18:50 veh_487_bus " + " trip_departure_time vehicle_id \n", + "0 2021-01-01 20:50:08 veh_443_bus \n", + "1 2021-01-01 21:32:08 veh_452_bus \n", + "2 2021-01-01 21:10:08 veh_439_bus \n", + "3 2021-01-01 06:35:08 veh_437_bus \n", + "4 2021-01-01 06:46:08 veh_442_bus " ] }, "execution_count": 50, @@ -2623,8 +2623,8 @@ "execution_count": 51, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.980545Z", - "start_time": "2021-02-23T20:44:27.848298Z" + "end_time": "2021-03-31T10:57:12.656280Z", + "start_time": "2021-03-31T10:57:12.527525Z" } }, "outputs": [ @@ -2632,7 +2632,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,967 - Changed Route attributes for 68 routes\n" + "2021-03-31 11:57:12,642 - Changed Route attributes for 68 routes\n" ] }, { @@ -2661,48 +2661,48 @@ " \n", " \n", " \n", - " VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da\n", - " [trip_0, trip_1]\n", + " VJeae6e634f8479e0b6712780d5728f0afca964e64\n", + " [trip_0, trip_1, trip_2, trip_3, trip_4, trip_...\n", " \n", " \n", - " VJ8f9aea7491080b0137d3092706f53dc11f7dba45\n", - " [trip_2, trip_3, trip_4, trip_5, trip_6, trip_7]\n", + " VJfc4917783c2ca3227789fa7c532c9adf47702095\n", + " [trip_22, trip_23, trip_24, trip_25, trip_26, ...\n", " \n", " \n", - " VJdb0c128567fcbcc063d554ae1c95851cee41b909\n", - " [trip_8, trip_9]\n", + " VJ24fe211d801738b556a39f815256d7f6bc544ec5\n", + " [trip_31, trip_32, trip_33, trip_34, trip_35, ...\n", " \n", " \n", - " VJ1a8cc306354fdc322d739ae644eb73444341d08d\n", - " [trip_10, trip_11, trip_12, trip_13, trip_14, ...\n", + " VJ256e98df611ff48afe737ddc81cbcde82e4e81c8\n", + " [trip_65]\n", " \n", " \n", " VJaa5ee0daec7529d7668c81fe7fac0c4ff545daea\n", - " [trip_26, trip_27, trip_28, trip_29, trip_30, ...\n", + " [trip_66, trip_67, trip_68, trip_69, trip_70, ...\n", " \n", " \n", " ...\n", " ...\n", " \n", " \n", - " VJ812fad65e7fa418645b57b446f00cba573f2cdaf\n", - " [trip_1537, trip_1538, trip_1539, trip_1540]\n", + " VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa\n", + " [trip_1514, trip_1515, trip_1516, trip_1517, t...\n", " \n", " \n", - " VJdf3936da1a51eb33db594ef99738802c14b19995\n", - " [trip_1541]\n", + " VJbf9d4fdb976223e6a026c0c669ed290418abefee\n", + " [trip_1526, trip_1527, trip_1528, trip_1529, t...\n", " \n", " \n", - " VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa\n", - " [trip_1542, trip_1543, trip_1544, trip_1545, t...\n", + " VJd9dbeefeca6d74ef2594a17514ebc08ee2d503b2\n", + " [trip_1532, trip_1533, trip_1534, trip_1535, t...\n", " \n", " \n", " VJb08f8a2de01a4ef99d3b7fefd9022117ac307531\n", - " [trip_1554, trip_1555, trip_1556, trip_1557]\n", + " [trip_1547, trip_1548, trip_1549, trip_1550]\n", " \n", " \n", - " VJ4e311a625836374adf4cfaa841224840dbeb7619\n", - " [trip_1558, trip_1559, trip_1560, trip_1561]\n", + " VJ85c23573d670bab5485618b0c5fddff3314efc89\n", + " [trip_1551, trip_1552, trip_1553, trip_1554, t...\n", " \n", " \n", "\n", @@ -2711,17 +2711,17 @@ ], "text/plain": [ " trips::trip_id\n", - "VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da [trip_0, trip_1]\n", - "VJ8f9aea7491080b0137d3092706f53dc11f7dba45 [trip_2, trip_3, trip_4, trip_5, trip_6, trip_7]\n", - "VJdb0c128567fcbcc063d554ae1c95851cee41b909 [trip_8, trip_9]\n", - "VJ1a8cc306354fdc322d739ae644eb73444341d08d [trip_10, trip_11, trip_12, trip_13, trip_14, ...\n", - "VJaa5ee0daec7529d7668c81fe7fac0c4ff545daea [trip_26, trip_27, trip_28, trip_29, trip_30, ...\n", + "VJeae6e634f8479e0b6712780d5728f0afca964e64 [trip_0, trip_1, trip_2, trip_3, trip_4, trip_...\n", + "VJfc4917783c2ca3227789fa7c532c9adf47702095 [trip_22, trip_23, trip_24, trip_25, trip_26, ...\n", + "VJ24fe211d801738b556a39f815256d7f6bc544ec5 [trip_31, trip_32, trip_33, trip_34, trip_35, ...\n", + "VJ256e98df611ff48afe737ddc81cbcde82e4e81c8 [trip_65]\n", + "VJaa5ee0daec7529d7668c81fe7fac0c4ff545daea [trip_66, trip_67, trip_68, trip_69, trip_70, ...\n", "... ...\n", - "VJ812fad65e7fa418645b57b446f00cba573f2cdaf [trip_1537, trip_1538, trip_1539, trip_1540]\n", - "VJdf3936da1a51eb33db594ef99738802c14b19995 [trip_1541]\n", - "VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa [trip_1542, trip_1543, trip_1544, trip_1545, t...\n", - "VJb08f8a2de01a4ef99d3b7fefd9022117ac307531 [trip_1554, trip_1555, trip_1556, trip_1557]\n", - "VJ4e311a625836374adf4cfaa841224840dbeb7619 [trip_1558, trip_1559, trip_1560, trip_1561]\n", + "VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa [trip_1514, trip_1515, trip_1516, trip_1517, t...\n", + "VJbf9d4fdb976223e6a026c0c669ed290418abefee [trip_1526, trip_1527, trip_1528, trip_1529, t...\n", + "VJd9dbeefeca6d74ef2594a17514ebc08ee2d503b2 [trip_1532, trip_1533, trip_1534, trip_1535, t...\n", + "VJb08f8a2de01a4ef99d3b7fefd9022117ac307531 [trip_1547, trip_1548, trip_1549, trip_1550]\n", + "VJ85c23573d670bab5485618b0c5fddff3314efc89 [trip_1551, trip_1552, trip_1553, trip_1554, t...\n", "\n", "[68 rows x 1 columns]" ] @@ -2750,8 +2750,8 @@ "execution_count": 52, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:27.998207Z", - "start_time": "2021-02-23T20:44:27.981925Z" + "end_time": "2021-03-31T10:57:12.688752Z", + "start_time": "2021-03-31T10:57:12.663396Z" } }, "outputs": [ @@ -2759,7 +2759,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:27,995 - Changed Stop attributes for 45 stops\n" + "2021-03-31 11:57:12,686 - Changed Stop attributes for 45 stops\n" ] } ], @@ -2777,8 +2777,8 @@ "execution_count": 53, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.015279Z", - "start_time": "2021-02-23T20:44:27.999607Z" + "end_time": "2021-03-31T10:57:12.709067Z", + "start_time": "2021-03-31T10:57:12.692789Z" } }, "outputs": [ @@ -2816,24 +2816,24 @@ " \n", " \n", " 136\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " stop\n", - " 490000173RC.link:3352\n", - " 490000173RC.link:3352\n", - " {'services': ['14073'], 'routes': ['VJd9dbeefe...\n", - " {'services': ['14073'], 'routes': ['VJd9dbeefe...\n", + " 490000091G.link:1242\n", + " 490000091G.link:1242\n", + " {'services': ['12430'], 'routes': ['VJ15419796...\n", + " {'services': ['12430'], 'routes': ['VJ15419796...\n", " [(add, , [('geometry', <shapely.geometry.point...\n", " \n", " \n", " 137\n", - " 2021-02-23 20:44:27\n", + " 2021-03-31 11:57:12\n", " modify\n", " stop\n", - " 490000173RG.link:2614\n", - " 490000173RG.link:2614\n", - " {'services': ['14073'], 'routes': ['VJ6cf76a4c...\n", - " {'services': ['14073'], 'routes': ['VJ6cf76a4c...\n", + " 490010531W.link:1867\n", + " 490010531W.link:1867\n", + " {'services': ['14073'], 'routes': ['VJdbc28007...\n", + " {'services': ['14073'], 'routes': ['VJdbc28007...\n", " [(add, , [('geometry', <shapely.geometry.point...\n", " \n", " \n", @@ -2841,17 +2841,17 @@ "" ], "text/plain": [ - " timestamp change_event object_type old_id \\\n", - "136 2021-02-23 20:44:27 modify stop 490000173RC.link:3352 \n", - "137 2021-02-23 20:44:27 modify stop 490000173RG.link:2614 \n", + " timestamp change_event object_type old_id \\\n", + "136 2021-03-31 11:57:12 modify stop 490000091G.link:1242 \n", + "137 2021-03-31 11:57:12 modify stop 490010531W.link:1867 \n", "\n", - " new_id old_attributes \\\n", - "136 490000173RC.link:3352 {'services': ['14073'], 'routes': ['VJd9dbeefe... \n", - "137 490000173RG.link:2614 {'services': ['14073'], 'routes': ['VJ6cf76a4c... \n", + " new_id old_attributes \\\n", + "136 490000091G.link:1242 {'services': ['12430'], 'routes': ['VJ15419796... \n", + "137 490010531W.link:1867 {'services': ['14073'], 'routes': ['VJdbc28007... \n", "\n", " new_attributes \\\n", - "136 {'services': ['14073'], 'routes': ['VJd9dbeefe... \n", - "137 {'services': ['14073'], 'routes': ['VJ6cf76a4c... \n", + "136 {'services': ['12430'], 'routes': ['VJ15419796... \n", + "137 {'services': ['14073'], 'routes': ['VJdbc28007... \n", "\n", " diff \n", "136 [(add, , [('geometry', POINT (529166.7349732723 181256.3367228433)\n", " \n", " \n", - " 490000235V.link:3140\n", - " Tottenham Court Road Station (Stop V)\n", - " 529716.723832\n", - " 181371.384818\n", - " POINT (529716.7238324936 181371.3848181052)\n", + " 490000235P.link:15\n", + " Tottenham Court Road Station New Oxford Stree...\n", + " 529967.770031\n", + " 181420.307095\n", + " POINT (529967.770031479 181420.3070953883)\n", " \n", " \n", "\n", @@ -2950,21 +2950,21 @@ "490000235YB.link:574 Oxford Street Soho Street (Stop YB) \n", "490014214HE.link:3154 Wardour Street (Stop OM) \n", "490010689KB.link:981 Great Titchfield Street Oxford Circus Station... \n", - "490000235V.link:3140 Tottenham Court Road Station (Stop V) \n", + "490000235P.link:15 Tottenham Court Road Station New Oxford Stree... \n", "\n", " x y \\\n", "490000235X.link:834 529981.795880 181412.097576 \n", "490000235YB.link:574 529570.781323 181336.281593 \n", "490014214HE.link:3154 529477.750156 181314.437043 \n", "490010689KB.link:981 529166.734973 181256.336723 \n", - "490000235V.link:3140 529716.723832 181371.384818 \n", + "490000235P.link:15 529967.770031 181420.307095 \n", "\n", " geometry \n", "490000235X.link:834 POINT (529981.7958802709 181412.0975758662) \n", "490000235YB.link:574 POINT (529570.7813227688 181336.2815925331) \n", "490014214HE.link:3154 POINT (529477.7501560802 181314.4370430721) \n", "490010689KB.link:981 POINT (529166.7349732723 181256.3367228433) \n", - "490000235V.link:3140 POINT (529716.7238324936 181371.3848181052) " + "490000235P.link:15 POINT (529967.770031479 181420.3070953883) " ] }, "execution_count": 54, @@ -2981,15 +2981,15 @@ "execution_count": 55, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.323051Z", - "start_time": "2021-02-23T20:44:28.045760Z" + "end_time": "2021-03-31T10:57:13.107522Z", + "start_time": "2021-03-31T10:57:12.746850Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 55, @@ -2998,7 +2998,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3019,8 +3019,8 @@ "execution_count": 56, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.330371Z", - "start_time": "2021-02-23T20:44:28.325353Z" + "end_time": "2021-03-31T10:57:13.124391Z", + "start_time": "2021-03-31T10:57:13.115846Z" } }, "outputs": [ @@ -3032,9 +3032,9 @@ " 'y': 181336.2815925331,\n", " 'epsg': 'epsg:27700',\n", " 'name': 'Oxford Street Soho Street (Stop YB)',\n", - " 'lat': 51.51609803324078,\n", - " 'lon': -0.13404398709291862,\n", - " 's2_id': 5221390696959560815,\n", + " 'lat': -0.13404398709291862,\n", + " 'lon': 51.51609803324078,\n", + " 's2_id': 2507584474601580133,\n", " 'additional_attributes': {'geometry',\n", " 'isBlocking',\n", " 'linkRefId',\n", @@ -3042,7 +3042,7 @@ " 'linkRefId': '574',\n", " 'isBlocking': 'false',\n", " 'new_attribute': 'hello!',\n", - " 'geometry': }" + " 'geometry': }" ] }, "execution_count": 56, @@ -3066,8 +3066,8 @@ "execution_count": 57, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.368272Z", - "start_time": "2021-02-23T20:44:28.331959Z" + "end_time": "2021-03-31T10:57:13.189264Z", + "start_time": "2021-03-31T10:57:13.130022Z" } }, "outputs": [ @@ -3092,8 +3092,8 @@ "execution_count": 58, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.426884Z", - "start_time": "2021-02-23T20:44:28.375125Z" + "end_time": "2021-03-31T10:57:13.250302Z", + "start_time": "2021-03-31T10:57:13.194515Z" } }, "outputs": [ @@ -3101,7 +3101,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:28,423 - Changed Route attributes for 68 routes\n" + "2021-03-31 11:57:13,246 - Changed Route attributes for 68 routes\n" ] } ], @@ -3121,8 +3121,8 @@ "execution_count": 59, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.467722Z", - "start_time": "2021-02-23T20:44:28.428244Z" + "end_time": "2021-03-31T10:57:13.296863Z", + "start_time": "2021-03-31T10:57:13.256360Z" } }, "outputs": [ @@ -3156,8 +3156,8 @@ "execution_count": 60, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.483522Z", - "start_time": "2021-02-23T20:44:28.471064Z" + "end_time": "2021-03-31T10:57:13.317904Z", + "start_time": "2021-03-31T10:57:13.305673Z" } }, "outputs": [ @@ -3188,14 +3188,19 @@ " \n", " \n", " \n", - " 14073\n", - " Service_94\n", - " Brand_new_nameService_94\n", + " 18915\n", + " Service_N5\n", + " Brand_new_nameService_N5\n", + " \n", + " \n", + " 14134\n", + " Service_98\n", + " Brand_new_nameService_98\n", " \n", " \n", - " 20274\n", - " Service_N55\n", - " Brand_new_nameService_N55\n", + " 17732\n", + " Service_N20\n", + " Brand_new_nameService_N20\n", " \n", " \n", " 18853\n", @@ -3207,22 +3212,17 @@ " Service_113\n", " Brand_new_nameService_113\n", " \n", - " \n", - " 15234\n", - " Service_134\n", - " Brand_new_nameService_134\n", - " \n", " \n", "\n", "" ], "text/plain": [ " name new_name\n", - "14073 Service_94 Brand_new_nameService_94\n", - "20274 Service_N55 Brand_new_nameService_N55\n", + "18915 Service_N5 Brand_new_nameService_N5\n", + "14134 Service_98 Brand_new_nameService_98\n", + "17732 Service_N20 Brand_new_nameService_N20\n", "18853 Service_N8 Brand_new_nameService_N8\n", - "15660 Service_113 Brand_new_nameService_113\n", - "15234 Service_134 Brand_new_nameService_134" + "15660 Service_113 Brand_new_nameService_113" ] }, "execution_count": 60, @@ -3240,23 +3240,23 @@ "execution_count": 61, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.503178Z", - "start_time": "2021-02-23T20:44:28.485027Z" + "end_time": "2021-03-31T10:57:13.333043Z", + "start_time": "2021-03-31T10:57:13.324431Z" } }, "outputs": [ { "data": { "text/plain": [ - "{'Service_94': 'Brand_new_nameService_94',\n", - " 'Service_N55': 'Brand_new_nameService_N55',\n", + "{'Service_N5': 'Brand_new_nameService_N5',\n", + " 'Service_98': 'Brand_new_nameService_98',\n", + " 'Service_N20': 'Brand_new_nameService_N20',\n", " 'Service_N8': 'Brand_new_nameService_N8',\n", " 'Service_113': 'Brand_new_nameService_113',\n", + " 'Service_205': 'Brand_new_nameService_205',\n", + " 'Service_94': 'Brand_new_nameService_94',\n", " 'Service_134': 'Brand_new_nameService_134',\n", - " 'Service_N5': 'Brand_new_nameService_N5',\n", - " 'Service_N20': 'Brand_new_nameService_N20',\n", - " 'Service_98': 'Brand_new_nameService_98',\n", - " 'Service_205': 'Brand_new_nameService_205'}" + " 'Service_N55': 'Brand_new_nameService_N55'}" ] }, "execution_count": 61, @@ -3281,8 +3281,8 @@ "execution_count": 62, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.522673Z", - "start_time": "2021-02-23T20:44:28.508036Z" + "end_time": "2021-03-31T10:57:13.350952Z", + "start_time": "2021-03-31T10:57:13.340333Z" } }, "outputs": [ @@ -3290,7 +3290,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-02-23 20:44:28,517 - Changed Service attributes for 9 services\n" + "2021-03-31 11:57:13,348 - Changed Service attributes for 9 services\n" ] } ], @@ -3303,8 +3303,8 @@ "execution_count": 63, "metadata": { "ExecuteTime": { - "end_time": "2021-02-23T20:44:28.545428Z", - "start_time": "2021-02-23T20:44:28.525533Z" + "end_time": "2021-03-31T10:57:13.379673Z", + "start_time": "2021-03-31T10:57:13.355553Z" } }, "outputs": [ @@ -3342,58 +3342,58 @@ " \n", " \n", " 210\n", - " 2021-02-23 20:44:28\n", + " 2021-03-31 11:57:13\n", " modify\n", " service\n", - " 15234\n", - " 15234\n", - " {'id': '15234', 'name': 'Service_134'}\n", - " {'id': '15234', 'name': 'Brand_new_nameService...\n", - " [(change, name, (Service_134, Brand_new_nameSe...\n", + " 15660\n", + " 15660\n", + " {'id': '15660', 'name': 'Service_113'}\n", + " {'id': '15660', 'name': 'Brand_new_nameService...\n", + " [(change, name, (Service_113, Brand_new_nameSe...\n", " \n", " \n", " 211\n", - " 2021-02-23 20:44:28\n", + " 2021-03-31 11:57:13\n", " modify\n", " service\n", - " 18915\n", - " 18915\n", - " {'id': '18915', 'name': 'Service_N5'}\n", - " {'id': '18915', 'name': 'Brand_new_nameService...\n", - " [(change, name, (Service_N5, Brand_new_nameSer...\n", + " 12430\n", + " 12430\n", + " {'id': '12430', 'name': 'Service_205'}\n", + " {'id': '12430', 'name': 'Brand_new_nameService...\n", + " [(change, name, (Service_205, Brand_new_nameSe...\n", " \n", " \n", " 212\n", - " 2021-02-23 20:44:28\n", + " 2021-03-31 11:57:13\n", " modify\n", " service\n", - " 17732\n", - " 17732\n", - " {'id': '17732', 'name': 'Service_N20'}\n", - " {'id': '17732', 'name': 'Brand_new_nameService...\n", - " [(change, name, (Service_N20, Brand_new_nameSe...\n", + " 14073\n", + " 14073\n", + " {'id': '14073', 'name': 'Service_94'}\n", + " {'id': '14073', 'name': 'Brand_new_nameService...\n", + " [(change, name, (Service_94, Brand_new_nameSer...\n", " \n", " \n", " 213\n", - " 2021-02-23 20:44:28\n", + " 2021-03-31 11:57:13\n", " modify\n", " service\n", - " 14134\n", - " 14134\n", - " {'id': '14134', 'name': 'Service_98'}\n", - " {'id': '14134', 'name': 'Brand_new_nameService...\n", - " [(change, name, (Service_98, Brand_new_nameSer...\n", + " 15234\n", + " 15234\n", + " {'id': '15234', 'name': 'Service_134'}\n", + " {'id': '15234', 'name': 'Brand_new_nameService...\n", + " [(change, name, (Service_134, Brand_new_nameSe...\n", " \n", " \n", " 214\n", - " 2021-02-23 20:44:28\n", + " 2021-03-31 11:57:13\n", " modify\n", " service\n", - " 12430\n", - " 12430\n", - " {'id': '12430', 'name': 'Service_205'}\n", - " {'id': '12430', 'name': 'Brand_new_nameService...\n", - " [(change, name, (Service_205, Brand_new_nameSe...\n", + " 20274\n", + " 20274\n", + " {'id': '20274', 'name': 'Service_N55'}\n", + " {'id': '20274', 'name': 'Brand_new_nameService...\n", + " [(change, name, (Service_N55, Brand_new_nameSe...\n", " \n", " \n", "\n", @@ -3401,32 +3401,32 @@ ], "text/plain": [ " timestamp change_event object_type old_id new_id \\\n", - "210 2021-02-23 20:44:28 modify service 15234 15234 \n", - "211 2021-02-23 20:44:28 modify service 18915 18915 \n", - "212 2021-02-23 20:44:28 modify service 17732 17732 \n", - "213 2021-02-23 20:44:28 modify service 14134 14134 \n", - "214 2021-02-23 20:44:28 modify service 12430 12430 \n", + "210 2021-03-31 11:57:13 modify service 15660 15660 \n", + "211 2021-03-31 11:57:13 modify service 12430 12430 \n", + "212 2021-03-31 11:57:13 modify service 14073 14073 \n", + "213 2021-03-31 11:57:13 modify service 15234 15234 \n", + "214 2021-03-31 11:57:13 modify service 20274 20274 \n", "\n", " old_attributes \\\n", - "210 {'id': '15234', 'name': 'Service_134'} \n", - "211 {'id': '18915', 'name': 'Service_N5'} \n", - "212 {'id': '17732', 'name': 'Service_N20'} \n", - "213 {'id': '14134', 'name': 'Service_98'} \n", - "214 {'id': '12430', 'name': 'Service_205'} \n", + "210 {'id': '15660', 'name': 'Service_113'} \n", + "211 {'id': '12430', 'name': 'Service_205'} \n", + "212 {'id': '14073', 'name': 'Service_94'} \n", + "213 {'id': '15234', 'name': 'Service_134'} \n", + "214 {'id': '20274', 'name': 'Service_N55'} \n", "\n", " new_attributes \\\n", - "210 {'id': '15234', 'name': 'Brand_new_nameService... \n", - "211 {'id': '18915', 'name': 'Brand_new_nameService... \n", - "212 {'id': '17732', 'name': 'Brand_new_nameService... \n", - "213 {'id': '14134', 'name': 'Brand_new_nameService... \n", - "214 {'id': '12430', 'name': 'Brand_new_nameService... \n", + "210 {'id': '15660', 'name': 'Brand_new_nameService... \n", + "211 {'id': '12430', 'name': 'Brand_new_nameService... \n", + "212 {'id': '14073', 'name': 'Brand_new_nameService... \n", + "213 {'id': '15234', 'name': 'Brand_new_nameService... \n", + "214 {'id': '20274', 'name': 'Brand_new_nameService... \n", "\n", " diff \n", - "210 [(change, name, (Service_134, Brand_new_nameSe... \n", - "211 [(change, name, (Service_N5, Brand_new_nameSer... \n", - "212 [(change, name, (Service_N20, Brand_new_nameSe... \n", - "213 [(change, name, (Service_98, Brand_new_nameSer... \n", - "214 [(change, name, (Service_205, Brand_new_nameSe... " + "210 [(change, name, (Service_113, Brand_new_nameSe... \n", + "211 [(change, name, (Service_205, Brand_new_nameSe... \n", + "212 [(change, name, (Service_94, Brand_new_nameSer... \n", + "213 [(change, name, (Service_134, Brand_new_nameSe... \n", + "214 [(change, name, (Service_N55, Brand_new_nameSe... " ] }, "execution_count": 63, @@ -3441,7 +3441,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/5.2. Modifying Network - Simplification.ipynb b/notebooks/5.2. Modifying Network - Simplification.ipynb index 3511f64b..d30c45d6 100644 --- a/notebooks/5.2. Modifying Network - Simplification.ipynb +++ b/notebooks/5.2. Modifying Network - Simplification.ipynb @@ -14,8 +14,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:19:14.773131Z", - "start_time": "2021-03-15T10:19:03.620570Z" + "end_time": "2021-04-13T18:07:37.437612Z", + "start_time": "2021-04-13T18:07:25.002624Z" } }, "outputs": [ @@ -23,16 +23,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:19:06,453 - Building OSM graph from file ../example_data/example.osm\n", - "2021-03-15 10:19:07,029 - Creating networkx graph from OSM data\n", - "2021-03-15 10:19:07,030 - OSM: Extract Nodes and Paths from OSM data\n", - "2021-03-15 10:19:07,236 - OSM: Add each OSM way (aka, path) to the OSM graph\n", - "2021-03-15 10:19:07,238 - Created OSM edges\n", - "2021-03-15 10:19:09,078 - Added 8695 nodes\n", - "2021-03-15 10:19:14,265 - Generated 802 link ids.\n", - "2021-03-15 10:19:14,569 - Added 802 links\n", - "2021-03-15 10:19:14,570 - Deleting isolated nodes which have no edges.\n", - "2021-03-15 10:19:14,766 - Removed 8132 nodes.\n" + "2021-04-13 19:07:28,300 - Building OSM graph from file ../example_data/example.osm\n", + "2021-04-13 19:07:28,790 - Creating networkx graph from OSM data\n", + "2021-04-13 19:07:28,791 - OSM: Extract Nodes and Paths from OSM data\n", + "2021-04-13 19:07:29,000 - OSM: Add each OSM way (aka, path) to the OSM graph\n", + "2021-04-13 19:07:29,003 - Created OSM edges\n", + "2021-04-13 19:07:30,936 - Added 8695 nodes\n", + "2021-04-13 19:07:36,825 - Generated 802 link ids.\n", + "2021-04-13 19:07:37,193 - Added 802 links\n", + "2021-04-13 19:07:37,194 - Deleting isolated nodes which have no edges.\n", + "2021-04-13 19:07:37,430 - Removed 8132 nodes.\n" ] }, { @@ -53,9 +53,10 @@ } ], "source": [ - "from genet import Network\n", - "n = Network('epsg:27700')\n", - "n.read_osm('../example_data/example.osm', '../genet/configs/OSM/slim_config.yml')\n", + "from genet import read_osm\n", + "n = read_osm('../example_data/example.osm', \n", + " '../genet/configs/OSM/slim_config.yml',\n", + " epsg='epsg:27700')\n", "n.print()" ] }, @@ -71,8 +72,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:19:14.902249Z", - "start_time": "2021-03-15T10:19:14.775190Z" + "end_time": "2021-04-13T18:07:37.632876Z", + "start_time": "2021-04-13T18:07:37.441170Z" } }, "outputs": [ @@ -80,18 +81,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:19:14,776 - Begin simplifying the graph\n", - "2021-03-15 10:19:14,779 - Generating paths to be simplified\n", - "2021-03-15 10:19:14,782 - Identified 114 edge endpoints\n", - "2021-03-15 10:19:14,783 - Identified 163 possible paths\n", - "2021-03-15 10:19:14,784 - Processing 163 paths\n", - "2021-03-15 10:19:14,786 - Found 110 paths to simplify.\n", - "2021-03-15 10:19:14,787 - Generated 110 link ids.\n", - "2021-03-15 10:19:14,804 - Processing links for all paths to be simplified\n", - "2021-03-15 10:19:14,826 - Adding new simplified links\n", - "2021-03-15 10:19:14,857 - Generated 0 link ids.\n", - "2021-03-15 10:19:14,886 - Added 110 links\n", - "2021-03-15 10:19:14,898 - Simplified graph: 563 to 114 nodes, 802 to 163 edges\n" + "2021-04-13 19:07:37,442 - Begin simplifying the graph\n", + "2021-04-13 19:07:37,446 - Generating paths to be simplified\n", + "2021-04-13 19:07:37,452 - Identified 114 edge endpoints\n", + "2021-04-13 19:07:37,457 - Identified 163 possible paths\n", + "2021-04-13 19:07:37,459 - Processing 163 paths\n", + "2021-04-13 19:07:37,460 - Found 110 paths to simplify.\n", + "2021-04-13 19:07:37,461 - Generated 110 link ids.\n", + "2021-04-13 19:07:37,476 - Processing links for all paths to be simplified\n", + "2021-04-13 19:07:37,504 - Adding new simplified links\n", + "2021-04-13 19:07:37,551 - Generated 0 link ids.\n", + "2021-04-13 19:07:37,597 - Added 110 links\n", + "2021-04-13 19:07:37,625 - Simplified graph: 563 to 114 nodes, 802 to 163 edges\n" ] }, { @@ -254,7 +255,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/5.3. Modifying Network - Addition.ipynb b/notebooks/5.3. Modifying Network - Addition.ipynb index a7f79097..a66f8d1c 100644 --- a/notebooks/5.3. Modifying Network - Addition.ipynb +++ b/notebooks/5.3. Modifying Network - Addition.ipynb @@ -13,20 +13,6 @@ "For now, the method only supports non overlapping services for `Schedules`, so let's merge two `Network`s with just graphs." ] }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-15T10:20:28.822730Z", - "start_time": "2021-03-15T10:20:26.801043Z" - } - }, - "outputs": [], - "source": [ - "from genet import Network" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -36,11 +22,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:20:32.510351Z", - "start_time": "2021-03-15T10:20:28.824700Z" + "end_time": "2021-04-13T18:09:02.372263Z", + "start_time": "2021-04-13T18:08:55.832564Z" } }, "outputs": [ @@ -48,22 +34,22 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:29,291 - Building OSM graph from file ../example_data/tiny_example.osm\n", - "2021-03-15 10:20:29,356 - Creating networkx graph from OSM data\n", - "2021-03-15 10:20:29,357 - OSM: Extract Nodes and Paths from OSM data\n", - "2021-03-15 10:20:29,376 - OSM: Add each OSM way (aka, path) to the OSM graph\n", - "2021-03-15 10:20:29,377 - Created OSM edges\n", - "2021-03-15 10:20:29,721 - Added 810 nodes\n", - "2021-03-15 10:20:32,378 - Generated 275 link ids.\n", - "2021-03-15 10:20:32,489 - Added 275 links\n", - "2021-03-15 10:20:32,490 - Deleting isolated nodes which have no edges.\n", - "2021-03-15 10:20:32,505 - Removed 634 nodes.\n" + "2021-04-13 19:08:58,757 - Building OSM graph from file ../example_data/tiny_example.osm\n", + "2021-04-13 19:08:58,822 - Creating networkx graph from OSM data\n", + "2021-04-13 19:08:58,823 - OSM: Extract Nodes and Paths from OSM data\n", + "2021-04-13 19:08:58,843 - OSM: Add each OSM way (aka, path) to the OSM graph\n", + "2021-04-13 19:08:58,844 - Created OSM edges\n", + "2021-04-13 19:08:59,265 - Added 810 nodes\n", + "2021-04-13 19:09:02,192 - Generated 275 link ids.\n", + "2021-04-13 19:09:02,343 - Added 275 links\n", + "2021-04-13 19:09:02,344 - Deleting isolated nodes which have no edges.\n", + "2021-04-13 19:09:02,364 - Removed 634 nodes.\n" ] }, { "data": { "text/plain": [ - ":' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -121,10 +112,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -135,11 +126,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:20:41.140215Z", - "start_time": "2021-03-15T10:20:32.709620Z" + "end_time": "2021-04-13T18:09:11.307952Z", + "start_time": "2021-04-13T18:09:02.613973Z" } }, "outputs": [ @@ -147,22 +138,22 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:33,087 - Building OSM graph from file ../example_data/example.osm\n", - "2021-03-15 10:20:33,495 - Creating networkx graph from OSM data\n", - "2021-03-15 10:20:33,496 - OSM: Extract Nodes and Paths from OSM data\n", - "2021-03-15 10:20:33,670 - OSM: Add each OSM way (aka, path) to the OSM graph\n", - "2021-03-15 10:20:33,672 - Created OSM edges\n", - "2021-03-15 10:20:35,366 - Added 8695 nodes\n", - "2021-03-15 10:20:40,545 - Generated 802 link ids.\n", - "2021-03-15 10:20:40,902 - Added 802 links\n", - "2021-03-15 10:20:40,904 - Deleting isolated nodes which have no edges.\n", - "2021-03-15 10:20:41,133 - Removed 8132 nodes.\n" + "2021-04-13 19:09:03,023 - Building OSM graph from file ../example_data/example.osm\n", + "2021-04-13 19:09:03,499 - Creating networkx graph from OSM data\n", + "2021-04-13 19:09:03,500 - OSM: Extract Nodes and Paths from OSM data\n", + "2021-04-13 19:09:03,689 - OSM: Add each OSM way (aka, path) to the OSM graph\n", + "2021-04-13 19:09:03,690 - Created OSM edges\n", + "2021-04-13 19:09:05,513 - Added 8695 nodes\n", + "2021-04-13 19:09:10,730 - Generated 802 link ids.\n", + "2021-04-13 19:09:11,115 - Added 802 links\n", + "2021-04-13 19:09:11,117 - Deleting isolated nodes which have no edges.\n", + "2021-04-13 19:09:11,299 - Removed 8132 nodes.\n" ] }, { "data": { "text/plain": [ - ":' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -218,10 +212,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -239,11 +233,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:20:53.714780Z", - "start_time": "2021-03-15T10:20:41.492045Z" + "end_time": "2021-04-13T18:09:23.643704Z", + "start_time": "2021-04-13T18:09:11.611444Z" } }, "outputs": [ @@ -251,857 +245,857 @@ "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:41,505 - Generated node id 7195968685.\n", - "2021-03-15 10:20:41,509 - Changed Link attributes for 1 links\n", - "2021-03-15 10:20:41,512 - Changed Link attributes for 0 links\n", - "2021-03-15 10:20:41,525 - Changed Node attributes under index: 101998\n", - "2021-03-15 10:20:41,527 - Changed Node index from 101998 to 7195968685\n", - "2021-03-15 10:20:41,529 - Generated node id 7195968686.\n", - "2021-03-15 10:20:41,541 - Changed Link attributes for 2 links\n", - "2021-03-15 10:20:41,549 - Changed Link attributes for 2 links\n", - "2021-03-15 10:20:41,559 - Changed Node attributes under index: 1684410096\n", - "2021-03-15 10:20:41,561 - Changed Node index from 1684410096 to 7195968686\n", + "2021-04-13 19:09:11,633 - Generated node id 7195968685.\n", + "2021-04-13 19:09:11,640 - Changed Link attributes for 1 links\n", + "2021-04-13 19:09:11,643 - Changed Link attributes for 0 links\n", + "2021-04-13 19:09:11,657 - Changed Node attributes under index: 101998\n", + "2021-04-13 19:09:11,660 - Changed Node index from 101998 to 7195968685\n", + "2021-04-13 19:09:11,662 - Generated node id 7195968686.\n", + "2021-04-13 19:09:11,673 - Changed Link attributes for 2 links\n", + "2021-04-13 19:09:11,678 - Changed Link attributes for 2 links\n", + "2021-04-13 19:09:11,691 - Changed Node attributes under index: 1684410096\n", + "2021-04-13 19:09:11,696 - Changed Node index from 1684410096 to 7195968686\n", "/Users/kasia.kozlowska/PycharmProjects/ABM/genet/genet/utils/graph_operations.py:344: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n", " for idx in s2_id_df.dropna()[s2_id_df['right'] != s2_id_df['left']].index]\n", - "2021-03-15 10:20:41,569 - Finished consolidating node indexing between the two graphs\n", - "2021-03-15 10:20:49,181 - Removed 74 links\n", - "2021-03-15 10:20:49,185 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,185 - Generated link id 802.\n", - "2021-03-15 10:20:49,202 - Changed Link attributes under index: 231\n", - "2021-03-15 10:20:49,203 - Changed Link index from 231 to 802\n", - "2021-03-15 10:20:49,206 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,207 - Generated link id 803.\n", - "2021-03-15 10:20:49,239 - Changed Link attributes under index: 101\n", - "2021-03-15 10:20:49,239 - Changed Link index from 101 to 803\n", - "2021-03-15 10:20:49,244 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,247 - Generated link id 804.\n", - "2021-03-15 10:20:49,264 - Changed Link attributes under index: 75\n", - "2021-03-15 10:20:49,265 - Changed Link index from 75 to 804\n", - "2021-03-15 10:20:49,268 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,271 - Generated link id 805.\n", - "2021-03-15 10:20:49,287 - Changed Link attributes under index: 43\n", - "2021-03-15 10:20:49,288 - Changed Link index from 43 to 805\n", - "2021-03-15 10:20:49,293 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,294 - Generated link id 806.\n", - "2021-03-15 10:20:49,311 - Changed Link attributes under index: 29\n", - "2021-03-15 10:20:49,312 - Changed Link index from 29 to 806\n", - "2021-03-15 10:20:49,315 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,320 - Generated link id 807.\n", - "2021-03-15 10:20:49,336 - Changed Link attributes under index: 191\n", - "2021-03-15 10:20:49,337 - Changed Link index from 191 to 807\n", - "2021-03-15 10:20:49,340 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,343 - Generated link id 808.\n", - "2021-03-15 10:20:49,361 - Changed Link attributes under index: 25\n", - "2021-03-15 10:20:49,362 - Changed Link index from 25 to 808\n", - "2021-03-15 10:20:49,364 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,365 - Generated link id 809.\n", - "2021-03-15 10:20:49,384 - Changed Link attributes under index: 219\n", - "2021-03-15 10:20:49,385 - Changed Link index from 219 to 809\n", - "2021-03-15 10:20:49,388 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,390 - Generated link id 810.\n", - "2021-03-15 10:20:49,408 - Changed Link attributes under index: 89\n", - "2021-03-15 10:20:49,408 - Changed Link index from 89 to 810\n", - "2021-03-15 10:20:49,412 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,414 - Generated link id 811.\n", - "2021-03-15 10:20:49,429 - Changed Link attributes under index: 256\n", - "2021-03-15 10:20:49,430 - Changed Link index from 256 to 811\n", - "2021-03-15 10:20:49,432 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,432 - Generated link id 812.\n", - "2021-03-15 10:20:49,450 - Changed Link attributes under index: 128\n", - "2021-03-15 10:20:49,453 - Changed Link index from 128 to 812\n", - "2021-03-15 10:20:49,454 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,456 - Generated link id 813.\n", - "2021-03-15 10:20:49,476 - Changed Link attributes under index: 170\n", - "2021-03-15 10:20:49,477 - Changed Link index from 170 to 813\n", - "2021-03-15 10:20:49,480 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,483 - Generated link id 814.\n", - "2021-03-15 10:20:49,500 - Changed Link attributes under index: 145\n", - "2021-03-15 10:20:49,501 - Changed Link index from 145 to 814\n", - "2021-03-15 10:20:49,504 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,504 - Generated link id 815.\n", - "2021-03-15 10:20:49,519 - Changed Link attributes under index: 27\n", - "2021-03-15 10:20:49,520 - Changed Link index from 27 to 815\n", - "2021-03-15 10:20:49,527 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,529 - Generated link id 816.\n", - "2021-03-15 10:20:49,546 - Changed Link attributes under index: 248\n", - "2021-03-15 10:20:49,547 - Changed Link index from 248 to 816\n", - "2021-03-15 10:20:49,549 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,550 - Generated link id 817.\n", - "2021-03-15 10:20:49,569 - Changed Link attributes under index: 190\n", - "2021-03-15 10:20:49,571 - Changed Link index from 190 to 817\n", - "2021-03-15 10:20:49,574 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,575 - Generated link id 818.\n", - "2021-03-15 10:20:49,595 - Changed Link attributes under index: 109\n", - "2021-03-15 10:20:49,596 - Changed Link index from 109 to 818\n", - "2021-03-15 10:20:49,602 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,603 - Generated link id 819.\n", - "2021-03-15 10:20:49,619 - Changed Link attributes under index: 60\n", - "2021-03-15 10:20:49,621 - Changed Link index from 60 to 819\n", - "2021-03-15 10:20:49,623 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,626 - Generated link id 820.\n", - "2021-03-15 10:20:49,647 - Changed Link attributes under index: 97\n", - "2021-03-15 10:20:49,648 - Changed Link index from 97 to 820\n", - "2021-03-15 10:20:49,651 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,654 - Generated link id 821.\n", - "2021-03-15 10:20:49,670 - Changed Link attributes under index: 157\n", - "2021-03-15 10:20:49,671 - Changed Link index from 157 to 821\n", - "2021-03-15 10:20:49,678 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,681 - Generated link id 822.\n", - "2021-03-15 10:20:49,703 - Changed Link attributes under index: 96\n", - "2021-03-15 10:20:49,703 - Changed Link index from 96 to 822\n", - "2021-03-15 10:20:49,707 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,708 - Generated link id 823.\n", - "2021-03-15 10:20:49,721 - Changed Link attributes under index: 34\n", - "2021-03-15 10:20:49,726 - Changed Link index from 34 to 823\n", - "2021-03-15 10:20:49,734 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,736 - Generated link id 824.\n", - "2021-03-15 10:20:49,760 - Changed Link attributes under index: 106\n", - "2021-03-15 10:20:49,761 - Changed Link index from 106 to 824\n", - "2021-03-15 10:20:49,764 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,768 - Generated link id 825.\n", - "2021-03-15 10:20:49,782 - Changed Link attributes under index: 126\n", - "2021-03-15 10:20:49,786 - Changed Link index from 126 to 825\n", - "2021-03-15 10:20:49,789 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,790 - Generated link id 826.\n", - "2021-03-15 10:20:49,808 - Changed Link attributes under index: 189\n", - "2021-03-15 10:20:49,809 - Changed Link index from 189 to 826\n", - "2021-03-15 10:20:49,814 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,830 - Generated link id 827.\n", - "2021-03-15 10:20:49,849 - Changed Link attributes under index: 64\n", - "2021-03-15 10:20:49,852 - Changed Link index from 64 to 827\n", - "2021-03-15 10:20:49,854 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,855 - Generated link id 828.\n", - "2021-03-15 10:20:49,872 - Changed Link attributes under index: 108\n", - "2021-03-15 10:20:49,874 - Changed Link index from 108 to 828\n", - "2021-03-15 10:20:49,877 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,878 - Generated link id 829.\n", - "2021-03-15 10:20:49,893 - Changed Link attributes under index: 274\n", - "2021-03-15 10:20:49,894 - Changed Link index from 274 to 829\n", - "2021-03-15 10:20:49,896 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,897 - Generated link id 830.\n", - "2021-03-15 10:20:49,913 - Changed Link attributes under index: 31\n", - "2021-03-15 10:20:49,915 - Changed Link index from 31 to 830\n", - "2021-03-15 10:20:49,917 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,921 - Generated link id 831.\n", - "2021-03-15 10:20:49,935 - Changed Link attributes under index: 33\n", - "2021-03-15 10:20:49,936 - Changed Link index from 33 to 831\n", - "2021-03-15 10:20:49,939 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,941 - Generated link id 832.\n", - "2021-03-15 10:20:49,957 - Changed Link attributes under index: 155\n", - "2021-03-15 10:20:49,958 - Changed Link index from 155 to 832\n", - "2021-03-15 10:20:49,960 - Generated 1 link ids.\n", - "2021-03-15 10:20:49,961 - Generated link id 833.\n", - "2021-03-15 10:20:49,977 - Changed Link attributes under index: 250\n", - "2021-03-15 10:20:49,978 - Changed Link index from 250 to 833\n", - "2021-03-15 10:20:49,981 - Generated 1 link ids.\n" + "2021-04-13 19:09:11,707 - Finished consolidating node indexing between the two graphs\n", + "2021-04-13 19:09:19,481 - Removed 74 links\n", + "2021-04-13 19:09:19,484 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,485 - Generated link id 802.\n", + "2021-04-13 19:09:19,501 - Changed Link attributes under index: 181\n", + "2021-04-13 19:09:19,502 - Changed Link index from 181 to 802\n", + "2021-04-13 19:09:19,511 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,514 - Generated link id 803.\n", + "2021-04-13 19:09:19,534 - Changed Link attributes under index: 236\n", + "2021-04-13 19:09:19,535 - Changed Link index from 236 to 803\n", + "2021-04-13 19:09:19,538 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,539 - Generated link id 804.\n", + "2021-04-13 19:09:19,566 - Changed Link attributes under index: 150\n", + "2021-04-13 19:09:19,567 - Changed Link index from 150 to 804\n", + "2021-04-13 19:09:19,582 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,582 - Generated link id 805.\n", + "2021-04-13 19:09:19,599 - Changed Link attributes under index: 59\n", + "2021-04-13 19:09:19,600 - Changed Link index from 59 to 805\n", + "2021-04-13 19:09:19,607 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,609 - Generated link id 806.\n", + "2021-04-13 19:09:19,632 - Changed Link attributes under index: 216\n", + "2021-04-13 19:09:19,633 - Changed Link index from 216 to 806\n", + "2021-04-13 19:09:19,639 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,641 - Generated link id 807.\n", + "2021-04-13 19:09:19,657 - Changed Link attributes under index: 15\n", + "2021-04-13 19:09:19,662 - Changed Link index from 15 to 807\n", + "2021-04-13 19:09:19,667 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,669 - Generated link id 808.\n", + "2021-04-13 19:09:19,688 - Changed Link attributes under index: 43\n", + "2021-04-13 19:09:19,690 - Changed Link index from 43 to 808\n", + "2021-04-13 19:09:19,693 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,694 - Generated link id 809.\n", + "2021-04-13 19:09:19,703 - Changed Link attributes under index: 110\n", + "2021-04-13 19:09:19,704 - Changed Link index from 110 to 809\n", + "2021-04-13 19:09:19,708 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,709 - Generated link id 810.\n", + "2021-04-13 19:09:19,724 - Changed Link attributes under index: 218\n", + "2021-04-13 19:09:19,725 - Changed Link index from 218 to 810\n", + "2021-04-13 19:09:19,729 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,732 - Generated link id 811.\n", + "2021-04-13 19:09:19,750 - Changed Link attributes under index: 2\n", + "2021-04-13 19:09:19,751 - Changed Link index from 2 to 811\n", + "2021-04-13 19:09:19,759 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,760 - Generated link id 812.\n", + "2021-04-13 19:09:19,775 - Changed Link attributes under index: 30\n", + "2021-04-13 19:09:19,776 - Changed Link index from 30 to 812\n", + "2021-04-13 19:09:19,781 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,782 - Generated link id 813.\n", + "2021-04-13 19:09:19,800 - Changed Link attributes under index: 126\n", + "2021-04-13 19:09:19,802 - Changed Link index from 126 to 813\n", + "2021-04-13 19:09:19,811 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,812 - Generated link id 814.\n", + "2021-04-13 19:09:19,835 - Changed Link attributes under index: 267\n", + "2021-04-13 19:09:19,837 - Changed Link index from 267 to 814\n", + "2021-04-13 19:09:19,842 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,844 - Generated link id 815.\n", + "2021-04-13 19:09:19,864 - Changed Link attributes under index: 18\n", + "2021-04-13 19:09:19,865 - Changed Link index from 18 to 815\n", + "2021-04-13 19:09:19,868 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,872 - Generated link id 816.\n", + "2021-04-13 19:09:19,889 - Changed Link attributes under index: 31\n", + "2021-04-13 19:09:19,892 - Changed Link index from 31 to 816\n", + "2021-04-13 19:09:19,893 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,898 - Generated link id 817.\n", + "2021-04-13 19:09:19,920 - Changed Link attributes under index: 91\n", + "2021-04-13 19:09:19,921 - Changed Link index from 91 to 817\n", + "2021-04-13 19:09:19,927 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,928 - Generated link id 818.\n", + "2021-04-13 19:09:19,939 - Changed Link attributes under index: 67\n", + "2021-04-13 19:09:19,941 - Changed Link index from 67 to 818\n", + "2021-04-13 19:09:19,943 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,946 - Generated link id 819.\n", + "2021-04-13 19:09:19,963 - Changed Link attributes under index: 197\n", + "2021-04-13 19:09:19,964 - Changed Link index from 197 to 819\n", + "2021-04-13 19:09:19,967 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,971 - Generated link id 820.\n", + "2021-04-13 19:09:19,996 - Changed Link attributes under index: 76\n", + "2021-04-13 19:09:19,996 - Changed Link index from 76 to 820\n", + "2021-04-13 19:09:19,998 - Generated 1 link ids.\n", + "2021-04-13 19:09:19,999 - Generated link id 821.\n", + "2021-04-13 19:09:20,017 - Changed Link attributes under index: 108\n", + "2021-04-13 19:09:20,017 - Changed Link index from 108 to 821\n", + "2021-04-13 19:09:20,022 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,024 - Generated link id 822.\n", + "2021-04-13 19:09:20,040 - Changed Link attributes under index: 84\n", + "2021-04-13 19:09:20,041 - Changed Link index from 84 to 822\n", + "2021-04-13 19:09:20,045 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,047 - Generated link id 823.\n", + "2021-04-13 19:09:20,067 - Changed Link attributes under index: 147\n", + "2021-04-13 19:09:20,068 - Changed Link index from 147 to 823\n", + "2021-04-13 19:09:20,074 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,075 - Generated link id 824.\n", + "2021-04-13 19:09:20,094 - Changed Link attributes under index: 145\n", + "2021-04-13 19:09:20,100 - Changed Link index from 145 to 824\n", + "2021-04-13 19:09:20,105 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,105 - Generated link id 825.\n", + "2021-04-13 19:09:20,128 - Changed Link attributes under index: 141\n", + "2021-04-13 19:09:20,129 - Changed Link index from 141 to 825\n", + "2021-04-13 19:09:20,132 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,134 - Generated link id 826.\n", + "2021-04-13 19:09:20,154 - Changed Link attributes under index: 274\n", + "2021-04-13 19:09:20,159 - Changed Link index from 274 to 826\n", + "2021-04-13 19:09:20,162 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,164 - Generated link id 827.\n", + "2021-04-13 19:09:20,180 - Changed Link attributes under index: 95\n", + "2021-04-13 19:09:20,182 - Changed Link index from 95 to 827\n", + "2021-04-13 19:09:20,184 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,186 - Generated link id 828.\n", + "2021-04-13 19:09:20,206 - Changed Link attributes under index: 245\n", + "2021-04-13 19:09:20,208 - Changed Link index from 245 to 828\n", + "2021-04-13 19:09:20,212 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,214 - Generated link id 829.\n", + "2021-04-13 19:09:20,229 - Changed Link attributes under index: 35\n", + "2021-04-13 19:09:20,229 - Changed Link index from 35 to 829\n", + "2021-04-13 19:09:20,232 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,234 - Generated link id 830.\n", + "2021-04-13 19:09:20,251 - Changed Link attributes under index: 106\n", + "2021-04-13 19:09:20,252 - Changed Link index from 106 to 830\n", + "2021-04-13 19:09:20,257 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,259 - Generated link id 831.\n", + "2021-04-13 19:09:20,283 - Changed Link attributes under index: 212\n", + "2021-04-13 19:09:20,291 - Changed Link index from 212 to 831\n", + "2021-04-13 19:09:20,299 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,300 - Generated link id 832.\n", + "2021-04-13 19:09:20,320 - Changed Link attributes under index: 259\n", + "2021-04-13 19:09:20,323 - Changed Link index from 259 to 832\n", + "2021-04-13 19:09:20,332 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,334 - Generated link id 833.\n", + "2021-04-13 19:09:20,350 - Changed Link attributes under index: 162\n", + "2021-04-13 19:09:20,351 - Changed Link index from 162 to 833\n", + "2021-04-13 19:09:20,353 - Generated 1 link ids.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:49,984 - Generated link id 834.\n", - "2021-03-15 10:20:49,998 - Changed Link attributes under index: 260\n", - "2021-03-15 10:20:49,999 - Changed Link index from 260 to 834\n", - "2021-03-15 10:20:50,000 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,005 - Generated link id 835.\n", - "2021-03-15 10:20:50,018 - Changed Link attributes under index: 244\n", - "2021-03-15 10:20:50,020 - Changed Link index from 244 to 835\n", - "2021-03-15 10:20:50,024 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,025 - Generated link id 836.\n", - "2021-03-15 10:20:50,034 - Changed Link attributes under index: 114\n", - "2021-03-15 10:20:50,036 - Changed Link index from 114 to 836\n", - "2021-03-15 10:20:50,040 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,041 - Generated link id 837.\n", - "2021-03-15 10:20:50,051 - Changed Link attributes under index: 163\n", - "2021-03-15 10:20:50,054 - Changed Link index from 163 to 837\n", - "2021-03-15 10:20:50,057 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,058 - Generated link id 838.\n", - "2021-03-15 10:20:50,067 - Changed Link attributes under index: 185\n", - "2021-03-15 10:20:50,067 - Changed Link index from 185 to 838\n", - "2021-03-15 10:20:50,072 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,073 - Generated link id 839.\n", - "2021-03-15 10:20:50,082 - Changed Link attributes under index: 221\n", - "2021-03-15 10:20:50,083 - Changed Link index from 221 to 839\n", - "2021-03-15 10:20:50,084 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,086 - Generated link id 840.\n", - "2021-03-15 10:20:50,097 - Changed Link attributes under index: 117\n", - "2021-03-15 10:20:50,098 - Changed Link index from 117 to 840\n", - "2021-03-15 10:20:50,099 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,101 - Generated link id 841.\n", - "2021-03-15 10:20:50,112 - Changed Link attributes under index: 202\n", - "2021-03-15 10:20:50,113 - Changed Link index from 202 to 841\n", - "2021-03-15 10:20:50,115 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,116 - Generated link id 842.\n", - "2021-03-15 10:20:50,128 - Changed Link attributes under index: 87\n", - "2021-03-15 10:20:50,129 - Changed Link index from 87 to 842\n", - "2021-03-15 10:20:50,130 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,131 - Generated link id 843.\n", - "2021-03-15 10:20:50,144 - Changed Link attributes under index: 201\n", - "2021-03-15 10:20:50,145 - Changed Link index from 201 to 843\n", - "2021-03-15 10:20:50,147 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,148 - Generated link id 844.\n", - "2021-03-15 10:20:50,159 - Changed Link attributes under index: 198\n", - "2021-03-15 10:20:50,160 - Changed Link index from 198 to 844\n", - "2021-03-15 10:20:50,161 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,162 - Generated link id 845.\n", - "2021-03-15 10:20:50,174 - Changed Link attributes under index: 154\n", - "2021-03-15 10:20:50,175 - Changed Link index from 154 to 845\n", - "2021-03-15 10:20:50,176 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,177 - Generated link id 846.\n", - "2021-03-15 10:20:50,193 - Changed Link attributes under index: 57\n", - "2021-03-15 10:20:50,193 - Changed Link index from 57 to 846\n", - "2021-03-15 10:20:50,195 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,196 - Generated link id 847.\n", - "2021-03-15 10:20:50,209 - Changed Link attributes under index: 261\n", - "2021-03-15 10:20:50,210 - Changed Link index from 261 to 847\n", - "2021-03-15 10:20:50,212 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,213 - Generated link id 848.\n", - "2021-03-15 10:20:50,227 - Changed Link attributes under index: 137\n", - "2021-03-15 10:20:50,228 - Changed Link index from 137 to 848\n", - "2021-03-15 10:20:50,229 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,230 - Generated link id 849.\n", - "2021-03-15 10:20:50,244 - Changed Link attributes under index: 177\n", - "2021-03-15 10:20:50,245 - Changed Link index from 177 to 849\n", - "2021-03-15 10:20:50,246 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,248 - Generated link id 850.\n", - "2021-03-15 10:20:50,262 - Changed Link attributes under index: 151\n", - "2021-03-15 10:20:50,263 - Changed Link index from 151 to 850\n", - "2021-03-15 10:20:50,265 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,270 - Generated link id 851.\n", - "2021-03-15 10:20:50,292 - Changed Link attributes under index: 6\n", - "2021-03-15 10:20:50,293 - Changed Link index from 6 to 851\n", - "2021-03-15 10:20:50,297 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,299 - Generated link id 852.\n", - "2021-03-15 10:20:50,318 - Changed Link attributes under index: 186\n", - "2021-03-15 10:20:50,321 - Changed Link index from 186 to 852\n", - "2021-03-15 10:20:50,330 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,337 - Generated link id 853.\n", - "2021-03-15 10:20:50,351 - Changed Link attributes under index: 168\n", - "2021-03-15 10:20:50,354 - Changed Link index from 168 to 853\n", - "2021-03-15 10:20:50,357 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,359 - Generated link id 854.\n", - "2021-03-15 10:20:50,378 - Changed Link attributes under index: 8\n", - "2021-03-15 10:20:50,379 - Changed Link index from 8 to 854\n", - "2021-03-15 10:20:50,381 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,384 - Generated link id 855.\n", - "2021-03-15 10:20:50,401 - Changed Link attributes under index: 111\n", - "2021-03-15 10:20:50,402 - Changed Link index from 111 to 855\n", - "2021-03-15 10:20:50,405 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,407 - Generated link id 856.\n", - "2021-03-15 10:20:50,418 - Changed Link attributes under index: 37\n", - "2021-03-15 10:20:50,419 - Changed Link index from 37 to 856\n", - "2021-03-15 10:20:50,423 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,426 - Generated link id 857.\n", - "2021-03-15 10:20:50,440 - Changed Link attributes under index: 4\n", - "2021-03-15 10:20:50,440 - Changed Link index from 4 to 857\n", - "2021-03-15 10:20:50,443 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,444 - Generated link id 858.\n", - "2021-03-15 10:20:50,457 - Changed Link attributes under index: 245\n", - "2021-03-15 10:20:50,458 - Changed Link index from 245 to 858\n", - "2021-03-15 10:20:50,459 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,460 - Generated link id 859.\n", - "2021-03-15 10:20:50,471 - Changed Link attributes under index: 9\n", - "2021-03-15 10:20:50,472 - Changed Link index from 9 to 859\n", - "2021-03-15 10:20:50,478 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,489 - Generated link id 860.\n", - "2021-03-15 10:20:50,501 - Changed Link attributes under index: 218\n", - "2021-03-15 10:20:50,504 - Changed Link index from 218 to 860\n", - "2021-03-15 10:20:50,507 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,509 - Generated link id 861.\n", - "2021-03-15 10:20:50,519 - Changed Link attributes under index: 24\n", - "2021-03-15 10:20:50,521 - Changed Link index from 24 to 861\n", - "2021-03-15 10:20:50,524 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,526 - Generated link id 862.\n", - "2021-03-15 10:20:50,540 - Changed Link attributes under index: 257\n", - "2021-03-15 10:20:50,542 - Changed Link index from 257 to 862\n", - "2021-03-15 10:20:50,545 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,546 - Generated link id 863.\n", - "2021-03-15 10:20:50,559 - Changed Link attributes under index: 110\n", - "2021-03-15 10:20:50,560 - Changed Link index from 110 to 863\n", - "2021-03-15 10:20:50,563 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,564 - Generated link id 864.\n", - "2021-03-15 10:20:50,576 - Changed Link attributes under index: 206\n", - "2021-03-15 10:20:50,577 - Changed Link index from 206 to 864\n", - "2021-03-15 10:20:50,578 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,580 - Generated link id 865.\n", - "2021-03-15 10:20:50,594 - Changed Link attributes under index: 142\n", - "2021-03-15 10:20:50,595 - Changed Link index from 142 to 865\n", - "2021-03-15 10:20:50,596 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,597 - Generated link id 866.\n", - "2021-03-15 10:20:50,610 - Changed Link attributes under index: 98\n", - "2021-03-15 10:20:50,610 - Changed Link index from 98 to 866\n", - "2021-03-15 10:20:50,612 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,614 - Generated link id 867.\n", - "2021-03-15 10:20:50,626 - Changed Link attributes under index: 266\n", - "2021-03-15 10:20:50,627 - Changed Link index from 266 to 867\n", - "2021-03-15 10:20:50,629 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,630 - Generated link id 868.\n", - "2021-03-15 10:20:50,643 - Changed Link attributes under index: 133\n", - "2021-03-15 10:20:50,644 - Changed Link index from 133 to 868\n", - "2021-03-15 10:20:50,645 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,646 - Generated link id 869.\n", - "2021-03-15 10:20:50,658 - Changed Link attributes under index: 139\n", - "2021-03-15 10:20:50,659 - Changed Link index from 139 to 869\n", - "2021-03-15 10:20:50,660 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,661 - Generated link id 870.\n", - "2021-03-15 10:20:50,673 - Changed Link attributes under index: 36\n", - "2021-03-15 10:20:50,673 - Changed Link index from 36 to 870\n" + "2021-04-13 19:09:20,356 - Generated link id 834.\n", + "2021-04-13 19:09:20,369 - Changed Link attributes under index: 111\n", + "2021-04-13 19:09:20,370 - Changed Link index from 111 to 834\n", + "2021-04-13 19:09:20,372 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,373 - Generated link id 835.\n", + "2021-04-13 19:09:20,385 - Changed Link attributes under index: 119\n", + "2021-04-13 19:09:20,385 - Changed Link index from 119 to 835\n", + "2021-04-13 19:09:20,388 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,389 - Generated link id 836.\n", + "2021-04-13 19:09:20,402 - Changed Link attributes under index: 167\n", + "2021-04-13 19:09:20,404 - Changed Link index from 167 to 836\n", + "2021-04-13 19:09:20,405 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,406 - Generated link id 837.\n", + "2021-04-13 19:09:20,418 - Changed Link attributes under index: 194\n", + "2021-04-13 19:09:20,419 - Changed Link index from 194 to 837\n", + "2021-04-13 19:09:20,421 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,421 - Generated link id 838.\n", + "2021-04-13 19:09:20,433 - Changed Link attributes under index: 186\n", + "2021-04-13 19:09:20,434 - Changed Link index from 186 to 838\n", + "2021-04-13 19:09:20,435 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,437 - Generated link id 839.\n", + "2021-04-13 19:09:20,452 - Changed Link attributes under index: 92\n", + "2021-04-13 19:09:20,453 - Changed Link index from 92 to 839\n", + "2021-04-13 19:09:20,456 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,459 - Generated link id 840.\n", + "2021-04-13 19:09:20,469 - Changed Link attributes under index: 69\n", + "2021-04-13 19:09:20,470 - Changed Link index from 69 to 840\n", + "2021-04-13 19:09:20,471 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,473 - Generated link id 841.\n", + "2021-04-13 19:09:20,485 - Changed Link attributes under index: 94\n", + "2021-04-13 19:09:20,485 - Changed Link index from 94 to 841\n", + "2021-04-13 19:09:20,487 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,489 - Generated link id 842.\n", + "2021-04-13 19:09:20,504 - Changed Link attributes under index: 252\n", + "2021-04-13 19:09:20,505 - Changed Link index from 252 to 842\n", + "2021-04-13 19:09:20,509 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,511 - Generated link id 843.\n", + "2021-04-13 19:09:20,525 - Changed Link attributes under index: 200\n", + "2021-04-13 19:09:20,526 - Changed Link index from 200 to 843\n", + "2021-04-13 19:09:20,529 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,530 - Generated link id 844.\n", + "2021-04-13 19:09:20,540 - Changed Link attributes under index: 136\n", + "2021-04-13 19:09:20,541 - Changed Link index from 136 to 844\n", + "2021-04-13 19:09:20,544 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,546 - Generated link id 845.\n", + "2021-04-13 19:09:20,559 - Changed Link attributes under index: 180\n", + "2021-04-13 19:09:20,561 - Changed Link index from 180 to 845\n", + "2021-04-13 19:09:20,564 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,565 - Generated link id 846.\n", + "2021-04-13 19:09:20,579 - Changed Link attributes under index: 258\n", + "2021-04-13 19:09:20,579 - Changed Link index from 258 to 846\n", + "2021-04-13 19:09:20,581 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,582 - Generated link id 847.\n", + "2021-04-13 19:09:20,593 - Changed Link attributes under index: 113\n", + "2021-04-13 19:09:20,594 - Changed Link index from 113 to 847\n", + "2021-04-13 19:09:20,597 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,598 - Generated link id 848.\n", + "2021-04-13 19:09:20,614 - Changed Link attributes under index: 33\n", + "2021-04-13 19:09:20,615 - Changed Link index from 33 to 848\n", + "2021-04-13 19:09:20,618 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,620 - Generated link id 849.\n", + "2021-04-13 19:09:20,634 - Changed Link attributes under index: 246\n", + "2021-04-13 19:09:20,634 - Changed Link index from 246 to 849\n", + "2021-04-13 19:09:20,637 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,638 - Generated link id 850.\n", + "2021-04-13 19:09:20,649 - Changed Link attributes under index: 183\n", + "2021-04-13 19:09:20,649 - Changed Link index from 183 to 850\n", + "2021-04-13 19:09:20,652 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,655 - Generated link id 851.\n", + "2021-04-13 19:09:20,668 - Changed Link attributes under index: 165\n", + "2021-04-13 19:09:20,668 - Changed Link index from 165 to 851\n", + "2021-04-13 19:09:20,670 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,672 - Generated link id 852.\n", + "2021-04-13 19:09:20,683 - Changed Link attributes under index: 172\n", + "2021-04-13 19:09:20,684 - Changed Link index from 172 to 852\n", + "2021-04-13 19:09:20,687 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,688 - Generated link id 853.\n", + "2021-04-13 19:09:20,700 - Changed Link attributes under index: 265\n", + "2021-04-13 19:09:20,700 - Changed Link index from 265 to 853\n", + "2021-04-13 19:09:20,703 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,704 - Generated link id 854.\n", + "2021-04-13 19:09:20,716 - Changed Link attributes under index: 168\n", + "2021-04-13 19:09:20,716 - Changed Link index from 168 to 854\n", + "2021-04-13 19:09:20,719 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,720 - Generated link id 855.\n", + "2021-04-13 19:09:20,732 - Changed Link attributes under index: 242\n", + "2021-04-13 19:09:20,733 - Changed Link index from 242 to 855\n", + "2021-04-13 19:09:20,735 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,736 - Generated link id 856.\n", + "2021-04-13 19:09:20,750 - Changed Link attributes under index: 178\n", + "2021-04-13 19:09:20,751 - Changed Link index from 178 to 856\n", + "2021-04-13 19:09:20,754 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,755 - Generated link id 857.\n", + "2021-04-13 19:09:20,765 - Changed Link attributes under index: 86\n", + "2021-04-13 19:09:20,766 - Changed Link index from 86 to 857\n", + "2021-04-13 19:09:20,768 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,770 - Generated link id 858.\n", + "2021-04-13 19:09:20,782 - Changed Link attributes under index: 226\n", + "2021-04-13 19:09:20,782 - Changed Link index from 226 to 858\n", + "2021-04-13 19:09:20,784 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,785 - Generated link id 859.\n", + "2021-04-13 19:09:20,801 - Changed Link attributes under index: 8\n", + "2021-04-13 19:09:20,801 - Changed Link index from 8 to 859\n", + "2021-04-13 19:09:20,803 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,805 - Generated link id 860.\n", + "2021-04-13 19:09:20,815 - Changed Link attributes under index: 52\n", + "2021-04-13 19:09:20,816 - Changed Link index from 52 to 860\n", + "2021-04-13 19:09:20,818 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,820 - Generated link id 861.\n", + "2021-04-13 19:09:20,832 - Changed Link attributes under index: 230\n", + "2021-04-13 19:09:20,833 - Changed Link index from 230 to 861\n", + "2021-04-13 19:09:20,835 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,837 - Generated link id 862.\n", + "2021-04-13 19:09:20,847 - Changed Link attributes under index: 201\n", + "2021-04-13 19:09:20,848 - Changed Link index from 201 to 862\n", + "2021-04-13 19:09:20,849 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,850 - Generated link id 863.\n", + "2021-04-13 19:09:20,863 - Changed Link attributes under index: 44\n", + "2021-04-13 19:09:20,863 - Changed Link index from 44 to 863\n", + "2021-04-13 19:09:20,865 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,866 - Generated link id 864.\n", + "2021-04-13 19:09:20,877 - Changed Link attributes under index: 243\n", + "2021-04-13 19:09:20,878 - Changed Link index from 243 to 864\n", + "2021-04-13 19:09:20,881 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,882 - Generated link id 865.\n", + "2021-04-13 19:09:20,893 - Changed Link attributes under index: 112\n", + "2021-04-13 19:09:20,894 - Changed Link index from 112 to 865\n", + "2021-04-13 19:09:20,898 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,899 - Generated link id 866.\n", + "2021-04-13 19:09:20,913 - Changed Link attributes under index: 70\n", + "2021-04-13 19:09:20,914 - Changed Link index from 70 to 866\n", + "2021-04-13 19:09:20,915 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,917 - Generated link id 867.\n", + "2021-04-13 19:09:20,928 - Changed Link attributes under index: 146\n", + "2021-04-13 19:09:20,928 - Changed Link index from 146 to 867\n", + "2021-04-13 19:09:20,933 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,933 - Generated link id 868.\n", + "2021-04-13 19:09:20,944 - Changed Link attributes under index: 187\n", + "2021-04-13 19:09:20,945 - Changed Link index from 187 to 868\n", + "2021-04-13 19:09:20,949 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,950 - Generated link id 869.\n", + "2021-04-13 19:09:20,965 - Changed Link attributes under index: 125\n", + "2021-04-13 19:09:20,966 - Changed Link index from 125 to 869\n", + "2021-04-13 19:09:20,968 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,969 - Generated link id 870.\n", + "2021-04-13 19:09:20,981 - Changed Link attributes under index: 193\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:50,675 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,676 - Generated link id 871.\n", - "2021-03-15 10:20:50,689 - Changed Link attributes under index: 203\n", - "2021-03-15 10:20:50,690 - Changed Link index from 203 to 871\n", - "2021-03-15 10:20:50,692 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,693 - Generated link id 872.\n", - "2021-03-15 10:20:50,705 - Changed Link attributes under index: 49\n", - "2021-03-15 10:20:50,706 - Changed Link index from 49 to 872\n", - "2021-03-15 10:20:50,708 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,709 - Generated link id 873.\n", - "2021-03-15 10:20:50,721 - Changed Link attributes under index: 88\n", - "2021-03-15 10:20:50,721 - Changed Link index from 88 to 873\n", - "2021-03-15 10:20:50,723 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,726 - Generated link id 874.\n", - "2021-03-15 10:20:50,741 - Changed Link attributes under index: 55\n", - "2021-03-15 10:20:50,741 - Changed Link index from 55 to 874\n", - "2021-03-15 10:20:50,743 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,743 - Generated link id 875.\n", - "2021-03-15 10:20:50,755 - Changed Link attributes under index: 237\n", - "2021-03-15 10:20:50,756 - Changed Link index from 237 to 875\n", - "2021-03-15 10:20:50,757 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,759 - Generated link id 876.\n", - "2021-03-15 10:20:50,768 - Changed Link attributes under index: 262\n", - "2021-03-15 10:20:50,769 - Changed Link index from 262 to 876\n", - "2021-03-15 10:20:50,773 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,774 - Generated link id 877.\n", - "2021-03-15 10:20:50,784 - Changed Link attributes under index: 19\n", - "2021-03-15 10:20:50,785 - Changed Link index from 19 to 877\n", - "2021-03-15 10:20:50,788 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,789 - Generated link id 878.\n", - "2021-03-15 10:20:50,800 - Changed Link attributes under index: 188\n", - "2021-03-15 10:20:50,801 - Changed Link index from 188 to 878\n", - "2021-03-15 10:20:50,803 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,805 - Generated link id 879.\n", - "2021-03-15 10:20:50,815 - Changed Link attributes under index: 195\n", - "2021-03-15 10:20:50,816 - Changed Link index from 195 to 879\n", - "2021-03-15 10:20:50,817 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,818 - Generated link id 880.\n", - "2021-03-15 10:20:50,831 - Changed Link attributes under index: 263\n", - "2021-03-15 10:20:50,831 - Changed Link index from 263 to 880\n", - "2021-03-15 10:20:50,834 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,835 - Generated link id 881.\n", - "2021-03-15 10:20:50,846 - Changed Link attributes under index: 53\n", - "2021-03-15 10:20:50,847 - Changed Link index from 53 to 881\n", - "2021-03-15 10:20:50,850 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,850 - Generated link id 882.\n", - "2021-03-15 10:20:50,862 - Changed Link attributes under index: 38\n", - "2021-03-15 10:20:50,862 - Changed Link index from 38 to 882\n", - "2021-03-15 10:20:50,864 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,865 - Generated link id 883.\n", - "2021-03-15 10:20:50,877 - Changed Link attributes under index: 30\n", - "2021-03-15 10:20:50,878 - Changed Link index from 30 to 883\n", - "2021-03-15 10:20:50,879 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,880 - Generated link id 884.\n", - "2021-03-15 10:20:50,892 - Changed Link attributes under index: 54\n", - "2021-03-15 10:20:50,893 - Changed Link index from 54 to 884\n", - "2021-03-15 10:20:50,894 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,895 - Generated link id 885.\n", - "2021-03-15 10:20:50,908 - Changed Link attributes under index: 152\n", - "2021-03-15 10:20:50,909 - Changed Link index from 152 to 885\n", - "2021-03-15 10:20:50,910 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,911 - Generated link id 886.\n", - "2021-03-15 10:20:50,923 - Changed Link attributes under index: 124\n", - "2021-03-15 10:20:50,924 - Changed Link index from 124 to 886\n", - "2021-03-15 10:20:50,925 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,926 - Generated link id 887.\n", - "2021-03-15 10:20:50,936 - Changed Link attributes under index: 94\n", - "2021-03-15 10:20:50,937 - Changed Link index from 94 to 887\n", - "2021-03-15 10:20:50,940 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,941 - Generated link id 888.\n", - "2021-03-15 10:20:50,951 - Changed Link attributes under index: 226\n", - "2021-03-15 10:20:50,952 - Changed Link index from 226 to 888\n", - "2021-03-15 10:20:50,954 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,956 - Generated link id 889.\n", - "2021-03-15 10:20:50,967 - Changed Link attributes under index: 204\n", - "2021-03-15 10:20:50,968 - Changed Link index from 204 to 889\n", - "2021-03-15 10:20:50,972 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,972 - Generated link id 890.\n", - "2021-03-15 10:20:50,988 - Changed Link attributes under index: 115\n", - "2021-03-15 10:20:50,991 - Changed Link index from 115 to 890\n", - "2021-03-15 10:20:50,994 - Generated 1 link ids.\n", - "2021-03-15 10:20:50,995 - Generated link id 891.\n", - "2021-03-15 10:20:51,013 - Changed Link attributes under index: 131\n", - "2021-03-15 10:20:51,014 - Changed Link index from 131 to 891\n", - "2021-03-15 10:20:51,016 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,021 - Generated link id 892.\n", - "2021-03-15 10:20:51,055 - Changed Link attributes under index: 138\n", - "2021-03-15 10:20:51,057 - Changed Link index from 138 to 892\n", - "2021-03-15 10:20:51,061 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,061 - Generated link id 893.\n", - "2021-03-15 10:20:51,082 - Changed Link attributes under index: 194\n", - "2021-03-15 10:20:51,083 - Changed Link index from 194 to 893\n", - "2021-03-15 10:20:51,089 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,091 - Generated link id 894.\n", - "2021-03-15 10:20:51,107 - Changed Link attributes under index: 32\n", - "2021-03-15 10:20:51,108 - Changed Link index from 32 to 894\n", - "2021-03-15 10:20:51,110 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,111 - Generated link id 895.\n", - "2021-03-15 10:20:51,130 - Changed Link attributes under index: 229\n", - "2021-03-15 10:20:51,130 - Changed Link index from 229 to 895\n", - "2021-03-15 10:20:51,133 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,138 - Generated link id 896.\n", - "2021-03-15 10:20:51,155 - Changed Link attributes under index: 62\n", - "2021-03-15 10:20:51,156 - Changed Link index from 62 to 896\n", - "2021-03-15 10:20:51,160 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,160 - Generated link id 897.\n", - "2021-03-15 10:20:51,175 - Changed Link attributes under index: 59\n", - "2021-03-15 10:20:51,176 - Changed Link index from 59 to 897\n", - "2021-03-15 10:20:51,179 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,180 - Generated link id 898.\n", - "2021-03-15 10:20:51,194 - Changed Link attributes under index: 265\n", - "2021-03-15 10:20:51,195 - Changed Link index from 265 to 898\n", - "2021-03-15 10:20:51,198 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,200 - Generated link id 899.\n", - "2021-03-15 10:20:51,216 - Changed Link attributes under index: 93\n", - "2021-03-15 10:20:51,217 - Changed Link index from 93 to 899\n", - "2021-03-15 10:20:51,222 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,225 - Generated link id 900.\n", - "2021-03-15 10:20:51,238 - Changed Link attributes under index: 48\n", - "2021-03-15 10:20:51,239 - Changed Link index from 48 to 900\n", - "2021-03-15 10:20:51,242 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,243 - Generated link id 901.\n", - "2021-03-15 10:20:51,258 - Changed Link attributes under index: 140\n", - "2021-03-15 10:20:51,259 - Changed Link index from 140 to 901\n", - "2021-03-15 10:20:51,262 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,263 - Generated link id 902.\n", - "2021-03-15 10:20:51,280 - Changed Link attributes under index: 222\n", - "2021-03-15 10:20:51,284 - Changed Link index from 222 to 902\n", - "2021-03-15 10:20:51,294 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,295 - Generated link id 903.\n", - "2021-03-15 10:20:51,311 - Changed Link attributes under index: 192\n", - "2021-03-15 10:20:51,312 - Changed Link index from 192 to 903\n", - "2021-03-15 10:20:51,316 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,318 - Generated link id 904.\n", - "2021-03-15 10:20:51,346 - Changed Link attributes under index: 211\n", - "2021-03-15 10:20:51,346 - Changed Link index from 211 to 904\n", - "2021-03-15 10:20:51,358 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,360 - Generated link id 905.\n", - "2021-03-15 10:20:51,397 - Changed Link attributes under index: 200\n", - "2021-03-15 10:20:51,399 - Changed Link index from 200 to 905\n", - "2021-03-15 10:20:51,405 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,406 - Generated link id 906.\n", - "2021-03-15 10:20:51,429 - Changed Link attributes under index: 233\n", - "2021-03-15 10:20:51,431 - Changed Link index from 233 to 906\n", - "2021-03-15 10:20:51,436 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,440 - Generated link id 907.\n", - "2021-03-15 10:20:51,463 - Changed Link attributes under index: 47\n" + "2021-04-13 19:09:20,982 - Changed Link index from 193 to 870\n", + "2021-04-13 19:09:20,983 - Generated 1 link ids.\n", + "2021-04-13 19:09:20,986 - Generated link id 871.\n", + "2021-04-13 19:09:20,998 - Changed Link attributes under index: 151\n", + "2021-04-13 19:09:20,999 - Changed Link index from 151 to 871\n", + "2021-04-13 19:09:21,002 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,002 - Generated link id 872.\n", + "2021-04-13 19:09:21,014 - Changed Link attributes under index: 135\n", + "2021-04-13 19:09:21,015 - Changed Link index from 135 to 872\n", + "2021-04-13 19:09:21,017 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,019 - Generated link id 873.\n", + "2021-04-13 19:09:21,031 - Changed Link attributes under index: 45\n", + "2021-04-13 19:09:21,032 - Changed Link index from 45 to 873\n", + "2021-04-13 19:09:21,033 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,034 - Generated link id 874.\n", + "2021-04-13 19:09:21,046 - Changed Link attributes under index: 93\n", + "2021-04-13 19:09:21,047 - Changed Link index from 93 to 874\n", + "2021-04-13 19:09:21,049 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,050 - Generated link id 875.\n", + "2021-04-13 19:09:21,061 - Changed Link attributes under index: 39\n", + "2021-04-13 19:09:21,062 - Changed Link index from 39 to 875\n", + "2021-04-13 19:09:21,064 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,065 - Generated link id 876.\n", + "2021-04-13 19:09:21,081 - Changed Link attributes under index: 11\n", + "2021-04-13 19:09:21,082 - Changed Link index from 11 to 876\n", + "2021-04-13 19:09:21,085 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,086 - Generated link id 877.\n", + "2021-04-13 19:09:21,098 - Changed Link attributes under index: 1\n", + "2021-04-13 19:09:21,099 - Changed Link index from 1 to 877\n", + "2021-04-13 19:09:21,101 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,102 - Generated link id 878.\n", + "2021-04-13 19:09:21,114 - Changed Link attributes under index: 268\n", + "2021-04-13 19:09:21,114 - Changed Link index from 268 to 878\n", + "2021-04-13 19:09:21,116 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,117 - Generated link id 879.\n", + "2021-04-13 19:09:21,130 - Changed Link attributes under index: 133\n", + "2021-04-13 19:09:21,130 - Changed Link index from 133 to 879\n", + "2021-04-13 19:09:21,134 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,135 - Generated link id 880.\n", + "2021-04-13 19:09:21,148 - Changed Link attributes under index: 144\n", + "2021-04-13 19:09:21,149 - Changed Link index from 144 to 880\n", + "2021-04-13 19:09:21,151 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,152 - Generated link id 881.\n", + "2021-04-13 19:09:21,164 - Changed Link attributes under index: 148\n", + "2021-04-13 19:09:21,164 - Changed Link index from 148 to 881\n", + "2021-04-13 19:09:21,166 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,167 - Generated link id 882.\n", + "2021-04-13 19:09:21,179 - Changed Link attributes under index: 81\n", + "2021-04-13 19:09:21,180 - Changed Link index from 81 to 882\n", + "2021-04-13 19:09:21,183 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,184 - Generated link id 883.\n", + "2021-04-13 19:09:21,197 - Changed Link attributes under index: 175\n", + "2021-04-13 19:09:21,198 - Changed Link index from 175 to 883\n", + "2021-04-13 19:09:21,199 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,200 - Generated link id 884.\n", + "2021-04-13 19:09:21,212 - Changed Link attributes under index: 253\n", + "2021-04-13 19:09:21,213 - Changed Link index from 253 to 884\n", + "2021-04-13 19:09:21,215 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,216 - Generated link id 885.\n", + "2021-04-13 19:09:21,230 - Changed Link attributes under index: 202\n", + "2021-04-13 19:09:21,230 - Changed Link index from 202 to 885\n", + "2021-04-13 19:09:21,232 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,233 - Generated link id 886.\n", + "2021-04-13 19:09:21,244 - Changed Link attributes under index: 129\n", + "2021-04-13 19:09:21,245 - Changed Link index from 129 to 886\n", + "2021-04-13 19:09:21,248 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,251 - Generated link id 887.\n", + "2021-04-13 19:09:21,264 - Changed Link attributes under index: 159\n", + "2021-04-13 19:09:21,265 - Changed Link index from 159 to 887\n", + "2021-04-13 19:09:21,268 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,269 - Generated link id 888.\n", + "2021-04-13 19:09:21,282 - Changed Link attributes under index: 192\n", + "2021-04-13 19:09:21,283 - Changed Link index from 192 to 888\n", + "2021-04-13 19:09:21,285 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,287 - Generated link id 889.\n", + "2021-04-13 19:09:21,299 - Changed Link attributes under index: 10\n", + "2021-04-13 19:09:21,299 - Changed Link index from 10 to 889\n", + "2021-04-13 19:09:21,302 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,303 - Generated link id 890.\n", + "2021-04-13 19:09:21,317 - Changed Link attributes under index: 196\n", + "2021-04-13 19:09:21,318 - Changed Link index from 196 to 890\n", + "2021-04-13 19:09:21,320 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,324 - Generated link id 891.\n", + "2021-04-13 19:09:21,341 - Changed Link attributes under index: 169\n", + "2021-04-13 19:09:21,344 - Changed Link index from 169 to 891\n", + "2021-04-13 19:09:21,345 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,348 - Generated link id 892.\n", + "2021-04-13 19:09:21,358 - Changed Link attributes under index: 241\n", + "2021-04-13 19:09:21,359 - Changed Link index from 241 to 892\n", + "2021-04-13 19:09:21,362 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,362 - Generated link id 893.\n", + "2021-04-13 19:09:21,374 - Changed Link attributes under index: 158\n", + "2021-04-13 19:09:21,376 - Changed Link index from 158 to 893\n", + "2021-04-13 19:09:21,377 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,381 - Generated link id 894.\n", + "2021-04-13 19:09:21,395 - Changed Link attributes under index: 156\n", + "2021-04-13 19:09:21,396 - Changed Link index from 156 to 894\n", + "2021-04-13 19:09:21,398 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,400 - Generated link id 895.\n", + "2021-04-13 19:09:21,411 - Changed Link attributes under index: 182\n", + "2021-04-13 19:09:21,412 - Changed Link index from 182 to 895\n", + "2021-04-13 19:09:21,416 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,418 - Generated link id 896.\n", + "2021-04-13 19:09:21,432 - Changed Link attributes under index: 62\n", + "2021-04-13 19:09:21,432 - Changed Link index from 62 to 896\n", + "2021-04-13 19:09:21,436 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,437 - Generated link id 897.\n", + "2021-04-13 19:09:21,452 - Changed Link attributes under index: 227\n", + "2021-04-13 19:09:21,452 - Changed Link index from 227 to 897\n", + "2021-04-13 19:09:21,454 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,455 - Generated link id 898.\n", + "2021-04-13 19:09:21,470 - Changed Link attributes under index: 3\n", + "2021-04-13 19:09:21,472 - Changed Link index from 3 to 898\n", + "2021-04-13 19:09:21,478 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,480 - Generated link id 899.\n", + "2021-04-13 19:09:21,495 - Changed Link attributes under index: 188\n", + "2021-04-13 19:09:21,496 - Changed Link index from 188 to 899\n", + "2021-04-13 19:09:21,501 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,502 - Generated link id 900.\n", + "2021-04-13 19:09:21,512 - Changed Link attributes under index: 128\n", + "2021-04-13 19:09:21,513 - Changed Link index from 128 to 900\n", + "2021-04-13 19:09:21,517 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,518 - Generated link id 901.\n", + "2021-04-13 19:09:21,532 - Changed Link attributes under index: 101\n", + "2021-04-13 19:09:21,533 - Changed Link index from 101 to 901\n", + "2021-04-13 19:09:21,535 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,536 - Generated link id 902.\n", + "2021-04-13 19:09:21,547 - Changed Link attributes under index: 256\n", + "2021-04-13 19:09:21,548 - Changed Link index from 256 to 902\n", + "2021-04-13 19:09:21,550 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,551 - Generated link id 903.\n", + "2021-04-13 19:09:21,564 - Changed Link attributes under index: 271\n", + "2021-04-13 19:09:21,565 - Changed Link index from 271 to 903\n", + "2021-04-13 19:09:21,567 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,568 - Generated link id 904.\n", + "2021-04-13 19:09:21,580 - Changed Link attributes under index: 56\n", + "2021-04-13 19:09:21,581 - Changed Link index from 56 to 904\n", + "2021-04-13 19:09:21,582 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,583 - Generated link id 905.\n", + "2021-04-13 19:09:21,599 - Changed Link attributes under index: 25\n", + "2021-04-13 19:09:21,600 - Changed Link index from 25 to 905\n", + "2021-04-13 19:09:21,604 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,605 - Generated link id 906.\n", + "2021-04-13 19:09:21,619 - Changed Link attributes under index: 143\n", + "2021-04-13 19:09:21,620 - Changed Link index from 143 to 906\n", + "2021-04-13 19:09:21,621 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,623 - Generated link id 907.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:51,464 - Changed Link index from 47 to 907\n", - "2021-03-15 10:20:51,468 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,469 - Generated link id 908.\n", - "2021-03-15 10:20:51,483 - Changed Link attributes under index: 210\n", - "2021-03-15 10:20:51,484 - Changed Link index from 210 to 908\n", - "2021-03-15 10:20:51,490 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,491 - Generated link id 909.\n", - "2021-03-15 10:20:51,504 - Changed Link attributes under index: 56\n", - "2021-03-15 10:20:51,505 - Changed Link index from 56 to 909\n", - "2021-03-15 10:20:51,509 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,510 - Generated link id 910.\n", - "2021-03-15 10:20:51,522 - Changed Link attributes under index: 146\n", - "2021-03-15 10:20:51,524 - Changed Link index from 146 to 910\n", - "2021-03-15 10:20:51,527 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,528 - Generated link id 911.\n", - "2021-03-15 10:20:51,547 - Changed Link attributes under index: 169\n", - "2021-03-15 10:20:51,547 - Changed Link index from 169 to 911\n", - "2021-03-15 10:20:51,556 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,558 - Generated link id 912.\n", - "2021-03-15 10:20:51,571 - Changed Link attributes under index: 121\n", - "2021-03-15 10:20:51,574 - Changed Link index from 121 to 912\n", - "2021-03-15 10:20:51,577 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,578 - Generated link id 913.\n", - "2021-03-15 10:20:51,593 - Changed Link attributes under index: 12\n", - "2021-03-15 10:20:51,593 - Changed Link index from 12 to 913\n", - "2021-03-15 10:20:51,598 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,599 - Generated link id 914.\n", - "2021-03-15 10:20:51,618 - Changed Link attributes under index: 86\n", - "2021-03-15 10:20:51,621 - Changed Link index from 86 to 914\n", - "2021-03-15 10:20:51,624 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,624 - Generated link id 915.\n", - "2021-03-15 10:20:51,639 - Changed Link attributes under index: 107\n", - "2021-03-15 10:20:51,640 - Changed Link index from 107 to 915\n", - "2021-03-15 10:20:51,644 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,645 - Generated link id 916.\n", - "2021-03-15 10:20:51,664 - Changed Link attributes under index: 239\n", - "2021-03-15 10:20:51,665 - Changed Link index from 239 to 916\n", - "2021-03-15 10:20:51,674 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,675 - Generated link id 917.\n", - "2021-03-15 10:20:51,696 - Changed Link attributes under index: 69\n", - "2021-03-15 10:20:51,697 - Changed Link index from 69 to 917\n", - "2021-03-15 10:20:51,701 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,707 - Generated link id 918.\n", - "2021-03-15 10:20:51,727 - Changed Link attributes under index: 41\n", - "2021-03-15 10:20:51,730 - Changed Link index from 41 to 918\n", - "2021-03-15 10:20:51,734 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,735 - Generated link id 919.\n", - "2021-03-15 10:20:51,753 - Changed Link attributes under index: 235\n", - "2021-03-15 10:20:51,761 - Changed Link index from 235 to 919\n", - "2021-03-15 10:20:51,767 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,772 - Generated link id 920.\n", - "2021-03-15 10:20:51,792 - Changed Link attributes under index: 105\n", - "2021-03-15 10:20:51,792 - Changed Link index from 105 to 920\n", - "2021-03-15 10:20:51,795 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,797 - Generated link id 921.\n", - "2021-03-15 10:20:51,813 - Changed Link attributes under index: 220\n", - "2021-03-15 10:20:51,813 - Changed Link index from 220 to 921\n", - "2021-03-15 10:20:51,818 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,825 - Generated link id 922.\n", - "2021-03-15 10:20:51,848 - Changed Link attributes under index: 270\n", - "2021-03-15 10:20:51,849 - Changed Link index from 270 to 922\n", - "2021-03-15 10:20:51,853 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,855 - Generated link id 923.\n", - "2021-03-15 10:20:51,872 - Changed Link attributes under index: 136\n", - "2021-03-15 10:20:51,873 - Changed Link index from 136 to 923\n", - "2021-03-15 10:20:51,879 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,880 - Generated link id 924.\n", - "2021-03-15 10:20:51,895 - Changed Link attributes under index: 14\n", - "2021-03-15 10:20:51,896 - Changed Link index from 14 to 924\n", - "2021-03-15 10:20:51,901 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,904 - Generated link id 925.\n", - "2021-03-15 10:20:51,926 - Changed Link attributes under index: 234\n", - "2021-03-15 10:20:51,927 - Changed Link index from 234 to 925\n", - "2021-03-15 10:20:51,942 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,943 - Generated link id 926.\n", - "2021-03-15 10:20:51,969 - Changed Link attributes under index: 196\n", - "2021-03-15 10:20:51,970 - Changed Link index from 196 to 926\n", - "2021-03-15 10:20:51,973 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,974 - Generated link id 927.\n", - "2021-03-15 10:20:51,988 - Changed Link attributes under index: 42\n", - "2021-03-15 10:20:51,989 - Changed Link index from 42 to 927\n", - "2021-03-15 10:20:51,997 - Generated 1 link ids.\n", - "2021-03-15 10:20:51,999 - Generated link id 928.\n", - "2021-03-15 10:20:52,014 - Changed Link attributes under index: 228\n", - "2021-03-15 10:20:52,015 - Changed Link index from 228 to 928\n", - "2021-03-15 10:20:52,018 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,019 - Generated link id 929.\n", - "2021-03-15 10:20:52,048 - Changed Link attributes under index: 7\n", - "2021-03-15 10:20:52,049 - Changed Link index from 7 to 929\n", - "2021-03-15 10:20:52,053 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,054 - Generated link id 930.\n", - "2021-03-15 10:20:52,073 - Changed Link attributes under index: 91\n", - "2021-03-15 10:20:52,077 - Changed Link index from 91 to 930\n", - "2021-03-15 10:20:52,081 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,083 - Generated link id 931.\n", - "2021-03-15 10:20:52,099 - Changed Link attributes under index: 74\n", - "2021-03-15 10:20:52,099 - Changed Link index from 74 to 931\n", - "2021-03-15 10:20:52,107 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,109 - Generated link id 932.\n", - "2021-03-15 10:20:52,122 - Changed Link attributes under index: 118\n", - "2021-03-15 10:20:52,126 - Changed Link index from 118 to 932\n", - "2021-03-15 10:20:52,130 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,131 - Generated link id 933.\n", - "2021-03-15 10:20:52,147 - Changed Link attributes under index: 197\n", - "2021-03-15 10:20:52,148 - Changed Link index from 197 to 933\n", - "2021-03-15 10:20:52,155 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,156 - Generated link id 934.\n", - "2021-03-15 10:20:52,171 - Changed Link attributes under index: 240\n", - "2021-03-15 10:20:52,175 - Changed Link index from 240 to 934\n", - "2021-03-15 10:20:52,178 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,178 - Generated link id 935.\n", - "2021-03-15 10:20:52,193 - Changed Link attributes under index: 21\n", - "2021-03-15 10:20:52,194 - Changed Link index from 21 to 935\n", - "2021-03-15 10:20:52,196 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,197 - Generated link id 936.\n", - "2021-03-15 10:20:52,211 - Changed Link attributes under index: 160\n", - "2021-03-15 10:20:52,212 - Changed Link index from 160 to 936\n", - "2021-03-15 10:20:52,220 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,223 - Generated link id 937.\n", - "2021-03-15 10:20:52,239 - Changed Link attributes under index: 102\n", - "2021-03-15 10:20:52,240 - Changed Link index from 102 to 937\n", - "2021-03-15 10:20:52,242 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,243 - Generated link id 938.\n", - "2021-03-15 10:20:52,256 - Changed Link attributes under index: 150\n", - "2021-03-15 10:20:52,257 - Changed Link index from 150 to 938\n", - "2021-03-15 10:20:52,260 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,261 - Generated link id 939.\n", - "2021-03-15 10:20:52,273 - Changed Link attributes under index: 215\n", - "2021-03-15 10:20:52,273 - Changed Link index from 215 to 939\n", - "2021-03-15 10:20:52,276 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,276 - Generated link id 940.\n", - "2021-03-15 10:20:52,296 - Changed Link attributes under index: 181\n", - "2021-03-15 10:20:52,296 - Changed Link index from 181 to 940\n", - "2021-03-15 10:20:52,300 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,301 - Generated link id 941.\n", - "2021-03-15 10:20:52,315 - Changed Link attributes under index: 246\n", - "2021-03-15 10:20:52,316 - Changed Link index from 246 to 941\n", - "2021-03-15 10:20:52,318 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,319 - Generated link id 942.\n", - "2021-03-15 10:20:52,333 - Changed Link attributes under index: 271\n", - "2021-03-15 10:20:52,333 - Changed Link index from 271 to 942\n", - "2021-03-15 10:20:52,336 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,338 - Generated link id 943.\n", - "2021-03-15 10:20:52,361 - Changed Link attributes under index: 44\n", - "2021-03-15 10:20:52,362 - Changed Link index from 44 to 943\n", - "2021-03-15 10:20:52,365 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,366 - Generated link id 944.\n" + "2021-04-13 19:09:21,635 - Changed Link attributes under index: 78\n", + "2021-04-13 19:09:21,635 - Changed Link index from 78 to 907\n", + "2021-04-13 19:09:21,637 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,638 - Generated link id 908.\n", + "2021-04-13 19:09:21,649 - Changed Link attributes under index: 4\n", + "2021-04-13 19:09:21,650 - Changed Link index from 4 to 908\n", + "2021-04-13 19:09:21,652 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,653 - Generated link id 909.\n", + "2021-04-13 19:09:21,665 - Changed Link attributes under index: 157\n", + "2021-04-13 19:09:21,666 - Changed Link index from 157 to 909\n", + "2021-04-13 19:09:21,667 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,669 - Generated link id 910.\n", + "2021-04-13 19:09:21,680 - Changed Link attributes under index: 46\n", + "2021-04-13 19:09:21,681 - Changed Link index from 46 to 910\n", + "2021-04-13 19:09:21,683 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,684 - Generated link id 911.\n", + "2021-04-13 19:09:21,694 - Changed Link attributes under index: 134\n", + "2021-04-13 19:09:21,695 - Changed Link index from 134 to 911\n", + "2021-04-13 19:09:21,698 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,699 - Generated link id 912.\n", + "2021-04-13 19:09:21,710 - Changed Link attributes under index: 34\n", + "2021-04-13 19:09:21,711 - Changed Link index from 34 to 912\n", + "2021-04-13 19:09:21,713 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,713 - Generated link id 913.\n", + "2021-04-13 19:09:21,723 - Changed Link attributes under index: 270\n", + "2021-04-13 19:09:21,724 - Changed Link index from 270 to 913\n", + "2021-04-13 19:09:21,726 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,727 - Generated link id 914.\n", + "2021-04-13 19:09:21,740 - Changed Link attributes under index: 80\n", + "2021-04-13 19:09:21,740 - Changed Link index from 80 to 914\n", + "2021-04-13 19:09:21,743 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,744 - Generated link id 915.\n", + "2021-04-13 19:09:21,755 - Changed Link attributes under index: 26\n", + "2021-04-13 19:09:21,756 - Changed Link index from 26 to 915\n", + "2021-04-13 19:09:21,759 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,761 - Generated link id 916.\n", + "2021-04-13 19:09:21,773 - Changed Link attributes under index: 64\n", + "2021-04-13 19:09:21,774 - Changed Link index from 64 to 916\n", + "2021-04-13 19:09:21,776 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,777 - Generated link id 917.\n", + "2021-04-13 19:09:21,790 - Changed Link attributes under index: 237\n", + "2021-04-13 19:09:21,791 - Changed Link index from 237 to 917\n", + "2021-04-13 19:09:21,797 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,798 - Generated link id 918.\n", + "2021-04-13 19:09:21,808 - Changed Link attributes under index: 85\n", + "2021-04-13 19:09:21,811 - Changed Link index from 85 to 918\n", + "2021-04-13 19:09:21,815 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,815 - Generated link id 919.\n", + "2021-04-13 19:09:21,826 - Changed Link attributes under index: 190\n", + "2021-04-13 19:09:21,828 - Changed Link index from 190 to 919\n", + "2021-04-13 19:09:21,832 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,832 - Generated link id 920.\n", + "2021-04-13 19:09:21,844 - Changed Link attributes under index: 16\n", + "2021-04-13 19:09:21,845 - Changed Link index from 16 to 920\n", + "2021-04-13 19:09:21,847 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,848 - Generated link id 921.\n", + "2021-04-13 19:09:21,859 - Changed Link attributes under index: 215\n", + "2021-04-13 19:09:21,860 - Changed Link index from 215 to 921\n", + "2021-04-13 19:09:21,864 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,865 - Generated link id 922.\n", + "2021-04-13 19:09:21,875 - Changed Link attributes under index: 122\n", + "2021-04-13 19:09:21,877 - Changed Link index from 122 to 922\n", + "2021-04-13 19:09:21,879 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,880 - Generated link id 923.\n", + "2021-04-13 19:09:21,891 - Changed Link attributes under index: 71\n", + "2021-04-13 19:09:21,892 - Changed Link index from 71 to 923\n", + "2021-04-13 19:09:21,897 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,898 - Generated link id 924.\n", + "2021-04-13 19:09:21,911 - Changed Link attributes under index: 20\n", + "2021-04-13 19:09:21,913 - Changed Link index from 20 to 924\n", + "2021-04-13 19:09:21,916 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,917 - Generated link id 925.\n", + "2021-04-13 19:09:21,929 - Changed Link attributes under index: 153\n", + "2021-04-13 19:09:21,930 - Changed Link index from 153 to 925\n", + "2021-04-13 19:09:21,932 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,932 - Generated link id 926.\n", + "2021-04-13 19:09:21,943 - Changed Link attributes under index: 191\n", + "2021-04-13 19:09:21,944 - Changed Link index from 191 to 926\n", + "2021-04-13 19:09:21,947 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,948 - Generated link id 927.\n", + "2021-04-13 19:09:21,958 - Changed Link attributes under index: 244\n", + "2021-04-13 19:09:21,960 - Changed Link index from 244 to 927\n", + "2021-04-13 19:09:21,968 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,970 - Generated link id 928.\n", + "2021-04-13 19:09:21,982 - Changed Link attributes under index: 37\n", + "2021-04-13 19:09:21,983 - Changed Link index from 37 to 928\n", + "2021-04-13 19:09:21,986 - Generated 1 link ids.\n", + "2021-04-13 19:09:21,987 - Generated link id 929.\n", + "2021-04-13 19:09:21,997 - Changed Link attributes under index: 13\n", + "2021-04-13 19:09:21,998 - Changed Link index from 13 to 929\n", + "2021-04-13 19:09:22,000 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,001 - Generated link id 930.\n", + "2021-04-13 19:09:22,012 - Changed Link attributes under index: 214\n", + "2021-04-13 19:09:22,013 - Changed Link index from 214 to 930\n", + "2021-04-13 19:09:22,016 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,017 - Generated link id 931.\n", + "2021-04-13 19:09:22,030 - Changed Link attributes under index: 72\n", + "2021-04-13 19:09:22,031 - Changed Link index from 72 to 931\n", + "2021-04-13 19:09:22,033 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,043 - Generated link id 932.\n", + "2021-04-13 19:09:22,060 - Changed Link attributes under index: 21\n", + "2021-04-13 19:09:22,060 - Changed Link index from 21 to 932\n", + "2021-04-13 19:09:22,063 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,065 - Generated link id 933.\n", + "2021-04-13 19:09:22,075 - Changed Link attributes under index: 48\n", + "2021-04-13 19:09:22,078 - Changed Link index from 48 to 933\n", + "2021-04-13 19:09:22,079 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,082 - Generated link id 934.\n", + "2021-04-13 19:09:22,095 - Changed Link attributes under index: 152\n", + "2021-04-13 19:09:22,095 - Changed Link index from 152 to 934\n", + "2021-04-13 19:09:22,098 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,099 - Generated link id 935.\n", + "2021-04-13 19:09:22,113 - Changed Link attributes under index: 234\n", + "2021-04-13 19:09:22,115 - Changed Link index from 234 to 935\n", + "2021-04-13 19:09:22,117 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,119 - Generated link id 936.\n", + "2021-04-13 19:09:22,131 - Changed Link attributes under index: 166\n", + "2021-04-13 19:09:22,132 - Changed Link index from 166 to 936\n", + "2021-04-13 19:09:22,137 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,137 - Generated link id 937.\n", + "2021-04-13 19:09:22,152 - Changed Link attributes under index: 163\n", + "2021-04-13 19:09:22,153 - Changed Link index from 163 to 937\n", + "2021-04-13 19:09:22,155 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,156 - Generated link id 938.\n", + "2021-04-13 19:09:22,171 - Changed Link attributes under index: 130\n", + "2021-04-13 19:09:22,171 - Changed Link index from 130 to 938\n", + "2021-04-13 19:09:22,173 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,174 - Generated link id 939.\n", + "2021-04-13 19:09:22,191 - Changed Link attributes under index: 264\n", + "2021-04-13 19:09:22,192 - Changed Link index from 264 to 939\n", + "2021-04-13 19:09:22,196 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,196 - Generated link id 940.\n", + "2021-04-13 19:09:22,209 - Changed Link attributes under index: 257\n", + "2021-04-13 19:09:22,210 - Changed Link index from 257 to 940\n", + "2021-04-13 19:09:22,214 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,214 - Generated link id 941.\n", + "2021-04-13 19:09:22,227 - Changed Link attributes under index: 177\n", + "2021-04-13 19:09:22,227 - Changed Link index from 177 to 941\n", + "2021-04-13 19:09:22,230 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,233 - Generated link id 942.\n", + "2021-04-13 19:09:22,243 - Changed Link attributes under index: 127\n", + "2021-04-13 19:09:22,244 - Changed Link index from 127 to 942\n", + "2021-04-13 19:09:22,247 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,249 - Generated link id 943.\n", + "2021-04-13 19:09:22,259 - Changed Link attributes under index: 5\n", + "2021-04-13 19:09:22,260 - Changed Link index from 5 to 943\n", + "2021-04-13 19:09:22,267 - Generated 1 link ids.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:52,388 - Changed Link attributes under index: 71\n", - "2021-03-15 10:20:52,392 - Changed Link index from 71 to 944\n", - "2021-03-15 10:20:52,394 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,395 - Generated link id 945.\n", - "2021-03-15 10:20:52,408 - Changed Link attributes under index: 90\n", - "2021-03-15 10:20:52,409 - Changed Link index from 90 to 945\n", - "2021-03-15 10:20:52,411 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,412 - Generated link id 946.\n", - "2021-03-15 10:20:52,426 - Changed Link attributes under index: 116\n", - "2021-03-15 10:20:52,427 - Changed Link index from 116 to 946\n", - "2021-03-15 10:20:52,430 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,431 - Generated link id 947.\n", - "2021-03-15 10:20:52,446 - Changed Link attributes under index: 159\n", - "2021-03-15 10:20:52,447 - Changed Link index from 159 to 947\n", - "2021-03-15 10:20:52,452 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,455 - Generated link id 948.\n", - "2021-03-15 10:20:52,475 - Changed Link attributes under index: 85\n", - "2021-03-15 10:20:52,475 - Changed Link index from 85 to 948\n", - "2021-03-15 10:20:52,478 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,479 - Generated link id 949.\n", - "2021-03-15 10:20:52,493 - Changed Link attributes under index: 272\n", - "2021-03-15 10:20:52,493 - Changed Link index from 272 to 949\n", - "2021-03-15 10:20:52,496 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,497 - Generated link id 950.\n", - "2021-03-15 10:20:52,509 - Changed Link attributes under index: 148\n", - "2021-03-15 10:20:52,510 - Changed Link index from 148 to 950\n", - "2021-03-15 10:20:52,513 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,513 - Generated link id 951.\n", - "2021-03-15 10:20:52,525 - Changed Link attributes under index: 46\n", - "2021-03-15 10:20:52,526 - Changed Link index from 46 to 951\n", - "2021-03-15 10:20:52,529 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,531 - Generated link id 952.\n", - "2021-03-15 10:20:52,544 - Changed Link attributes under index: 122\n", - "2021-03-15 10:20:52,545 - Changed Link index from 122 to 952\n", - "2021-03-15 10:20:52,548 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,548 - Generated link id 953.\n", - "2021-03-15 10:20:52,561 - Changed Link attributes under index: 269\n", - "2021-03-15 10:20:52,561 - Changed Link index from 269 to 953\n", - "2021-03-15 10:20:52,565 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,565 - Generated link id 954.\n", - "2021-03-15 10:20:52,576 - Changed Link attributes under index: 17\n", - "2021-03-15 10:20:52,577 - Changed Link index from 17 to 954\n", - "2021-03-15 10:20:52,579 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,580 - Generated link id 955.\n", - "2021-03-15 10:20:52,591 - Changed Link attributes under index: 224\n", - "2021-03-15 10:20:52,593 - Changed Link index from 224 to 955\n", - "2021-03-15 10:20:52,595 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,595 - Generated link id 956.\n", - "2021-03-15 10:20:52,606 - Changed Link attributes under index: 18\n", - "2021-03-15 10:20:52,607 - Changed Link index from 18 to 956\n", - "2021-03-15 10:20:52,609 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,610 - Generated link id 957.\n", - "2021-03-15 10:20:52,620 - Changed Link attributes under index: 164\n", - "2021-03-15 10:20:52,622 - Changed Link index from 164 to 957\n", - "2021-03-15 10:20:52,627 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,628 - Generated link id 958.\n", - "2021-03-15 10:20:52,639 - Changed Link attributes under index: 249\n", - "2021-03-15 10:20:52,640 - Changed Link index from 249 to 958\n", - "2021-03-15 10:20:52,642 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,643 - Generated link id 959.\n", - "2021-03-15 10:20:52,653 - Changed Link attributes under index: 13\n", - "2021-03-15 10:20:52,653 - Changed Link index from 13 to 959\n", - "2021-03-15 10:20:52,657 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,658 - Generated link id 960.\n", - "2021-03-15 10:20:52,668 - Changed Link attributes under index: 242\n", - "2021-03-15 10:20:52,668 - Changed Link index from 242 to 960\n", - "2021-03-15 10:20:52,672 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,673 - Generated link id 961.\n", - "2021-03-15 10:20:52,684 - Changed Link attributes under index: 178\n", - "2021-03-15 10:20:52,684 - Changed Link index from 178 to 961\n", - "2021-03-15 10:20:52,688 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,688 - Generated link id 962.\n", - "2021-03-15 10:20:52,701 - Changed Link attributes under index: 20\n", - "2021-03-15 10:20:52,701 - Changed Link index from 20 to 962\n", - "2021-03-15 10:20:52,707 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,707 - Generated link id 963.\n", - "2021-03-15 10:20:52,718 - Changed Link attributes under index: 3\n", - "2021-03-15 10:20:52,726 - Changed Link index from 3 to 963\n", - "2021-03-15 10:20:52,731 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,731 - Generated link id 964.\n", - "2021-03-15 10:20:52,743 - Changed Link attributes under index: 79\n", - "2021-03-15 10:20:52,744 - Changed Link index from 79 to 964\n", - "2021-03-15 10:20:52,746 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,747 - Generated link id 965.\n", - "2021-03-15 10:20:52,759 - Changed Link attributes under index: 165\n", - "2021-03-15 10:20:52,760 - Changed Link index from 165 to 965\n", - "2021-03-15 10:20:52,762 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,762 - Generated link id 966.\n", - "2021-03-15 10:20:52,776 - Changed Link attributes under index: 174\n", - "2021-03-15 10:20:52,776 - Changed Link index from 174 to 966\n", - "2021-03-15 10:20:52,779 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,779 - Generated link id 967.\n", - "2021-03-15 10:20:52,794 - Changed Link attributes under index: 254\n", - "2021-03-15 10:20:52,794 - Changed Link index from 254 to 967\n", - "2021-03-15 10:20:52,796 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,797 - Generated link id 968.\n", - "2021-03-15 10:20:52,815 - Changed Link attributes under index: 212\n", - "2021-03-15 10:20:52,816 - Changed Link index from 212 to 968\n", - "2021-03-15 10:20:52,819 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,821 - Generated link id 969.\n", - "2021-03-15 10:20:52,833 - Changed Link attributes under index: 267\n", - "2021-03-15 10:20:52,834 - Changed Link index from 267 to 969\n", - "2021-03-15 10:20:52,838 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,838 - Generated link id 970.\n", - "2021-03-15 10:20:52,855 - Changed Link attributes under index: 113\n", - "2021-03-15 10:20:52,857 - Changed Link index from 113 to 970\n", - "2021-03-15 10:20:52,861 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,862 - Generated link id 971.\n", - "2021-03-15 10:20:52,873 - Changed Link attributes under index: 0\n", - "2021-03-15 10:20:52,875 - Changed Link index from 0 to 971\n", - "2021-03-15 10:20:52,879 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,879 - Generated link id 972.\n", - "2021-03-15 10:20:52,892 - Changed Link attributes under index: 182\n", - "2021-03-15 10:20:52,893 - Changed Link index from 182 to 972\n", - "2021-03-15 10:20:52,895 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,896 - Generated link id 973.\n", - "2021-03-15 10:20:52,912 - Changed Link attributes under index: 158\n", - "2021-03-15 10:20:52,913 - Changed Link index from 158 to 973\n", - "2021-03-15 10:20:52,915 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,917 - Generated link id 974.\n", - "2021-03-15 10:20:52,930 - Changed Link attributes under index: 230\n", - "2021-03-15 10:20:52,931 - Changed Link index from 230 to 974\n", - "2021-03-15 10:20:52,934 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,934 - Generated link id 975.\n", - "2021-03-15 10:20:52,946 - Changed Link attributes under index: 95\n", - "2021-03-15 10:20:52,947 - Changed Link index from 95 to 975\n", - "2021-03-15 10:20:52,950 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,950 - Generated link id 976.\n", - "2021-03-15 10:20:52,964 - Changed Link attributes under index: 84\n", - "2021-03-15 10:20:52,964 - Changed Link index from 84 to 976\n", - "2021-03-15 10:20:52,967 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,968 - Generated link id 977.\n", - "2021-03-15 10:20:52,980 - Changed Link attributes under index: 70\n", - "2021-03-15 10:20:52,981 - Changed Link index from 70 to 977\n", - "2021-03-15 10:20:52,983 - Generated 1 link ids.\n", - "2021-03-15 10:20:52,984 - Generated link id 978.\n", - "2021-03-15 10:20:52,998 - Changed Link attributes under index: 50\n", - "2021-03-15 10:20:52,999 - Changed Link index from 50 to 978\n", - "2021-03-15 10:20:53,000 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,002 - Generated link id 979.\n", - "2021-03-15 10:20:53,013 - Changed Link attributes under index: 214\n", - "2021-03-15 10:20:53,014 - Changed Link index from 214 to 979\n", - "2021-03-15 10:20:53,018 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,018 - Generated link id 980.\n", - "2021-03-15 10:20:53,030 - Changed Link attributes under index: 236\n", - "2021-03-15 10:20:53,031 - Changed Link index from 236 to 980\n" + "2021-04-13 19:09:22,269 - Generated link id 944.\n", + "2021-04-13 19:09:22,279 - Changed Link attributes under index: 206\n", + "2021-04-13 19:09:22,280 - Changed Link index from 206 to 944\n", + "2021-04-13 19:09:22,284 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,284 - Generated link id 945.\n", + "2021-04-13 19:09:22,297 - Changed Link attributes under index: 219\n", + "2021-04-13 19:09:22,298 - Changed Link index from 219 to 945\n", + "2021-04-13 19:09:22,299 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,300 - Generated link id 946.\n", + "2021-04-13 19:09:22,311 - Changed Link attributes under index: 74\n", + "2021-04-13 19:09:22,312 - Changed Link index from 74 to 946\n", + "2021-04-13 19:09:22,316 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,317 - Generated link id 947.\n", + "2021-04-13 19:09:22,333 - Changed Link attributes under index: 232\n", + "2021-04-13 19:09:22,333 - Changed Link index from 232 to 947\n", + "2021-04-13 19:09:22,336 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,337 - Generated link id 948.\n", + "2021-04-13 19:09:22,349 - Changed Link attributes under index: 9\n", + "2021-04-13 19:09:22,350 - Changed Link index from 9 to 948\n", + "2021-04-13 19:09:22,351 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,352 - Generated link id 949.\n", + "2021-04-13 19:09:22,366 - Changed Link attributes under index: 104\n", + "2021-04-13 19:09:22,367 - Changed Link index from 104 to 949\n", + "2021-04-13 19:09:22,369 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,370 - Generated link id 950.\n", + "2021-04-13 19:09:22,382 - Changed Link attributes under index: 251\n", + "2021-04-13 19:09:22,383 - Changed Link index from 251 to 950\n", + "2021-04-13 19:09:22,385 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,386 - Generated link id 951.\n", + "2021-04-13 19:09:22,398 - Changed Link attributes under index: 49\n", + "2021-04-13 19:09:22,399 - Changed Link index from 49 to 951\n", + "2021-04-13 19:09:22,401 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,402 - Generated link id 952.\n", + "2021-04-13 19:09:22,416 - Changed Link attributes under index: 164\n", + "2021-04-13 19:09:22,416 - Changed Link index from 164 to 952\n", + "2021-04-13 19:09:22,418 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,420 - Generated link id 953.\n", + "2021-04-13 19:09:22,438 - Changed Link attributes under index: 75\n", + "2021-04-13 19:09:22,439 - Changed Link index from 75 to 953\n", + "2021-04-13 19:09:22,441 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,442 - Generated link id 954.\n", + "2021-04-13 19:09:22,455 - Changed Link attributes under index: 149\n", + "2021-04-13 19:09:22,456 - Changed Link index from 149 to 954\n", + "2021-04-13 19:09:22,458 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,460 - Generated link id 955.\n", + "2021-04-13 19:09:22,472 - Changed Link attributes under index: 154\n", + "2021-04-13 19:09:22,473 - Changed Link index from 154 to 955\n", + "2021-04-13 19:09:22,474 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,475 - Generated link id 956.\n", + "2021-04-13 19:09:22,488 - Changed Link attributes under index: 207\n", + "2021-04-13 19:09:22,489 - Changed Link index from 207 to 956\n", + "2021-04-13 19:09:22,491 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,492 - Generated link id 957.\n", + "2021-04-13 19:09:22,506 - Changed Link attributes under index: 261\n", + "2021-04-13 19:09:22,507 - Changed Link index from 261 to 957\n", + "2021-04-13 19:09:22,509 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,512 - Generated link id 958.\n", + "2021-04-13 19:09:22,522 - Changed Link attributes under index: 50\n", + "2021-04-13 19:09:22,523 - Changed Link index from 50 to 958\n", + "2021-04-13 19:09:22,524 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,525 - Generated link id 959.\n", + "2021-04-13 19:09:22,540 - Changed Link attributes under index: 184\n", + "2021-04-13 19:09:22,541 - Changed Link index from 184 to 959\n", + "2021-04-13 19:09:22,545 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,546 - Generated link id 960.\n", + "2021-04-13 19:09:22,557 - Changed Link attributes under index: 209\n", + "2021-04-13 19:09:22,558 - Changed Link index from 209 to 960\n", + "2021-04-13 19:09:22,561 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,562 - Generated link id 961.\n", + "2021-04-13 19:09:22,574 - Changed Link attributes under index: 171\n", + "2021-04-13 19:09:22,574 - Changed Link index from 171 to 961\n", + "2021-04-13 19:09:22,578 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,578 - Generated link id 962.\n", + "2021-04-13 19:09:22,590 - Changed Link attributes under index: 42\n", + "2021-04-13 19:09:22,591 - Changed Link index from 42 to 962\n", + "2021-04-13 19:09:22,594 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,595 - Generated link id 963.\n", + "2021-04-13 19:09:22,617 - Changed Link attributes under index: 90\n", + "2021-04-13 19:09:22,618 - Changed Link index from 90 to 963\n", + "2021-04-13 19:09:22,620 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,621 - Generated link id 964.\n", + "2021-04-13 19:09:22,633 - Changed Link attributes under index: 140\n", + "2021-04-13 19:09:22,634 - Changed Link index from 140 to 964\n", + "2021-04-13 19:09:22,636 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,637 - Generated link id 965.\n", + "2021-04-13 19:09:22,649 - Changed Link attributes under index: 6\n", + "2021-04-13 19:09:22,650 - Changed Link index from 6 to 965\n", + "2021-04-13 19:09:22,653 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,654 - Generated link id 966.\n", + "2021-04-13 19:09:22,668 - Changed Link attributes under index: 199\n", + "2021-04-13 19:09:22,669 - Changed Link index from 199 to 966\n", + "2021-04-13 19:09:22,671 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,673 - Generated link id 967.\n", + "2021-04-13 19:09:22,685 - Changed Link attributes under index: 121\n", + "2021-04-13 19:09:22,685 - Changed Link index from 121 to 967\n", + "2021-04-13 19:09:22,688 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,689 - Generated link id 968.\n", + "2021-04-13 19:09:22,701 - Changed Link attributes under index: 160\n", + "2021-04-13 19:09:22,702 - Changed Link index from 160 to 968\n", + "2021-04-13 19:09:22,704 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,706 - Generated link id 969.\n", + "2021-04-13 19:09:22,717 - Changed Link attributes under index: 14\n", + "2021-04-13 19:09:22,718 - Changed Link index from 14 to 969\n", + "2021-04-13 19:09:22,720 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,721 - Generated link id 970.\n", + "2021-04-13 19:09:22,737 - Changed Link attributes under index: 173\n", + "2021-04-13 19:09:22,738 - Changed Link index from 173 to 970\n", + "2021-04-13 19:09:22,739 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,740 - Generated link id 971.\n", + "2021-04-13 19:09:22,764 - Changed Link attributes under index: 142\n", + "2021-04-13 19:09:22,765 - Changed Link index from 142 to 971\n", + "2021-04-13 19:09:22,769 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,770 - Generated link id 972.\n", + "2021-04-13 19:09:22,784 - Changed Link attributes under index: 89\n", + "2021-04-13 19:09:22,785 - Changed Link index from 89 to 972\n", + "2021-04-13 19:09:22,788 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,788 - Generated link id 973.\n", + "2021-04-13 19:09:22,801 - Changed Link attributes under index: 120\n", + "2021-04-13 19:09:22,802 - Changed Link index from 120 to 973\n", + "2021-04-13 19:09:22,804 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,805 - Generated link id 974.\n", + "2021-04-13 19:09:22,819 - Changed Link attributes under index: 105\n", + "2021-04-13 19:09:22,819 - Changed Link index from 105 to 974\n", + "2021-04-13 19:09:22,821 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,822 - Generated link id 975.\n", + "2021-04-13 19:09:22,835 - Changed Link attributes under index: 224\n", + "2021-04-13 19:09:22,836 - Changed Link index from 224 to 975\n", + "2021-04-13 19:09:22,839 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,839 - Generated link id 976.\n", + "2021-04-13 19:09:22,851 - Changed Link attributes under index: 138\n", + "2021-04-13 19:09:22,852 - Changed Link index from 138 to 976\n", + "2021-04-13 19:09:22,856 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,858 - Generated link id 977.\n", + "2021-04-13 19:09:22,872 - Changed Link attributes under index: 185\n", + "2021-04-13 19:09:22,872 - Changed Link index from 185 to 977\n", + "2021-04-13 19:09:22,874 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,875 - Generated link id 978.\n", + "2021-04-13 19:09:22,889 - Changed Link attributes under index: 211\n", + "2021-04-13 19:09:22,890 - Changed Link index from 211 to 978\n", + "2021-04-13 19:09:22,892 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,894 - Generated link id 979.\n", + "2021-04-13 19:09:22,905 - Changed Link attributes under index: 239\n", + "2021-04-13 19:09:22,906 - Changed Link index from 239 to 979\n", + "2021-04-13 19:09:22,908 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,908 - Generated link id 980.\n", + "2021-04-13 19:09:22,922 - Changed Link attributes under index: 51\n", + "2021-04-13 19:09:22,923 - Changed Link index from 51 to 980\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2021-03-15 10:20:53,032 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,035 - Generated link id 981.\n", - "2021-03-15 10:20:53,049 - Changed Link attributes under index: 172\n", - "2021-03-15 10:20:53,049 - Changed Link index from 172 to 981\n", - "2021-03-15 10:20:53,052 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,054 - Generated link id 982.\n", - "2021-03-15 10:20:53,066 - Changed Link attributes under index: 227\n", - "2021-03-15 10:20:53,066 - Changed Link index from 227 to 982\n", - "2021-03-15 10:20:53,068 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,069 - Generated link id 983.\n", - "2021-03-15 10:20:53,081 - Changed Link attributes under index: 238\n", - "2021-03-15 10:20:53,081 - Changed Link index from 238 to 983\n", - "2021-03-15 10:20:53,084 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,085 - Generated link id 984.\n", - "2021-03-15 10:20:53,096 - Changed Link attributes under index: 213\n", - "2021-03-15 10:20:53,097 - Changed Link index from 213 to 984\n", - "2021-03-15 10:20:53,101 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,101 - Generated link id 985.\n", - "2021-03-15 10:20:53,112 - Changed Link attributes under index: 92\n", - "2021-03-15 10:20:53,113 - Changed Link index from 92 to 985\n", - "2021-03-15 10:20:53,116 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,117 - Generated link id 986.\n", - "2021-03-15 10:20:53,128 - Changed Link attributes under index: 104\n", - "2021-03-15 10:20:53,129 - Changed Link index from 104 to 986\n", - "2021-03-15 10:20:53,130 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,133 - Generated link id 987.\n", - "2021-03-15 10:20:53,146 - Changed Link attributes under index: 125\n", - "2021-03-15 10:20:53,147 - Changed Link index from 125 to 987\n", - "2021-03-15 10:20:53,149 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,149 - Generated link id 988.\n", - "2021-03-15 10:20:53,162 - Changed Link attributes under index: 253\n", - "2021-03-15 10:20:53,162 - Changed Link index from 253 to 988\n", - "2021-03-15 10:20:53,164 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,166 - Generated link id 989.\n", - "2021-03-15 10:20:53,178 - Changed Link attributes under index: 171\n", - "2021-03-15 10:20:53,178 - Changed Link index from 171 to 989\n", - "2021-03-15 10:20:53,180 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,189 - Generated link id 990.\n", - "2021-03-15 10:20:53,201 - Changed Link attributes under index: 73\n", - "2021-03-15 10:20:53,202 - Changed Link index from 73 to 990\n", - "2021-03-15 10:20:53,205 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,208 - Generated link id 991.\n", - "2021-03-15 10:20:53,218 - Changed Link attributes under index: 162\n", - "2021-03-15 10:20:53,219 - Changed Link index from 162 to 991\n", - "2021-03-15 10:20:53,222 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,223 - Generated link id 992.\n", - "2021-03-15 10:20:53,234 - Changed Link attributes under index: 80\n", - "2021-03-15 10:20:53,237 - Changed Link index from 80 to 992\n", - "2021-03-15 10:20:53,239 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,240 - Generated link id 993.\n", - "2021-03-15 10:20:53,251 - Changed Link attributes under index: 176\n", - "2021-03-15 10:20:53,252 - Changed Link index from 176 to 993\n", - "2021-03-15 10:20:53,257 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,259 - Generated link id 994.\n", - "2021-03-15 10:20:53,269 - Changed Link attributes under index: 251\n", - "2021-03-15 10:20:53,272 - Changed Link index from 251 to 994\n", - "2021-03-15 10:20:53,275 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,277 - Generated link id 995.\n", - "2021-03-15 10:20:53,290 - Changed Link attributes under index: 183\n", - "2021-03-15 10:20:53,291 - Changed Link index from 183 to 995\n", - "2021-03-15 10:20:53,295 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,296 - Generated link id 996.\n", - "2021-03-15 10:20:53,309 - Changed Link attributes under index: 135\n", - "2021-03-15 10:20:53,309 - Changed Link index from 135 to 996\n", - "2021-03-15 10:20:53,312 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,314 - Generated link id 997.\n", - "2021-03-15 10:20:53,326 - Changed Link attributes under index: 22\n", - "2021-03-15 10:20:53,327 - Changed Link index from 22 to 997\n", - "2021-03-15 10:20:53,329 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,330 - Generated link id 998.\n", - "2021-03-15 10:20:53,341 - Changed Link attributes under index: 264\n", - "2021-03-15 10:20:53,341 - Changed Link index from 264 to 998\n", - "2021-03-15 10:20:53,343 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,344 - Generated link id 999.\n", - "2021-03-15 10:20:53,355 - Changed Link attributes under index: 179\n", - "2021-03-15 10:20:53,356 - Changed Link index from 179 to 999\n", - "2021-03-15 10:20:53,359 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,360 - Generated link id 1000.\n", - "2021-03-15 10:20:53,370 - Changed Link attributes under index: 232\n", - "2021-03-15 10:20:53,371 - Changed Link index from 232 to 1000\n", - "2021-03-15 10:20:53,374 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,375 - Generated link id 1001.\n", - "2021-03-15 10:20:53,386 - Changed Link attributes under index: 207\n", - "2021-03-15 10:20:53,387 - Changed Link index from 207 to 1001\n", - "2021-03-15 10:20:53,390 - Generated 1 link ids.\n", - "2021-03-15 10:20:53,391 - Generated link id 1002.\n", - "2021-03-15 10:20:53,401 - Changed Link attributes under index: 247\n", - "2021-03-15 10:20:53,401 - Changed Link index from 247 to 1002\n", - "2021-03-15 10:20:53,680 - Finished consolidating link indexing between the two graphs\n", - "2021-03-15 10:20:53,693 - The following vehicle types clash: {'ferry', 'tram', 'rail', 'subway', 'bus', 'funicular', 'gondola', 'cablecar'}\n", - "2021-03-15 10:20:53,694 - Overwrite is on. Vehicle types listed above will be overwritten.\n" + "2021-04-13 19:09:22,925 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,925 - Generated link id 981.\n", + "2021-04-13 19:09:22,938 - Changed Link attributes under index: 73\n", + "2021-04-13 19:09:22,939 - Changed Link index from 73 to 981\n", + "2021-04-13 19:09:22,940 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,941 - Generated link id 982.\n", + "2021-04-13 19:09:22,953 - Changed Link attributes under index: 131\n", + "2021-04-13 19:09:22,954 - Changed Link index from 131 to 982\n", + "2021-04-13 19:09:22,956 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,957 - Generated link id 983.\n", + "2021-04-13 19:09:22,970 - Changed Link attributes under index: 29\n", + "2021-04-13 19:09:22,971 - Changed Link index from 29 to 983\n", + "2021-04-13 19:09:22,972 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,974 - Generated link id 984.\n", + "2021-04-13 19:09:22,986 - Changed Link attributes under index: 189\n", + "2021-04-13 19:09:22,986 - Changed Link index from 189 to 984\n", + "2021-04-13 19:09:22,989 - Generated 1 link ids.\n", + "2021-04-13 19:09:22,990 - Generated link id 985.\n", + "2021-04-13 19:09:23,001 - Changed Link attributes under index: 260\n", + "2021-04-13 19:09:23,003 - Changed Link index from 260 to 985\n", + "2021-04-13 19:09:23,006 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,007 - Generated link id 986.\n", + "2021-04-13 19:09:23,021 - Changed Link attributes under index: 47\n", + "2021-04-13 19:09:23,022 - Changed Link index from 47 to 986\n", + "2021-04-13 19:09:23,024 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,025 - Generated link id 987.\n", + "2021-04-13 19:09:23,040 - Changed Link attributes under index: 204\n", + "2021-04-13 19:09:23,041 - Changed Link index from 204 to 987\n", + "2021-04-13 19:09:23,049 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,049 - Generated link id 988.\n", + "2021-04-13 19:09:23,063 - Changed Link attributes under index: 221\n", + "2021-04-13 19:09:23,064 - Changed Link index from 221 to 988\n", + "2021-04-13 19:09:23,066 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,068 - Generated link id 989.\n", + "2021-04-13 19:09:23,081 - Changed Link attributes under index: 229\n", + "2021-04-13 19:09:23,082 - Changed Link index from 229 to 989\n", + "2021-04-13 19:09:23,085 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,086 - Generated link id 990.\n", + "2021-04-13 19:09:23,098 - Changed Link attributes under index: 87\n", + "2021-04-13 19:09:23,098 - Changed Link index from 87 to 990\n", + "2021-04-13 19:09:23,100 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,102 - Generated link id 991.\n", + "2021-04-13 19:09:23,116 - Changed Link attributes under index: 203\n", + "2021-04-13 19:09:23,117 - Changed Link index from 203 to 991\n", + "2021-04-13 19:09:23,120 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,122 - Generated link id 992.\n", + "2021-04-13 19:09:23,134 - Changed Link attributes under index: 23\n", + "2021-04-13 19:09:23,135 - Changed Link index from 23 to 992\n", + "2021-04-13 19:09:23,138 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,139 - Generated link id 993.\n", + "2021-04-13 19:09:23,152 - Changed Link attributes under index: 248\n", + "2021-04-13 19:09:23,152 - Changed Link index from 248 to 993\n", + "2021-04-13 19:09:23,154 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,156 - Generated link id 994.\n", + "2021-04-13 19:09:23,168 - Changed Link attributes under index: 17\n", + "2021-04-13 19:09:23,169 - Changed Link index from 17 to 994\n", + "2021-04-13 19:09:23,172 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,173 - Generated link id 995.\n", + "2021-04-13 19:09:23,185 - Changed Link attributes under index: 123\n", + "2021-04-13 19:09:23,186 - Changed Link index from 123 to 995\n", + "2021-04-13 19:09:23,187 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,189 - Generated link id 996.\n", + "2021-04-13 19:09:23,202 - Changed Link attributes under index: 231\n", + "2021-04-13 19:09:23,203 - Changed Link index from 231 to 996\n", + "2021-04-13 19:09:23,207 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,208 - Generated link id 997.\n", + "2021-04-13 19:09:23,220 - Changed Link attributes under index: 0\n", + "2021-04-13 19:09:23,221 - Changed Link index from 0 to 997\n", + "2021-04-13 19:09:23,224 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,225 - Generated link id 998.\n", + "2021-04-13 19:09:23,239 - Changed Link attributes under index: 249\n", + "2021-04-13 19:09:23,239 - Changed Link index from 249 to 998\n", + "2021-04-13 19:09:23,242 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,244 - Generated link id 999.\n", + "2021-04-13 19:09:23,256 - Changed Link attributes under index: 41\n", + "2021-04-13 19:09:23,256 - Changed Link index from 41 to 999\n", + "2021-04-13 19:09:23,258 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,259 - Generated link id 1000.\n", + "2021-04-13 19:09:23,272 - Changed Link attributes under index: 223\n", + "2021-04-13 19:09:23,272 - Changed Link index from 223 to 1000\n", + "2021-04-13 19:09:23,274 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,275 - Generated link id 1001.\n", + "2021-04-13 19:09:23,288 - Changed Link attributes under index: 118\n", + "2021-04-13 19:09:23,289 - Changed Link index from 118 to 1001\n", + "2021-04-13 19:09:23,290 - Generated 1 link ids.\n", + "2021-04-13 19:09:23,291 - Generated link id 1002.\n", + "2021-04-13 19:09:23,306 - Changed Link attributes under index: 176\n", + "2021-04-13 19:09:23,307 - Changed Link index from 176 to 1002\n", + "2021-04-13 19:09:23,610 - Finished consolidating link indexing between the two graphs\n", + "2021-04-13 19:09:23,621 - The following vehicle types clash: {'subway', 'cablecar', 'rail', 'ferry', 'bus', 'tram', 'gondola', 'funicular'}\n", + "2021-04-13 19:09:23,622 - Overwrite is on. Vehicle types listed above will be overwritten.\n" ] } ], @@ -1111,18 +1105,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2021-03-15T10:20:53.727481Z", - "start_time": "2021-03-15T10:20:53.716454Z" + "end_time": "2021-04-13T18:09:23.654885Z", + "start_time": "2021-04-13T18:09:23.647410Z" } }, "outputs": [ { "data": { "text/plain": [ - ":' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -1176,10 +1172,10 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -1187,46 +1183,11 @@ "source": [ "_n.plot()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, diff --git a/notebooks/6.1. Validating Network - MATSim Specific.ipynb b/notebooks/6.1. Validating Network - MATSim Specific.ipynb index faca9c89..2663e72c 100644 --- a/notebooks/6.1. Validating Network - MATSim Specific.ipynb +++ b/notebooks/6.1. Validating Network - MATSim Specific.ipynb @@ -14,8 +14,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.212883Z", - "start_time": "2020-12-17T12:21:31.861688Z" + "end_time": "2021-03-31T10:57:59.013482Z", + "start_time": "2021-03-31T10:57:52.945920Z" } }, "outputs": [ @@ -25,26 +25,36 @@ "text": [ "Graph info: Name: Network graph\n", "Type: MultiDiGraph\n", - "Number of nodes: 2\n", - "Number of edges: 1\n", - "Average in degree: 0.5000\n", - "Average out degree: 0.5000 \n", + "Number of nodes: 1662\n", + "Number of edges: 3166\n", + "Average in degree: 1.9049\n", + "Average out degree: 1.9049 \n", "Schedule info: Schedule:\n", - "Number of services: 1\n", - "Number of unique routes: 1\n", - "Number of stops: 2\n" + "Number of services: 9\n", + "Number of routes: 68\n", + "Number of stops: 45\n" ] } ], "source": [ "# read sample network\n", - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", - "path_to_matsim_network = '../tests/test_data/matsim'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "path_to_matsim_network = '../example_data/pt2matsim_network'\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.print()" ] }, @@ -53,8 +63,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.248625Z", - "start_time": "2020-12-17T12:21:35.214538Z" + "end_time": "2021-03-31T10:58:01.661472Z", + "start_time": "2021-03-31T10:57:59.025741Z" } }, "outputs": [ @@ -62,24 +72,12 @@ "name": "stderr", "output_type": "stream", "text": [ - "2020-12-17 12:21:35,216 - Checking validity of the Network\n", - "2020-12-17 12:21:35,218 - Checking validity of the Network graph\n", - "2020-12-17 12:21:35,221 - Checking network connectivity for mode: car\n", - "2020-12-17 12:21:35,222 - Checking network connectivity for mode: walk\n", - "2020-12-17 12:21:35,224 - Checking network connectivity for mode: bike\n", - "2020-12-17 12:21:35,226 - Checking validity of the Schedule\n", - "2020-12-17 12:21:35,228 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,231 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,232 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,233 - This schedule is not valid\n", - "2020-12-17 12:21:35,234 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,236 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,238 - Service id=10314 is not valid\n", - "2020-12-17 12:21:35,239 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,240 - Not all stops reference network link ids.\n", - "2020-12-17 12:21:35,243 - Route id=VJbd8660f05fe6f744e58a66ae12bd66acbca88b98 under Service id=10314 is not valid\n", - "2020-12-17 12:21:35,244 - Some link ids in Route: VJbd8660f05fe6f744e58a66ae12bd66acbca88b98 don't accept the route's mode: bus\n", - "2020-12-17 12:21:35,245 - Some link ids in Route: VJbd8660f05fe6f744e58a66ae12bd66acbca88b98 don't accept the route's mode: bus\n" + "2021-03-31 11:57:59,027 - Checking validity of the Network\n", + "2021-03-31 11:57:59,033 - Checking validity of the Network graph\n", + "2021-03-31 11:57:59,034 - Checking network connectivity for mode: car\n", + "2021-03-31 11:57:59,389 - Checking network connectivity for mode: walk\n", + "2021-03-31 11:57:59,441 - Checking network connectivity for mode: bike\n", + "2021-03-31 11:58:01,552 - Checking validity of the Schedule\n" ] } ], @@ -99,8 +97,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.262338Z", - "start_time": "2020-12-17T12:21:35.251074Z" + "end_time": "2021-03-31T10:58:01.675571Z", + "start_time": "2021-03-31T10:58:01.665681Z" } }, "outputs": [ @@ -111,13 +109,16 @@ "{'graph_connectivity': {'bike': {'number_of_connected_subgraphs': 0,\n", " 'problem_nodes': {'dead_ends': [],\n", " 'unreachable_node': []}},\n", - " 'car': {'number_of_connected_subgraphs': 2,\n", - " 'problem_nodes': {'dead_ends': ['21667818'],\n", - " 'unreachable_node': ['25508485']}},\n", - " 'walk': {'number_of_connected_subgraphs': 2,\n", - " 'problem_nodes': {'dead_ends': ['21667818'],\n", - " 'unreachable_node': ['25508485']}}},\n", - " 'links_over_1km_length': []}\n" + " 'car': {'number_of_connected_subgraphs': 1,\n", + " 'problem_nodes': {'dead_ends': [],\n", + " 'unreachable_node': []}},\n", + " 'walk': {'number_of_connected_subgraphs': 0,\n", + " 'problem_nodes': {'dead_ends': [],\n", + " 'unreachable_node': []}}},\n", + " 'link_attributes': {'links_over_1km_length': {'link_ids': [],\n", + " 'number_of': 0,\n", + " 'percentage': 0.0},\n", + " 'zero_attributes': {}}}\n" ] } ], @@ -164,8 +165,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.274994Z", - "start_time": "2020-12-17T12:21:35.266391Z" + "end_time": "2021-03-31T10:58:01.760298Z", + "start_time": "2021-03-31T10:58:01.677236Z" } }, "outputs": [ @@ -173,16 +174,182 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'route_level': {'10314': {'VJbd8660f05fe6f744e58a66ae12bd66acbca88b98': {'invalid_stages': ['not_has_correctly_ordered_route'],\n", - " 'is_valid_route': False}}},\n", - " 'schedule_level': {'has_valid_services': False,\n", - " 'invalid_services': ['10314'],\n", - " 'invalid_stages': ['not_has_valid_services'],\n", - " 'is_valid_schedule': False},\n", - " 'service_level': {'10314': {'has_valid_routes': False,\n", - " 'invalid_routes': ['VJbd8660f05fe6f744e58a66ae12bd66acbca88b98'],\n", - " 'invalid_stages': ['not_has_valid_routes'],\n", - " 'is_valid_service': False}}}\n" + "{'route_level': {'12430': {'VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ06cd41dcd58d947097df4a8f33234ef423210154': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ15419796737689e742962a625abcf3fd5b3d58b1': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ235c8fca539cf931b3c673f9b056606384aff950': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ8f9aea7491080b0137d3092706f53dc11f7dba45': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ948e8caa0f08b9c6bf6330927893942c474b5100': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ95b4c534d7c903d76ec0340025aa88b81dba3ce4': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJeae6e634f8479e0b6712780d5728f0afca964e64': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJeb72539d69ddf8e29f1adf74d43953def196ae41': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJef7f20c3a9bf1419f6401e1e9131fe2c634bcb9a': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '14073': {'VJ24fe211d801738b556a39f815256d7f6bc544ec5': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ93d8207ae8540b4ff59d47c9ee1ec5689084522d': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJaa5ee0daec7529d7668c81fe7fac0c4ff545daea': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJb4309b7a9598539ab9942ea1bcadc60a91b978ba': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJc8cdbd902dadeebeeb4dbd7332b564ee2e4b00ce': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJd132b905afc6c0e8e8a994142e301ca5c0f70e22': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJd9dbeefeca6d74ef2594a17514ebc08ee2d503b2': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJdbc280077e505b4f8d66586ca51751a125cb4ef0': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJe18efadf172576fea7989ec1f233f26854c0f66a': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJe6ba07ef9f19ae40517261ad626bf34dd656491a': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJe8cffad09738ff7b9698b333e3247918d5c45358': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJea6046f64f85febf1854290fb8f76e921e3ac96b': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJf6055fdf9ef0dd6d0500b6c11adcfdd4d10655dc': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJfc35884fc4f11dc408a209c19f56f3b60f634daf': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '14134': {'VJ12ba6089dfb2733e29c415a1a0015fef30fd5305': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ256e98df611ff48afe737ddc81cbcde82e4e81c8': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ26095b8f9f9db92ca2e53d4c086a7dcd82a13be9': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ2aba67e3ed98f2ed5f5966c1ac394cbf6d1943d7': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ2c87b2a59184888f3175b55bde7b02d024ea8607': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ323d02e117552af1565f2ff1273a612655c829c4': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ4c6fa387b0d4be94a6c3679b94790b183e2558ca': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ4e2b897edf0e7b8a8e3b5516ab43ce56f72c5cff': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ4e311a625836374adf4cfaa841224840dbeb7619': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ5909ba51575a9459eb0013fbd31c8205455ca2fd': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJa7f37392e276aeac26c7e73bbc05e6a71af38dba': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJb93a17a405fe502c5b3a2d6544105b0311da9fe2': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJd78967364a302cf232c5139d40622dcb6c238c9e': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJdb0c128567fcbcc063d554ae1c95851cee41b909': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJdf3936da1a51eb33db594ef99738802c14b19995': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJf9a22035ae6f25bb420df833474943ad76065c89': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '15234': {'VJ1a8cc306354fdc322d739ae644eb73444341d08d': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ28a8a6a4ab02807a4fdfd199e5c2ca0622d34d0c': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ3d50b96792ae8495dbe5a5e372849a60c48b2279': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ5b511605b1e07428c2e0a7d676d301c6c40dcca6': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ652c769bc42361cc0308dff59a1fdcf0949bdade': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ8ccf92aa0f351b2e31f1a078b968dff4c2505c02': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ9b58a59e3d74941586a5bca7726a8aa624da67fc': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJbf9d4fdb976223e6a026c0c669ed290418abefee': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJd4cbfb092a104ac6a3164a86e9765f68734fdfcf': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '15660': {'VJ1cf651142378958b52229bfe1fa552e49136e60e': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ3716910ec59c370d9f5c69137df7276b68cf0a08': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJf2e0de4f5dad68cb03064e6064e372dde52cc678': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '17732': {'VJ0cb60de3ed229c1413abac506e770b6ab8a7c49a': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ85c23573d670bab5485618b0c5fddff3314efc89': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '18853': {'VJ8cacca9a6722c497c413005568182ecf4d50b160': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJf3e316e5e605bb512147dee2a989be5a82ef1b5f': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJfc4917783c2ca3227789fa7c532c9adf47702095': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '18915': {'VJ0d304b95d39f4bce48e6ff26ddd73a9c06f17f4f': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ887921c00645929c5402ac46592e57c368ea63a1': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ8a4b1ca7dfd0a130abd1de9f55f3b756617dd4ca': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJb08f8a2de01a4ef99d3b7fefd9022117ac307531': {'invalid_stages': [],\n", + " 'is_valid_route': True}},\n", + " '20274': {'VJ375a660d47a2aa570aa20a8568012da8497ffecf': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e': {'invalid_stages': [],\n", + " 'is_valid_route': True},\n", + " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf': {'invalid_stages': [],\n", + " 'is_valid_route': True}}},\n", + " 'schedule_level': {'has_valid_services': True,\n", + " 'invalid_services': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_schedule': True},\n", + " 'service_level': {'12430': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '14073': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '14134': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '15234': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '15660': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '17732': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '18853': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '18915': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True},\n", + " '20274': {'has_valid_routes': True,\n", + " 'invalid_routes': [],\n", + " 'invalid_stages': [],\n", + " 'is_valid_service': True}}}\n" ] } ], @@ -209,8 +376,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.283322Z", - "start_time": "2020-12-17T12:21:35.278684Z" + "end_time": "2021-03-31T10:58:01.814961Z", + "start_time": "2021-03-31T10:58:01.784600Z" } }, "outputs": [ @@ -218,12 +385,76 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'route_to_crow_fly_ratio': {'10314': {'VJbd8660f05fe6f744e58a66ae12bd66acbca88b98': 'Division '\n", - " 'by '\n", - " 'zero'}},\n", - " 'service_routes_with_invalid_network_route': [('10314',\n", - " 'VJbd8660f05fe6f744e58a66ae12bd66acbca88b98')],\n", - " 'services_have_routes_in_the_graph': False}\n" + "{'route_to_crow_fly_ratio': {'12430': {'VJ06420fdab0dfe5c8e7f2f9504df05cf6289cd7d3': 0.846235591692864,\n", + " 'VJ06cd41dcd58d947097df4a8f33234ef423210154': 0.846235591692864,\n", + " 'VJ0f3c08222de16c2e278be0a1bf0f9ea47370774e': 0.6847798803333932,\n", + " 'VJ15419796737689e742962a625abcf3fd5b3d58b1': 0.846235591692864,\n", + " 'VJ235c8fca539cf931b3c673f9b056606384aff950': 0.6847798803333932,\n", + " 'VJ8f9aea7491080b0137d3092706f53dc11f7dba45': 0.6847798803333932,\n", + " 'VJ948e8caa0f08b9c6bf6330927893942c474b5100': 0.6847798803333932,\n", + " 'VJ95b4c534d7c903d76ec0340025aa88b81dba3ce4': 0.6847798803333932,\n", + " 'VJeae6e634f8479e0b6712780d5728f0afca964e64': 0.846235591692864,\n", + " 'VJeb72539d69ddf8e29f1adf74d43953def196ae41': 0.846235591692864,\n", + " 'VJef7f20c3a9bf1419f6401e1e9131fe2c634bcb9a': 0.6847798803333932,\n", + " 'VJf8e38a73359b6cf743d8e35ee64ef1f7b7914daa': 0.846235591692864},\n", + " '14073': {'VJ24fe211d801738b556a39f815256d7f6bc544ec5': 0.8207362718554999,\n", + " 'VJ6cf76a4c03cca468cb6954db7f7aad5ae189df13': 0.9185129454449271,\n", + " 'VJ93d8207ae8540b4ff59d47c9ee1ec5689084522d': 0.8207362718554999,\n", + " 'VJaa5ee0daec7529d7668c81fe7fac0c4ff545daea': 0.8207362718554999,\n", + " 'VJb4309b7a9598539ab9942ea1bcadc60a91b978ba': 0.9185129454449271,\n", + " 'VJc8cdbd902dadeebeeb4dbd7332b564ee2e4b00ce': 0.9185129454449271,\n", + " 'VJd132b905afc6c0e8e8a994142e301ca5c0f70e22': 0.9185129454449271,\n", + " 'VJd9dbeefeca6d74ef2594a17514ebc08ee2d503b2': 0.8207362718554999,\n", + " 'VJdbc280077e505b4f8d66586ca51751a125cb4ef0': 0.9185129454449271,\n", + " 'VJe18efadf172576fea7989ec1f233f26854c0f66a': 0.9185129454449271,\n", + " 'VJe6ba07ef9f19ae40517261ad626bf34dd656491a': 0.8207362718554999,\n", + " 'VJe8cffad09738ff7b9698b333e3247918d5c45358': 0.8207362718554999,\n", + " 'VJea6046f64f85febf1854290fb8f76e921e3ac96b': 0.8207362718554999,\n", + " 'VJf6055fdf9ef0dd6d0500b6c11adcfdd4d10655dc': 0.9185129454449271,\n", + " 'VJfc35884fc4f11dc408a209c19f56f3b60f634daf': 0.9185129454449271},\n", + " '14134': {'VJ12ba6089dfb2733e29c415a1a0015fef30fd5305': 0.6001713432424822,\n", + " 'VJ256e98df611ff48afe737ddc81cbcde82e4e81c8': 0.6001713432424822,\n", + " 'VJ26095b8f9f9db92ca2e53d4c086a7dcd82a13be9': 0.6356819282334122,\n", + " 'VJ2aba67e3ed98f2ed5f5966c1ac394cbf6d1943d7': 0.6001713432424822,\n", + " 'VJ2c87b2a59184888f3175b55bde7b02d024ea8607': 0.6356819282334122,\n", + " 'VJ323d02e117552af1565f2ff1273a612655c829c4': 0.6356819282334122,\n", + " 'VJ4c6fa387b0d4be94a6c3679b94790b183e2558ca': 0.6356819282334122,\n", + " 'VJ4e2b897edf0e7b8a8e3b5516ab43ce56f72c5cff': 0.6001713432424822,\n", + " 'VJ4e311a625836374adf4cfaa841224840dbeb7619': 0.6356819282334122,\n", + " 'VJ5909ba51575a9459eb0013fbd31c8205455ca2fd': 0.6356819282334122,\n", + " 'VJa7f37392e276aeac26c7e73bbc05e6a71af38dba': 0.6001713432424822,\n", + " 'VJb93a17a405fe502c5b3a2d6544105b0311da9fe2': 0.6356819282334122,\n", + " 'VJd78967364a302cf232c5139d40622dcb6c238c9e': 0.6001713432424822,\n", + " 'VJdb0c128567fcbcc063d554ae1c95851cee41b909': 0.6356819282334122,\n", + " 'VJdf3936da1a51eb33db594ef99738802c14b19995': 0.6001713432424822,\n", + " 'VJf9a22035ae6f25bb420df833474943ad76065c89': 0.6001713432424822},\n", + " '15234': {'VJ1a8cc306354fdc322d739ae644eb73444341d08d': 0.542205277349309,\n", + " 'VJ28a8a6a4ab02807a4fdfd199e5c2ca0622d34d0c': 0.542205277349309,\n", + " 'VJ3d50b96792ae8495dbe5a5e372849a60c48b2279': 0.542205277349309,\n", + " 'VJ5b511605b1e07428c2e0a7d676d301c6c40dcca6': 0.542205277349309,\n", + " 'VJ652c769bc42361cc0308dff59a1fdcf0949bdade': 0.542205277349309,\n", + " 'VJ8ccf92aa0f351b2e31f1a078b968dff4c2505c02': 0.542205277349309,\n", + " 'VJ9b58a59e3d74941586a5bca7726a8aa624da67fc': 1.159833011264421,\n", + " 'VJbf9d4fdb976223e6a026c0c669ed290418abefee': 0.542205277349309,\n", + " 'VJd4cbfb092a104ac6a3164a86e9765f68734fdfcf': 0.542205277349309},\n", + " '15660': {'VJ1cf651142378958b52229bfe1fa552e49136e60e': 1.328436022439322,\n", + " 'VJ3716910ec59c370d9f5c69137df7276b68cf0a08': 1.328436022439322,\n", + " 'VJf2e0de4f5dad68cb03064e6064e372dde52cc678': 1.8033355406925058},\n", + " '17732': {'VJ0cb60de3ed229c1413abac506e770b6ab8a7c49a': 0.9589696986431446,\n", + " 'VJ85c23573d670bab5485618b0c5fddff3314efc89': 1.355926006598838},\n", + " '18853': {'VJ8cacca9a6722c497c413005568182ecf4d50b160': 0.8769127190510215,\n", + " 'VJf3e316e5e605bb512147dee2a989be5a82ef1b5f': 0.5898795510616061,\n", + " 'VJfc4917783c2ca3227789fa7c532c9adf47702095': 0.8769127190510215},\n", + " '18915': {'VJ0d304b95d39f4bce48e6ff26ddd73a9c06f17f4f': 0.9589696986431446,\n", + " 'VJ520ec0c0ca58a849349fa614b5cf9270ac5c93da': 1.355926006598838,\n", + " 'VJ887921c00645929c5402ac46592e57c368ea63a1': 1.355926006598838,\n", + " 'VJ8a4b1ca7dfd0a130abd1de9f55f3b756617dd4ca': 0.9589696986431446,\n", + " 'VJb08f8a2de01a4ef99d3b7fefd9022117ac307531': 1.355926006598838},\n", + " '20274': {'VJ375a660d47a2aa570aa20a8568012da8497ffecf': 0.5898572922343817,\n", + " 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e': 0.8690449306856333,\n", + " 'VJ812fad65e7fa418645b57b446f00cba573f2cdaf': 0.8690449306856333}},\n", + " 'service_routes_with_invalid_network_route': [],\n", + " 'services_have_routes_in_the_graph': True}\n" ] } ], @@ -248,22 +479,15 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.294571Z", - "start_time": "2020-12-17T12:21:35.285314Z" + "end_time": "2021-03-31T10:58:01.868371Z", + "start_time": "2021-03-31T10:58:01.829397Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2020-12-17 12:21:35,288 - Some link ids in Route: VJbd8660f05fe6f744e58a66ae12bd66acbca88b98 don't accept the route's mode: bus\n" - ] - }, { "data": { "text/plain": [ - "[('10314', 'VJbd8660f05fe6f744e58a66ae12bd66acbca88b98')]" + "[]" ] }, "execution_count": 6, @@ -280,22 +504,15 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.304141Z", - "start_time": "2020-12-17T12:21:35.296084Z" + "end_time": "2021-03-31T10:58:01.935457Z", + "start_time": "2021-03-31T10:58:01.870687Z" } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2020-12-17 12:21:35,299 - Not all stops reference network link ids.\n" - ] - }, { "data": { "text/plain": [ - "False" + "True" ] }, "execution_count": 7, @@ -319,8 +536,8 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.312173Z", - "start_time": "2020-12-17T12:21:35.307556Z" + "end_time": "2021-03-31T10:58:02.028814Z", + "start_time": "2021-03-31T10:58:01.938984Z" } }, "outputs": [ @@ -344,8 +561,8 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T12:21:35.322032Z", - "start_time": "2020-12-17T12:21:35.315127Z" + "end_time": "2021-03-31T10:58:02.071684Z", + "start_time": "2021-03-31T10:58:02.059278Z" } }, "outputs": [ @@ -363,32 +580,11 @@ "source": [ "n.schedule.graph().is_directed()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -402,7 +598,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/6.2. Validating Network - Google Directions API.ipynb b/notebooks/6.2. Validating Network - Google Directions API.ipynb index 625d30ff..ed739f4c 100644 --- a/notebooks/6.2. Validating Network - Google Directions API.ipynb +++ b/notebooks/6.2. Validating Network - Google Directions API.ipynb @@ -18,8 +18,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.477474Z", - "start_time": "2020-12-17T13:05:05.670395Z" + "end_time": "2021-03-31T10:58:49.374437Z", + "start_time": "2021-03-31T10:58:45.201591Z" } }, "outputs": [ @@ -35,21 +35,30 @@ "Average out degree: 1.9049 \n", "Schedule info: Schedule:\n", "Number of services: 9\n", - "Number of unique routes: 68\n", + "Number of routes: 68\n", "Number of stops: 45\n" ] } ], "source": [ "# read sample network\n", - "from genet import Network\n", - "from genet import google_directions\n", + "from genet import read_matsim, google_directions\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.print()" ] }, @@ -135,8 +144,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.487114Z", - "start_time": "2020-12-17T13:05:09.479543Z" + "end_time": "2021-03-31T10:58:49.396915Z", + "start_time": "2021-03-31T10:58:49.387803Z" } }, "outputs": [], @@ -149,8 +158,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.501949Z", - "start_time": "2020-12-17T13:05:09.491075Z" + "end_time": "2021-03-31T10:58:49.410240Z", + "start_time": "2021-03-31T10:58:49.400269Z" } }, "outputs": [ @@ -196,8 +205,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.519961Z", - "start_time": "2020-12-17T13:05:09.510747Z" + "end_time": "2021-03-31T10:58:49.432178Z", + "start_time": "2021-03-31T10:58:49.426673Z" } }, "outputs": [], @@ -210,8 +219,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.535934Z", - "start_time": "2020-12-17T13:05:09.531302Z" + "end_time": "2021-03-31T10:58:49.440878Z", + "start_time": "2021-03-31T10:58:49.433969Z" } }, "outputs": [ @@ -236,8 +245,8 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.547225Z", - "start_time": "2020-12-17T13:05:09.539753Z" + "end_time": "2021-03-31T10:58:49.458866Z", + "start_time": "2021-03-31T10:58:49.446984Z" } }, "outputs": [ @@ -290,8 +299,8 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.585840Z", - "start_time": "2020-12-17T13:05:09.561615Z" + "end_time": "2021-03-31T10:58:49.473617Z", + "start_time": "2021-03-31T10:58:49.460920Z" } }, "outputs": [ @@ -299,7 +308,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2020-12-17 13:05:09,582 - Changed Edge attributes for 1 edges\n" + "2021-03-31 11:58:49,469 - Changed Edge attributes for 1 edges\n" ] } ], @@ -322,8 +331,8 @@ "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.626228Z", - "start_time": "2020-12-17T13:05:09.607262Z" + "end_time": "2021-03-31T10:58:49.484628Z", + "start_time": "2021-03-31T10:58:49.478426Z" } }, "outputs": [ @@ -382,8 +391,8 @@ "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.681235Z", - "start_time": "2020-12-17T13:05:09.634591Z" + "end_time": "2021-03-31T10:58:49.524832Z", + "start_time": "2021-03-31T10:58:49.488660Z" } }, "outputs": [ @@ -391,8 +400,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "2020-12-17 13:05:09,671 - 3165 out of 3166 links have not been affected by the function. Links affected: ['596']\n", - "2020-12-17 13:05:09,679 - Changed Link attributes for 1 links\n" + "2021-03-31 11:58:49,515 - 3165 out of 3166 links have not been affected by the function. Links affected: ['596']\n", + "2021-03-31 11:58:49,522 - Changed Link attributes for 1 links\n" ] } ], @@ -408,8 +417,8 @@ "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:05:09.701952Z", - "start_time": "2020-12-17T13:05:09.692023Z" + "end_time": "2021-03-31T10:58:49.538105Z", + "start_time": "2021-03-31T10:58:49.528239Z" } }, "outputs": [ @@ -462,7 +471,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -476,7 +485,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/notebooks/7. Visualising Network.ipynb b/notebooks/7. Visualising Network.ipynb index b16a97d1..ab95bd0f 100644 --- a/notebooks/7. Visualising Network.ipynb +++ b/notebooks/7. Visualising Network.ipynb @@ -12,8 +12,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:52.253663Z", - "start_time": "2020-12-17T13:42:48.449588Z" + "end_time": "2021-03-31T10:58:21.267678Z", + "start_time": "2021-03-31T10:58:17.304876Z" } }, "outputs": [ @@ -29,20 +29,30 @@ "Average out degree: 1.9049 \n", "Schedule info: Schedule:\n", "Number of services: 9\n", - "Number of unique routes: 68\n", + "Number of routes: 68\n", "Number of stops: 45\n" ] } ], "source": [ "# read sample network\n", - "from genet import Network\n", + "from genet import read_matsim\n", "import os\n", "\n", - "n = Network('epsg:27700')\n", "path_to_matsim_network = '../example_data/pt2matsim_network'\n", - "n.read_matsim_network(os.path.join(path_to_matsim_network, 'network.xml'))\n", - "n.read_matsim_schedule(os.path.join(path_to_matsim_network, 'schedule.xml'))\n", + "\n", + "network = os.path.join(path_to_matsim_network, 'network.xml')\n", + "schedule = os.path.join(path_to_matsim_network, 'schedule.xml')\n", + "vehicles = os.path.join(path_to_matsim_network, 'vehicles.xml')\n", + "n = read_matsim(\n", + " path_to_network=network, \n", + " epsg='epsg:27700', \n", + " path_to_schedule=schedule, \n", + " path_to_vehicles=vehicles\n", + ")\n", + "# you don't need to read the vehicles file, but doing so ensures all vehicles\n", + "# in the schedule are of the expected type and the definition of the vehicle\n", + "# is preserved\n", "n.print()" ] }, @@ -60,8 +70,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:55.475798Z", - "start_time": "2020-12-17T13:42:52.256450Z" + "end_time": "2021-03-31T10:58:24.577084Z", + "start_time": "2021-03-31T10:58:21.273512Z" } }, "outputs": [ @@ -69,15 +79,17 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -89,7 +101,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 2, @@ -106,8 +118,8 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:55.677662Z", - "start_time": "2020-12-17T13:42:55.480768Z" + "end_time": "2021-03-31T10:58:24.780256Z", + "start_time": "2021-03-31T10:58:24.593169Z" } }, "outputs": [ @@ -115,13 +127,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -133,7 +147,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 3, @@ -150,8 +164,8 @@ "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:55.843199Z", - "start_time": "2020-12-17T13:42:55.682220Z" + "end_time": "2021-03-31T10:58:24.999209Z", + "start_time": "2021-03-31T10:58:24.783722Z" } }, "outputs": [ @@ -159,13 +173,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAACZCAYAAACi7wp2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAcYklEQVR4nO3deXCb13ku8Of7sBMAiYVYuZMARYJabVkSLTqt0zhxHcdp4qXeTUmuO5PEzuQ2d5KmdSedSdpMtzu903Y6mUpy7NhxmsWKXUd2JNuKSInU5kUSQVEgKa4gNoLgAnCV1D8AQpJtybREAvjI5zej0TYkjv56dM55z/sKFy9eBBEREV2bmO0FEBERSQEDk4iIaAEYmERERAvAwCQiIloABiYREdECyK/1lyaTiSW0RES0okSjUeHj/pw7TCIiogVgYBIR0Yrwt9/8Bp566qnr/noGJhERLWsugx7P3dGAO21mXJicvO7vI1yr0w/vMImISKr0CgWeWV+LeypL8O8fnMFLHd2YW0B3u6vdYV6z6IeIiEhqRAG411WOb23w4K2+Ifzxnn2ITs/c8PdlYBIR0bKxwWLCs5vWYebCBTy5/zC80diifW8GJhERSZ5Vo8a3b65Dvd2KfzxxGq+e61/0z2DRDxERLZhZrcLL//D3+Lsf/jDbSwEAKEURf1bnxmv3/BGCiSncuWffkoQlwB0mEREtQI2xAI0eFz5X4sD7He1oGQhke0n4gyIb/uqWtTg3NoEHfnsAvePxJf08BiYREX0sAcDtxXY0elyoKNDjxTPduOOV32FkEQpobkR5vg5/dctalOq1+MGxkzg4GMzI5zIwiYjoCnlyGb7qKsMTtS6Mz8ziOW8n9vYOYPZCdl8aauVyfG3tKtznLsePT5/F195pyeiaGJhERAQAcGg1eKymCve6ynA8GMFfHjqB46HhbC8LAoB7Kkvw7ZtX47A/hLtffQvhyamMr4OBSUS0wq0vNKLR48ZWpxWvdPXivtffQf9EItvLAgCsNhvw7KZ1kIsinn6nFe9HRrK2FgYmEdEKJBMEfKHMiW0eN8xqFZ5v78Rft7yLidm5bC8NAGBSq/B/Nnhwe7ED/++9NvyqsxfZbj3HwCQiWkHylQo84C7HYzVVGIwn8OPTZ/FWvx9Zvp5MkwsCHqmpxNfW1mBPVx/u3LMP47Oz2V4WAAYmEdGKUJ6vw+O1VfhSRQkODATwtXda0baIXXAWw60OC/560zoEE5N4+I2D6Bodz/aSrsDAJCJaxrbYLdjmcWG9xYSXz57DF3+zH6EsFMxcS7EuD3+5cQ1qTQb88NhJvNU/lO0lfSxOKyEiWmaUoogvVZbgidoqKEQRz3k78ZvufkydP5/tpV1BLZPhz9dU45FVldjt7cTONh9mLlzI9rI4rYSIaLkzq1V4aFUFHl5VifboKP7xRBua/cGsF8t8nD8uK8J3N67Bu+Fh3PPa2wgkrn9OZaYwMImIJG6VMR+NtS7cUerE3p5BPP5mEzpz7P5v3ipjPp7dtA75SgW+3XwMx4LZf+e5UAxMIiIJEgD8YaptXVUOta27mgKlAt/c4MFdZUX4/x+04+dne3B+AcOccwkDk4hIQjRyGb5aVYYnaqsQn5vDbm8n9vZkv23d1YgC8KfuCjyzvhZ7ewfxhT37MDqTG89EPi0GJhGRBNjzNHisphL3uctxPBjB9w6/mxNt667lFpsZz25ah7GZWTTua0bHyFi2l3RDGJhERDlsXaERjR4XGpy2nGtbdzX2PA2+s3E1brKY8aPjp7C3dzDbS1oUfFZCRJRjZIKAz5c60ehxwaJR4/kzXfilrydn2tZdjVIUsaPOjW0eF17s6MaPT5/F5FxuPWVZCD4rISLKcXqFAg9UJ9vW+eMJ7GzzYX8Ota27Gpkg4J+++39xK2ZwvKUFX339HQzk+C74ejAwiYiyrFSvxRO1LtxTWYLfDwTwjQOtOD2cW23rPo5WLsd97uTcTH1NNV7e/zb++cCRbC9ryfBIlogoSzbbC7HN48aGVNu6lzq6EUzkVtu6j2PP0+Dx2irc5ypDSyCM3W2+rI7dWmxXO5JlYBIRZZBSFHF3RTEaPS4oRRHPtXdhT1dfzrWt+zgekwE76lz4TJEdr3T14vn2rmV59Mo7TCKiLDKpVXi4ugIPrapEx0hut627nADg9mI7tte5UarX4vn2Lny/9YOcGbmVSQxMIqIlVG3IR6PHhc+XOrG3dxBP7GtCZyw329ZdTi2T4StVpWj0uJCYm8OuNh/29gxiTmLdeRYTj2SJiBaZAOAPipJt61yGZNu6n589h2iOtq27XKFahUdrqvBgdTneC0ex29uJo8FItpeVUTySJSJaYhp5clf2eK0LU3Pnsdvrw29zuG3d5dyGfGxL7YRf7xnAg28cRM/YRLaXlVO4wyQiukH2PA0eranE/e5yHA8N4zmvTzJTOBqcVmzzuFFjLMCLHV34Wce5nG3gnimskiUiWmRrC43Ylmpbt6erD8+3d+Z82zrg0oDpbR4XAGC3txOvdffnxPDmXMDAJCJaBDJBwB2ptnVWCbWtAwCDSomHqivwSE0lzo6MYZfXh2Z/KNvLyjm8wyQiugF6hQL3u8vwWG0VAvFJ7G7zYX//kCRmOpbn69BY68LdFcXY1+fH9n2HcDYm7ckh2cDAJCK6hmTbuircU1mKg4MBPHPgKE4NS6OrzSZbIbZ5XKlOQj24c88+RKams70syeKRLBHRx5gPm5usZvz8bA9e7OiSRNs6uSDgzvIibPe4oVPI8Vx7J37dKY1OQrmCR7JERJ9AKYr4YkUxGmtdUMmSbeu+dfCYJMJGp5DjT6sr8HhNFfon4vi3k2fwTv9QzncSkhIGJhGteCaVEg+tqsTDqbZ1//xeG5oGc79tHQAUafPwhKcKX6kqw8HBAL4ukUknUsTAJKIVy23IR2OtC18oc+INCbWtA4B1hUZsr3Oj3m7Brzp78aVX30IgMZntZS1rvMMkohVFAPD9p7+Om2QXYBzswUsd3Xi5Qxpt60QB+FyJE9s8Lti1GvzE24lf+HoRn8v9Jy1SwjtMIlrRlKKIeypLsL3ODeemjXij9Sj+5ldvSuKxfp5chntdZWj0uBCdmsHONh/29fkl8aRlOeEOk4iWtfnH+o/WVKE9GsMurw+Hh8LZXtaC2PLUeLSmCg+4y3EsGMHONh/eC0ezvaxljztMIlpRku8nXfhyZQn29w9h275myTzWrzUWYFudC7cXO/Bqdx/u/+0B9I3Hs72sFY87TCJaVtYXGrGjrhqb7IX4+dke/PRMF0KTuf9+cn4k2LY6Fyrz9XjhTBdePnsOYzMrb1BztnGHSUTLligAf1TixI46N6waNZ7zduI7h44jMZf77ydVMhFfrizFdo8L0+cvYKfXh70SGQm20jAwiUiy1DIZvuoqwzaPC6PTM/gvCRXDmNQqPLKqEg+vqsCpyAi+f+QDtAakcbe6UjEwiUhyzGoVHq2pxEPVFXg3HMV3D53AiZA05k9WFeixzePCnWVF2NsziEffbELXqDTefq50DEwikozLw+b1ngE8+MZB9IxNZHtZC1Jvt2B7nRurzQa82NGNz7/yO0m8/aRLWPRDRDlvk60QT9a5sabQiBc7uvHSmW5JhI1CFPDF8hJsr3NBIYrY5e3Eb7r6JPH2cyXjAGkikhSZIODOsiLsqHNDq5BjV5sPe7r7MH0+98OmQKnAg9UVeLS2Cl2xcezy+iTTm5ZYJUtEEqGVy3F/dTkaa10YnIjj3z5oxzsDAUmETalei0aPC/dUlOCt/iH82f7DODMymu1l0SJhYBJRTrDnafB4bRXuc5Xh8FAYz/z+CE5GpDGo+WarGds9Lmy0Jd9+3vWb/ZJ4+0mfDo9kiSiraowF2J7qarOnqw8/ae/EwEQi28v6RDJBwBfKnNjuccOgUmK3txO/7urFpATeftK18UiWiHJKg9OKJ+vcqDLk44X2Lvzg6ElJdLXRKeS4z12OJ2qrMBSfxH+e6sDbA0Ngn4Hlj4FJRBmjFEXcXVGM7XVuXLwI7PL68D/n+iXR1cahTR4Z31tVhkNDIXzz90clc2RMi4OBSURLLj9VNfpYbRU6Y2P40fFTaPaHsr2sTySTyfDg5z6LjZMxbHVY8euuPvzJ/7wNf5yDmlci3mES0ZIp1uWhsdaFL1eV4u3+Iez2duZ81WiRNg/1Dgs22y34bMNWlH7re/ibu+7ACye9mJjloOaVgO8wiShj1hYasaPOjS12C37p68ELZ7oRSOTmrsyqUWOL3YItDgu22C3QyGVoDYTRMhRGayCM6EUBExPS6CZEi4OBSURLSgBwe4kDT9a54dBq8BNvJ37h60V8Lrd2ZUaVEpvthdhit2KLwwKTSoljwQhaAmG0DoXRyb6uKx6rZIloSahkIr5SlZwYMjE7h51tZ/Fmb+5MDNErFLjFXogt9kJssVtQrNPieDCC1kAY/+07h/boqCSaIlD2cYdJRNfFpFLikZoqPLyqAh9ERrCz7SyOBbM/MUQjl+Fmqxn1dgs2OyyoKtDjg3AULUNhHAmEcXo4hrkcCXPKTTySJaJFUZGvwzaPC3eVF2NvzyB2e33ozuLEEKUoYr3FhPrUHWStyQBvNJa6gwzhg/AIm53Tp8LAJKIbstFqxo46NzZYTHip4xx+2tGN6NR0xtchFwSsKTSmC3XWFZrgi42hNXUHeSI0jKnz7LZD14+BSUSfmkwQ8PlSJ3asdiNfocBubyde6erLaCCJAlBrNKSrWDdazegbj6MlkDxiPRaM8LkHLSoGJhEtWJ5chvvd5Xii1oVAYhK72nwZbf/mNuSn7yA32QoRmZxKV7EeDUYQk8AsTJIuBiYRfSKrRo3HaqvwgLscRwJh7Grz4f0MtH8r02tR77Bii92CzfZCJObm0u8gjwQiCHPyB2UQA5OIrqrakI8ddW58tsSBV7v78Jy3E/1LODHEqdWk7yDr7VYAQEsghNZUSLL1HGUTA5OIPmKrw4rtdW6sMiYnhrx89hxGl2BiiEWjxhZ7ITbbLah3WKCVy1N3kBG0DIXQOx5f9M8kul4MTCICAChEAXeVF2NHnRsyQcAubyde6+5f1KcXBpUSm22F6UKdQo0aR4MRtA6F0BqIwBcbW7TPIlpsDEyiFU6vUODB6nI8XutC1+g4drb50OQPLsr31inkuMWW7KRT70h20zkRGk73ZD0zEuO8SJIMBibRCuXUatDoceErVWU4MBDArjYf2m9wYsh8N53Ndgvq7RZUGfT4IDyCI4EwWgJhnI6MsJsOSRYDk2iFWW02YEedG1sdVvyysxfPt3dd98SQ+W4684U6nlQ3nfkinffDUXbToWWDgUm0AggA/rDYjh11bpTotHiuvRO/8PV86of9MkHAGrMBW1JPPdZZjOgaHU8H5InQMCbn2E2HlidOKyFaxpSiiD+pKsV2jwuT589jZ5sPb/QMLvhYVBSAGqMBW+yFqHdYcbPVjIGJOFoDYTzf3omjB9hNh4g7TCIJM6qUeHhVJR6pqcTpyAh2en04Eogs6GtdBn2ySMduwSa7BcOpbjpHUs89RthNh1YoHskSLSNlei22edy4u6IYb/b6sdvr+8TBx6V6LepTd5Cb7RZMzZ1PT/Q4EoggxG46RAAYmETLwk0WE3asrsZGqxk/6ziHn57pQuQqE0Mc8910Uj9EUUjfQbYOhTEYX7pOPkRSxsAkkihRAO4ocWJHnRsmtQq7vJ14pav3I0U3ZrXqsnZzFugUcrQGIumnHj1ZnFlJJCUs+iGSGI1chntdZdjmcSE8OY3/avNhf78/3QCgQKnAZrsl3W7Omu6mE8YL7V3wxcbA//ESLR7uMIlyjEWjxqM1lXiwugLHghHsbPPhvXAUOoUcG62X2s2V6a/sptPObjpEi4JHskQ5zmXQY7vHjTtKnXjtXD9+duYcLHkqbLFbUe+wwGXQ42Qk1U1nKIxT7KZDtCQYmEQ5aovdgh11btSZDHhnYAgj0zPYYDGhzmxEezSWnOgRCOG9ELvpEGUC7zCJcohcEPDFimJ8fW0N8pUKRKenoVHIUGMyoHUohP88dRYnQhEk2E2HKGcwMIkyREDyWciTq6vR4LRBLgoYik/itXMDaAmEcSwQwfjs4s+iJKLFwcAkWkKuAj022y24vdiOzfZCKEQZ+icm8K/ve/Hrzl5E2U2HSDIYmESLqFSvTbebq3daoV1/M0YHBqAbiWBPVx/+41QHhuLXNzGEiLKLgUl0ncxqFdYVmvCZIhvWWYyoyNdDLgqYu3ARKpmI6NQ0Lqy7BW2xOP7ix8+zeTmRxLFKlugqdAo5inVaFOvyUKzXokSnRWWBDlUFelg0aggALgIIT06hMzaOd0PDeD8SRf94HEPxSVa0EkkUq2SJPkQpinDq8lCsy0PJh4KxWJcHlUwGfzyBxNwcFKIIs1oFrUKOU5ER/LS9C7/3B3F2hN10iFYKBiYtWwIAW54GJfq81E4xGYQl+uTPZrUKgcQk+scTGJiIY2AigYMDQeiVcpTpdVhvNaE8X4d3Q9F0swBvNIbzbBZAtCLxSJYkzaBSJneGOi1KU0E4H4xOXR5Gp2fRPxHHwHgyEAcm4qnfJxBITEIuCrjJYk63m1tlLMCpyEhyokcgjJORKGbZb45oRWGnH5IktUyGYv1lR6Y6bXqHWKLT4gIuYiC1Q+xLBeH8bnFgIo7p81feIypEAWsLTem5kKvNRnSMjKb7sb4XHv7I1xDRysLApJwkFwQ4tJrkrvCyIJw/OtUpFBiMJ67cIY7H0Z/69djM1R/6ywQBFQU6eEwGeEwGPPyDH0E3HML7Lz2fHnl1IjiM+ByrV4noEgYmZU2hWoVivRalOi2K9ZeOTIt1Wtjy1AhPTl/aFY6njkwnEugfjyM8ObWgohqlKGKVsQAeUwHqzMmAdBvyEZqcgjcag3c4htmiUhw714tTZ31L/m8mIuliYNKS0SnkyV2h/tLOcH6XWKTLw+Tc+fS94eX3if0TcQzFE5/6jlCvUKDWVACP2QCPqQAekwFleh3OjY2jPTqKtuEYvNEYzoyM8u0jEX1qDEy6bkpRRFH6/jDvQ9WmWihE8YodYvI+MfnrwYnEDR15WjTqdCh6TAZ4zAUwq9XoGBlN7hyjo/AOx+CLjfHdIxEtCgYmXZUoAFaN5soq01Qwlui0MKmVGIpPpipMP3qfuFj9UEv1WnhMBahNhWOd2QC5IMAbHUV7NJYOyHNj4xyUTERLhoG5whlVyit2hiWXhaJDq0FseiZ9bzhw2R3iwEQcwcTUor49lAsCKgv06bvG+ZCcmJ1N7xi90RjaojH2XSWijGNgLnMauSy1I7y0QyyZf6yvz8P5CxeveIeYfqw/HsdgPLFkTynUMhlqjPnwmA3pnaPboMdQfDJdjDO/g+TkDiLKBWyNJ3FyQUi3cZvvWlOSPjbNg1ahwODEpecWAxMJnAgOp8MxE3MW85WK9I4xed9oQIlOi67R8dRxagyvdPbizMgoByMTkeRwh5lDLBr1R6pM53eIVk3y+cUVR6aXVZwu9PnFYrHlqS8rxEmGpEGlxJno6BV3jr7YGDvlEJGk8Eg2B7grK1Cqy4MsNnJFo++SVBu3xOxcOggv9TdNBqJ/IoG5LPQwFZAsxrl035gMR0EQ0keqbalinN6xCTYiJyLJY2Bmicugx21OG25z2vDZv/gOJqdncOBf/+kjXWsGJ+JZP6ZUiAJcBfnpHWOtyYBaYwFGZ2Yvu29MhmMgwWIcIlqeGJgZUqBU4FaHFbcV2dDgtOL8xYtoGgyiyR/CsXAUE7NzmMuBVmwauQw1xivfN1YV6DE4kbjifWP7yChiLMYhohWEgblEZIKANYXG1C7SCrchH8dDw6mQDOLc2ES2lwiDSpkuxKlLVas6tRp0xsYvhWM0ho6RUUyyGIeIVjgG5iKy52nQ4LTiM0U21DusCMQn0ewP4uBgECdCw1ntOGPP01zxvtFjMiBfqUD7yJXvG7ti41m5EyUiynUMzBugkom4xVaY3EUW2WBWq3B4KISmwSCa/SGEJqcyviZRAMr1utR946U7xwsXL8J7WT9VbzSG/vE4i3GIiBaIgfkpuQr0aChKFuvcZDXhTHQUzf4QmvxBnB4eyVhrNrlcDp1GA6dCltwxpgJylTEfI1Mz6VD0DiePVbMR3kREywkD8xPkzxfrOG24rciKCxeBJn8QTYNBtAyFM/Lwf54oAGvMyXvRx59+BvY163Hq755N3zV6ozG0R0evOQuSiIiuDwPzQ0QBWGs2pneR1alineZUSHZnuFjHodWgIVU4VO+wIpiYRJM/iJOJGfTNXkSbjzMciYgygYGJZHea25w2NDhtuNVhQWhyCk3+IJoHQzgWjGS0WCdPLsMmmwW3FVmx1WmDUaXEodSR76Es3YsSEdEKDUylKGKTvTC9c7No1Dg8FE6GpD+IYCJzoSQAqDUZ0OBMHvuuKTTiVGQktZYQ2qMxFuYQEeWAFROYVQV63Oa0osFpw81WMzpiY2hOvYk8lcFiHQCwatTYmgrIWx0WxGZmccgfRNNgCEeD4ax39iEioo9atoGpVyhwq8OSvosUgPQO8vBQOKOFMfPPT+ZD0panQctQCE3+EA75g/BztiMRUc5bNoF5eQVpQ5ENq4z5eDcURdNgAE3+ELpGxzO6nmpDfvKYtciG9Zbk85P5u8hM72iJiOjGSTowrRp1ujfrrQ4rIpNTaPKH0OwP4lgwsmTDjz+OSa3CVocFDU4btjqtmDl/If38pDUQxsRs9vvEEhHR9ZNUYCpFERtt5nRnHVue5orOOpmclKEURWywmlKFQzaU6rVoDYTRnArsvvF4xtZCRERLL+cDszJfl9pF2rDRaoYvNoYmfwhNgwGczPDRZmW+Dg3O5I72FlshukbH0wH5fjjKHqxERMtYzgWmTiFPd9ZpKLJCJghoGkze/bUMhTCawWKdAqUC9Q4rGlLVtaIANA0mA7IlEOZ4KyKiFSTrgSkAWG024raiZEjWmArwXiiavv/rzGCxjlwQsM5iSgekq0Cf7vLTnIXCISIiyh1ZCUyLRo3bUhWktzqsiE5Noyk1BivTxTqlei0anMmuOlvshegfT6QD8t0sj+QiIqLckZHAVIoibraa0xWtDm1e+h1i02Awo8U6OoUcW+yW9F2kRi5Hc6rt3KGhEIanpjO2FiIiko4lCcy8vDzcXFWB8tlJfKbIjo1WMzpHx9E0GMRBfxCnIiM4n6ECGVFIHfmmnnvUmgrwfjiaLtbpGBnLyDqIiEjaliQwn3rqKXzv6W/gZ3/eiIODQRzOcLHO/ISPBqcV9fZkM/XmLL3PJCKi5WFJAlMmk6GgoADRaPQGl7cwGrkMm22WVLGOFUa1CodSAXloKJTRZupERLQ8Zb1K9nokJ3wUpHeRawqNOB2JpYt1vJzwQUREi+xqgSnP9EI+iUWjxlaHNTkn0mHF6Mwsmv1B7PZ24mgggvgcW88REVHmZT0wVTIRG62FaCiyosFhg0OrQUtqZuW/vOvFYDyR7SUSERFl50jWPT/hw2nDBqsJHSPJmZXN/iBODccyVllLRET0YVm9wzSplLg11VVnq9OK2fMX0OwPoskfQutQGOOzmausJSIiupaM3mEqRAEbLObkhI8iK8r0OhwJhNHkD+E/Tp7hhA8iIpKcRQvMinxdujfrLbZCdI+N45A/hB8ePckJH0REJHk3dCT7nWeeRlnEj9rpCcgEAc2pFnic8EFERFK1JEeynrXrEGwZw5Ov/44TPoiIaFnL6cYFREREmXa1HaaY6YUQERFJ0TV3mERERJTEHSYREdECMDCJiIgWgIFJRES0AAxMIiKiBWBgEhERLQADk4iIaAH+F94X4GmJ6X1LAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -177,7 +193,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 4, @@ -194,8 +210,8 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:56.060548Z", - "start_time": "2020-12-17T13:42:55.849505Z" + "end_time": "2021-03-31T10:58:25.229669Z", + "start_time": "2021-03-31T10:58:25.003508Z" } }, "outputs": [ @@ -203,8 +219,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -221,7 +239,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 5, @@ -247,8 +265,8 @@ "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:56.781280Z", - "start_time": "2020-12-17T13:42:56.063042Z" + "end_time": "2021-03-31T10:58:26.048055Z", + "start_time": "2021-03-31T10:58:25.235072Z" } }, "outputs": [ @@ -256,8 +274,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { @@ -274,7 +294,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 6, @@ -291,8 +311,8 @@ "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-12-17T13:42:57.604314Z", - "start_time": "2020-12-17T13:42:56.786361Z" + "end_time": "2021-03-31T10:58:26.984242Z", + "start_time": "2021-03-31T10:58:26.054280Z" } }, "outputs": [ @@ -300,15 +320,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", " return _prepare_from_string(\" \".join(pjargs))\n", - "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.8/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", - " return _prepare_from_string(\" \".join(pjargs))\n" + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/pyproj/crs/crs.py:53: FutureWarning: '+init=:' syntax is deprecated. ':' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n", + " return _prepare_from_string(\" \".join(pjargs))\n", + "/Users/kasia.kozlowska/pycharm_venvs/genet/lib/python3.7/site-packages/osmnx/utils_graph.py:56: FutureWarning: Assigning CRS to a GeoDataFrame without a geometry column is now deprecated and will not be supported in the future.\n", + " gdf_nodes = gpd.GeoDataFrame(data, index=nodes, crs=crs)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -320,7 +344,7 @@ "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 7, @@ -384,18 +408,11 @@ "source": [ "n.schedule.generate_standard_outputs(output_dir='path/to/standard_outputs', gtfs_day='19700101')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (genet)", + "display_name": "genet", "language": "python", "name": "genet" }, @@ -409,7 +426,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.7.0" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/requirements.txt b/requirements.txt index 97d88ae3..e6c86b10 100644 --- a/requirements.txt +++ b/requirements.txt @@ -18,7 +18,7 @@ docutils==0.15.2 Fiona==1.8.13.post1 flake8==3.8.4 future==0.18.2 -geopandas==0.7.0 +geopandas==0.9.0 idna==2.9 importlib-metadata==1.6.0 ipykernel==5.3.0 diff --git a/tests/fixtures.py b/tests/fixtures.py index de28e38e..d65cf659 100644 --- a/tests/fixtures.py +++ b/tests/fixtures.py @@ -2,10 +2,12 @@ import sys, os import dictdiffer import pytest +import pandas as pd from collections import OrderedDict from genet.schedule_elements import Stop, Route, Service, Schedule -from genet.core import Network from genet.inputs_handler import osm_reader +import genet.modify.change_log as change_log +from genet.inputs_handler import read sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) pt2matsim_network_test_file = os.path.abspath( @@ -60,10 +62,8 @@ def assert_logging_warning_caught_with_message_containing(clog, message): ########################################################### @pytest.fixture() def network_object_from_test_data(): - n = Network('epsg:27700') - n.read_matsim_network(pt2matsim_network_test_file) - n.read_matsim_schedule(pt2matsim_schedule_file, pt2matsim_vehicles_file) - return n + return read.read_matsim(path_to_network=pt2matsim_network_test_file, path_to_schedule=pt2matsim_schedule_file, + path_to_vehicles=pt2matsim_vehicles_file, epsg='epsg:27700') ########################################################### @@ -71,9 +71,8 @@ def network_object_from_test_data(): ########################################################### @pytest.fixture() def schedule_object_from_test_data(): - s = Schedule('epsg:27700') - s.read_matsim_schedule(pt2matsim_schedule_file, pt2matsim_vehicles_file) - return s + return read.read_matsim_schedule(path_to_schedule=pt2matsim_schedule_file, path_to_vehicles=pt2matsim_vehicles_file, + epsg='epsg:27700') @pytest.fixture() @@ -96,9 +95,12 @@ def route(): 'vehicle_id': ['veh_1_bus']}, arrival_offsets=['00:00:00', '00:02:00'], departure_offsets=['00:00:00', '00:02:00']) -trips={'trip_id': ['1', '2'], - 'trip_departure_time': ['13:00:00', '13:30:00'], - 'vehicle_id': ['veh_1_bus', 'veh_2_bus']}, + + +trips = {'trip_id': ['1', '2'], + 'trip_departure_time': ['13:00:00', '13:30:00'], + 'vehicle_id': ['veh_1_bus', 'veh_2_bus']}, + @pytest.fixture() def similar_non_exact_test_route(): @@ -117,13 +119,13 @@ def test_service(): return Service(id='service', routes=[ Route(route_short_name='route', mode='bus', - stops=[Stop(id='0', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700'), - Stop(id='0', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700')], - trips={'trip_id': ['VJ00938baa194cee94700312812d208fe79f3297ee_04:40:00'], - 'trip_departure_time': ['04:40:00'], - 'vehicle_id': ['veh_1_bus']}, - arrival_offsets=['00:00:00', '00:02:00'], - departure_offsets=['00:00:00', '00:02:00']), + stops=[Stop(id='0', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700'), + Stop(id='0', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700')], + trips={'trip_id': ['VJ00938baa194cee94700312812d208fe79f3297ee_04:40:00'], + 'trip_departure_time': ['04:40:00'], + 'vehicle_id': ['veh_1_bus']}, + arrival_offsets=['00:00:00', '00:02:00'], + departure_offsets=['00:00:00', '00:02:00']), Route(route_short_name='route1', mode='bus', stops=[Stop(id='1', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700'), Stop(id='2', x=528504.1342843144, y=182155.7435136598, epsg='epsg:27700')], @@ -156,8 +158,9 @@ def correct_schedule(): Service(id='service', routes=[ Route(id='1', route_short_name='route', mode='bus', - stops=[Stop(id='0', x=529455.7452394223, y=182401.37630677427, epsg='epsg:27700', linkRefId='1'), - Stop(id='1', x=529350.7866124967, y=182388.0201078112, epsg='epsg:27700', linkRefId='2')], + stops=[ + Stop(id='0', x=529455.7452394223, y=182401.37630677427, epsg='epsg:27700', linkRefId='1'), + Stop(id='1', x=529350.7866124967, y=182388.0201078112, epsg='epsg:27700', linkRefId='2')], trips={'trip_id': ['VJ00938baa194cee94700312812d208fe79f3297ee_04:40:00'], 'trip_departure_time': ['04:40:00'], @@ -166,8 +169,9 @@ def correct_schedule(): departure_offsets=['00:00:00', '00:02:00'], route=['1', '2']), Route(id='2', route_short_name='route1', mode='bus', - stops=[Stop(id='0', x=529455.7452394223, y=182401.37630677427, epsg='epsg:27700', linkRefId='1'), - Stop(id='1', x=529350.7866124967, y=182388.0201078112, epsg='epsg:27700', linkRefId='2')], + stops=[ + Stop(id='0', x=529455.7452394223, y=182401.37630677427, epsg='epsg:27700', linkRefId='1'), + Stop(id='1', x=529350.7866124967, y=182388.0201078112, epsg='epsg:27700', linkRefId='2')], trips={'trip_id': ['Blep_04:40:00'], 'trip_departure_time': ['05:40:00'], 'vehicle_id': ['veh_2_bus']}, @@ -206,73 +210,56 @@ def test_schedule(): ########################################################### # correct gtfs vars ########################################################### -@pytest.fixture() -def correct_stop_times(): - return [{'trip_id': 'BT1', 'arrival_time': '03:21:00', 'departure_time': '03:21:00', 'stop_id': 'BSE', - 'stop_sequence': '0', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '1', - 'timepoint': '1', 'stop_direction_name': ''}, - {'trip_id': 'BT1', 'arrival_time': '03:23:00', 'departure_time': '03:23:00', 'stop_id': 'BSN', - 'stop_sequence': '1', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '0', - 'timepoint': '0', 'stop_direction_name': ''}, - {'trip_id': 'RT1', 'arrival_time': '03:21:00', 'departure_time': '03:21:00', 'stop_id': 'RSN', - 'stop_sequence': '0', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '0', - 'timepoint': '0', 'stop_direction_name': ''}, - {'trip_id': 'RT1', 'arrival_time': '03:23:00', 'departure_time': '03:23:00', 'stop_id': 'RSE', - 'stop_sequence': '1', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '1', - 'timepoint': '1', 'stop_direction_name': ''}] - - @pytest.fixture() def correct_stop_times_db(): - return {'BT1': [ - {'trip_id': 'BT1', 'arrival_time': '03:21:00', 'departure_time': '03:21:00', 'stop_id': 'BSE', - 'stop_sequence': '0', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '1', 'timepoint': '1', - 'stop_direction_name': ''}, - {'trip_id': 'BT1', 'arrival_time': '03:23:00', 'departure_time': '03:23:00', 'stop_id': 'BSN', - 'stop_sequence': '1', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '0', 'timepoint': '0', - 'stop_direction_name': ''}], 'RT1': [ - {'trip_id': 'RT1', 'arrival_time': '03:21:00', 'departure_time': '03:21:00', 'stop_id': 'RSN', - 'stop_sequence': '0', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '0', 'timepoint': '0', - 'stop_direction_name': ''}, - {'trip_id': 'RT1', 'arrival_time': '03:23:00', 'departure_time': '03:23:00', 'stop_id': 'RSE', - 'stop_sequence': '1', 'stop_headsign': '', 'pickup_type': '0', 'drop_off_type': '1', 'timepoint': '1', - 'stop_direction_name': ''}]} + return pd.DataFrame( + {'trip_id': {0: 'BT1', 1: 'BT1', 2: 'RT1', 3: 'RT1'}, + 'arrival_time': {0: '03:21:00', 1: '03:23:00', 2: '03:21:00', 3: '03:23:00'}, + 'departure_time': {0: '03:21:00', 1: '03:23:00', 2: '03:21:00', 3: '03:23:00'}, + 'stop_id': {0: 'BSE', 1: 'BSN', 2: 'RSN', 3: 'RSE'}, 'stop_sequence': {0: 0, 1: 1, 2: 0, 3: 1}, + 'stop_headsign': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'pickup_type': {0: 0, 1: 0, 2: 0, 3: 0}, + 'drop_off_type': {0: 1, 1: 0, 2: 0, 3: 1}, 'timepoint': {0: 1, 1: 0, 2: 0, 3: 1}, + 'stop_direction_name': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}} + ) @pytest.fixture() def correct_stops_db(): - return { - 'BSE': {'stop_id': 'BSE', 'stop_code': '', 'stop_name': 'Bus Stop snap to edge', 'stop_lat': '51.5226864', - 'stop_lon': '-0.1413621', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G433', 'platform_code': ''}, - 'BSN': {'stop_id': 'BSN', 'stop_code': '', 'stop_name': 'Bus Stop snap to node', 'stop_lat': '51.5216199', - 'stop_lon': '-0.140053', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G432', 'platform_code': ''}, - 'RSE': {'stop_id': 'RSE', 'stop_code': '', 'stop_name': 'Rail Stop snap to edge', 'stop_lat': '51.5192615', - 'stop_lon': '-0.1421595', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G431', 'platform_code': ''}, - 'RSN': {'stop_id': 'RSN', 'stop_code': '', 'stop_name': 'Rail Stop snap to node', 'stop_lat': '51.5231335', - 'stop_lon': '-0.1410946', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G430', 'platform_code': ''}} + return pd.DataFrame( + {'stop_id': {0: 'BSE', 1: 'BSN', 2: 'RSE', 3: 'RSN'}, + 'stop_code': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'stop_name': {0: 'Bus Stop snap to edge', 1: 'Bus Stop snap to node', 2: 'Rail Stop snap to edge', + 3: 'Rail Stop snap to node'}, + 'stop_lat': {0: 51.5226864, 1: 51.5216199, 2: 51.5192615, 3: 51.5231335}, + 'stop_lon': {0: -0.14136210000000002, 1: -0.140053, 2: -0.1421595, 3: -0.14109460000000001}, + 'wheelchair_boarding': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'stop_timezone': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'location_type': {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0}, + 'parent_station': {0: '210G433', 1: '210G432', 2: '210G431', 3: '210G430'}, + 'platform_code': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}} + ) @pytest.fixture() def correct_trips_db(): - return { - 'BT1': {'route_id': '1001', 'service_id': '6630', 'trip_id': 'BT1', 'trip_headsign': 'Bus Test trip', - 'block_id': '', 'wheelchair_accessible': '0', 'trip_direction_name': '', 'exceptional': ''}, - 'RT1': {'route_id': '1002', 'service_id': '6631', 'trip_id': 'RT1', 'trip_headsign': 'Rail Test trip', - 'block_id': '', 'wheelchair_accessible': '0', 'trip_direction_name': '', 'exceptional': ''}} + return pd.DataFrame( + {'route_id': {0: '1001', 1: '1002'}, 'service_id': {0: '6630', 1: '6631'}, 'trip_id': {0: 'BT1', 1: 'RT1'}, + 'trip_headsign': {0: 'Bus Test trip', 1: 'Rail Test trip'}, 'block_id': {0: float('nan'), 1: float('nan')}, + 'wheelchair_accessible': {0: 0, 1: 0}, 'trip_direction_name': {0: float('nan'), 1: float('nan')}, + 'exceptional': {0: float('nan'), 1: float('nan')}} + ) @pytest.fixture() def correct_routes_db(): - return {'1001': {'route_id': '1001', 'agency_id': 'OP550', 'route_short_name': 'BTR', - 'route_long_name': 'Bus Test Route', 'route_type': '3', 'route_url': '', - 'route_color': 'CE312D', 'route_text_color': 'FFFFFF', 'checkin_duration': ''}, - '1002': {'route_id': '1002', 'agency_id': 'OP550', 'route_short_name': 'RTR', - 'route_long_name': 'Rail Test Route', 'route_type': '2', 'route_url': '', - 'route_color': 'CE312D', 'route_text_color': 'FFFFFF', 'checkin_duration': ''}} + return pd.DataFrame( + {'route_id': {0: '1001', 1: '1002'}, 'agency_id': {0: 'OP550', 1: 'OP550'}, + 'route_short_name': {0: 'BTR', 1: 'RTR'}, 'route_long_name': {0: 'Bus Test Route', 1: 'Rail Test Route'}, + 'route_type': {0: 3, 1: 2}, 'route_url': {0: float('nan'), 1: float('nan')}, + 'route_color': {0: 'CE312D', 1: 'CE312D'}, + 'route_text_color': {0: 'FFFFFF', 1: 'FFFFFF'}, 'checkin_duration': {0: float('nan'), 1: float('nan')}} + ) @pytest.fixture() @@ -290,62 +277,58 @@ def correct_schedule_dict(): @pytest.fixture() -def correct_schedule_dict_from_test_gtfs(): - return {'1001': [ - {'route_short_name': 'BTR', 'route_long_name': 'Bus Test Route', 'mode': 'bus', 'route_color': '#CE312D', - 'trips': {'trip_id': ['BT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_0_bus']}, - 'stops': ['BSE', 'BSN'], 'arrival_offsets': ['0:00:00', '0:02:00'], - 'departure_offsets': ['0:00:00', '0:02:00'], 's2_stops': [5221390325135889957, 5221390684150342605]}], - '1002': [{'route_short_name': 'RTR', 'route_long_name': 'Rail Test Route', 'mode': 'rail', - 'route_color': '#CE312D', - 'trips': {'trip_id': ['RT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_1_rail']}, - 'stops': ['RSN', 'RSE'], - 'arrival_offsets': ['0:00:00', '0:02:00'], 'departure_offsets': ['0:00:00', '0:02:00'], - 's2_stops': [5221390332291192399, 5221390324026756531]}]} +def correct_schedule_graph_nodes_from_test_gtfs(): + return {'BSN': {'stop_code': float('nan'), 'name': 'Bus Stop snap to node', 'lat': 51.5216199, 'lon': -0.140053, + 'wheelchair_boarding': float('nan'), 'stop_timezone': float('nan'), 'location_type': 0.0, + 'parent_station': '210G432', + 'platform_code': float('nan'), 'id': 'BSN', 'x': -0.140053, 'y': 51.5216199, 'epsg': 'epsg:4326', + 's2_id': 5221390684150342605, 'routes': {'1001_0'}, 'services': {'1001'}}, + 'RSE': {'stop_code': float('nan'), 'name': 'Rail Stop snap to edge', 'lat': 51.5192615, 'lon': -0.1421595, + 'wheelchair_boarding': float('nan'), 'stop_timezone': float('nan'), 'location_type': 0.0, + 'parent_station': '210G431', + 'platform_code': float('nan'), 'id': 'RSE', 'x': -0.1421595, 'y': 51.5192615, 'epsg': 'epsg:4326', + 's2_id': 5221390324026756531, 'routes': {'1002_0'}, 'services': {'1002'}}, + 'RSN': {'stop_code': float('nan'), 'name': 'Rail Stop snap to node', 'lat': 51.5231335, + 'lon': -0.14109460000000001, + 'wheelchair_boarding': float('nan'), 'stop_timezone': float('nan'), 'location_type': 0.0, + 'parent_station': '210G430', + 'platform_code': float('nan'), 'id': 'RSN', 'x': -0.14109460000000001, 'y': 51.5231335, + 'epsg': 'epsg:4326', + 's2_id': 5221390332291192399, 'routes': {'1002_0'}, 'services': {'1002'}}, + 'BSE': {'stop_code': float('nan'), 'name': 'Bus Stop snap to edge', 'lat': 51.5226864, + 'lon': -0.14136210000000002, + 'wheelchair_boarding': float('nan'), 'stop_timezone': float('nan'), 'location_type': 0.0, + 'parent_station': '210G433', + 'platform_code': float('nan'), 'id': 'BSE', 'x': -0.14136210000000002, 'y': 51.5226864, + 'epsg': 'epsg:4326', + 's2_id': 5221390325135889957, 'routes': {'1001_0'}, 'services': {'1001'}}} @pytest.fixture() -def correct_stopdb_from_test_gtfs(): - return {'BSE': {'stop_id': 'BSE', 'stop_code': '', 'stop_name': 'Bus Stop snap to edge', 'stop_lat': '51.5226864', - 'stop_lon': '-0.1413621', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G433', 'platform_code': ''}, - 'BSN': {'stop_id': 'BSN', 'stop_code': '', 'stop_name': 'Bus Stop snap to node', 'stop_lat': '51.5216199', - 'stop_lon': '-0.140053', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G432', 'platform_code': ''}, - 'RSE': {'stop_id': 'RSE', 'stop_code': '', 'stop_name': 'Rail Stop snap to edge', 'stop_lat': '51.5192615', - 'stop_lon': '-0.1421595', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G431', 'platform_code': ''}, - 'RSN': {'stop_id': 'RSN', 'stop_code': '', 'stop_name': 'Rail Stop snap to node', 'stop_lat': '51.5231335', - 'stop_lon': '-0.1410946', 'wheelchair_boarding': '', 'stop_timezone': '', 'location_type': '0.0', - 'parent_station': '210G430', 'platform_code': ''}} +def correct_schedule_graph_edges_from_test_gtfs(): + return {'BSN': {}, 'RSE': {}, 'RSN': {'RSE': {'routes': {'1002_0'}, 'services': {'1002'}}}, + 'BSE': {'BSN': {'routes': {'1001_0'}, 'services': {'1001'}}}} @pytest.fixture() -def correct_services_from_test_gtfs(): - services = [] - services.append(Service( - '1001', - [Route( - route_short_name='BTR', - mode='bus', - stops=[Stop(id='BSE', x=-0.1413621, y=51.5226864, epsg='epsg:4326'), - Stop(id='BSN', x=-0.140053, y=51.5216199, epsg='epsg:4326')], - trips={'BT1': '03:21:00'}, - arrival_offsets=['0:00:00', '0:02:00'], - departure_offsets=['0:00:00', '0:02:00'] - )])) - services.append(Service( - '1002', - [Route( - route_short_name='RTR', - mode='rail', - stops=[Stop(id='RSN', x=-0.1410946, y=51.5231335, epsg='epsg:4326'), - Stop(id='RSE', x=-0.1421595, y=51.5192615, epsg='epsg:4326')], - trips={'RT1': '03:21:00'}, - arrival_offsets=['0:00:00', '0:02:00'], - departure_offsets=['0:00:00', '0:02:00'] - )])) - return services +def correct_schedule_graph_data_from_test_gtfs(): + return {'name': 'Schedule graph', 'crs': {'init': 'epsg:4326'}, + 'route_to_service_map': {'1001_0': '1001', '1002_0': '1002'}, + 'service_to_route_map': {'1001': ['1001_0'], '1002': ['1002_0']}, 'change_log': change_log.ChangeLog(), + 'routes': {'1001_0': {'arrival_offsets': ['00:00:00', '00:02:00'], 'route_color': 'CE312D', + 'ordered_stops': ['BSE', 'BSN'], 'mode': 'bus', 'route_type': 3, + 'departure_offsets': ['00:00:00', '00:02:00'], + 'route_long_name': 'Bus Test Route', 'route_short_name': 'BTR', + 'trips': {'trip_id': ['BT1'], 'trip_departure_time': ['03:21:00'], + 'vehicle_id': ['veh_0']}, 'service_id': '1001', 'id': '1001_0'}, + '1002_0': {'arrival_offsets': ['00:00:00', '00:02:00'], 'route_color': 'CE312D', + 'ordered_stops': ['RSN', 'RSE'], 'mode': 'rail', 'route_type': 2, + 'departure_offsets': ['00:00:00', '00:02:00'], + 'route_long_name': 'Rail Test Route', 'route_short_name': 'RTR', + 'trips': {'trip_id': ['RT1'], 'trip_departure_time': ['03:21:00'], + 'vehicle_id': ['veh_1']}, 'service_id': '1002', + 'id': '1002_0'}}, + 'services': {'1001': {'id': '1001', 'name': 'BTR'}, '1002': {'id': '1002', 'name': 'RTR'}}} @pytest.fixture() @@ -392,19 +375,26 @@ def correct_services_from_test_pt2matsim_schedule(): @pytest.fixture() def full_fat_default_config_path(): - return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "default_config.yml")) + return os.path.abspath( + os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "default_config.yml")) + @pytest.fixture() def full_fat_default_config(): - return osm_reader.Config(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "default_config.yml"))) + return osm_reader.Config( + os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "default_config.yml"))) + @pytest.fixture() def slim_default_config_path(): return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "slim_config.yml")) + @pytest.fixture() def slim_default_config(): - return osm_reader.Config(os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "slim_config.yml")) + return osm_reader.Config( + os.path.join(os.path.dirname(__file__), "..", "genet", "configs", "OSM", "slim_config.yml")) + ########################################################### # vehicle types configs diff --git a/tests/test_core_network.py b/tests/test_core_network.py index 429c77d0..58bd338d 100644 --- a/tests/test_core_network.py +++ b/tests/test_core_network.py @@ -7,15 +7,17 @@ import lxml import networkx as nx import pandas as pd +import geopandas as gpd import pytest from pandas.testing import assert_frame_equal, assert_series_equal -from shapely.geometry import LineString, Polygon +from shapely.geometry import LineString, Polygon, Point from genet.core import Network from genet.inputs_handler import matsim_reader from tests.test_outputs_handler_matsim_xml_writer import network_dtd, schedule_dtd from genet.schedule_elements import Route, Service, Schedule from genet.utils import plot, spatial +from genet.inputs_handler import read from tests.fixtures import assert_semantically_equal, route, stop_epsg_27700, network_object_from_test_data, \ full_fat_default_config_path, correct_schedule, vehicle_definitions_config_path @@ -442,9 +444,8 @@ def test_attempt_to_simplify_already_simplified_network_throws_error(): def test_simplifing_puma_network_results_in_correct_record_of_removed_links_and_expected_graph_data(): - n = Network('epsg:27700') - n.read_matsim_network(puma_network_test_file) - n.read_matsim_schedule(puma_schedule_test_file) + n = read.read_matsim(path_to_network=puma_network_test_file, epsg='epsg:27700', + path_to_schedule=puma_schedule_test_file) link_ids_pre_simplify = set(dict(n.links()).keys()) @@ -468,9 +469,8 @@ def test_simplifing_puma_network_results_in_correct_record_of_removed_links_and_ def test_simplified_network_saves_to_correct_dtds(tmpdir, network_dtd, schedule_dtd): - n = Network('epsg:27700') - n.read_matsim_network(puma_network_test_file) - n.read_matsim_schedule(puma_schedule_test_file) + n = read.read_matsim(path_to_network=puma_network_test_file, epsg='epsg:27700', + path_to_schedule=puma_schedule_test_file) n.simplify() @@ -530,9 +530,8 @@ def test_simplifying_network_with_multi_edges_resulting_in_multi_paths(): def test_reading_back_simplified_network(): # simplified networks have additional geometry attribute and some of their attributes are composite, e.g. links # now refer to a number of osm ways each with a unique id - n = Network('epsg:27700') - n.read_matsim_network(simplified_network) - n.read_matsim_schedule(simplified_schedule) + n = read.read_matsim(path_to_network=simplified_network, epsg='epsg:27700', + path_to_schedule=simplified_schedule) number_of_simplified_links = 659 @@ -550,8 +549,7 @@ def test_reading_back_simplified_network(): def test_network_with_missing_link_attribute_elem_text_is_read_and_able_to_save_again(tmpdir): - n = Network('epsg:27700') - n.read_matsim_network(network_link_attrib_text_missing) + n = read.read_matsim(path_to_network=network_link_attrib_text_missing, epsg='epsg:27700') n.write_to_matsim(tmpdir) @@ -1697,8 +1695,7 @@ def test_schedule_routes_with_disconnected_routes(network_object_from_test_data) def test_reads_osm_network_into_the_right_schema(full_fat_default_config_path): osm_test_file = os.path.abspath( os.path.join(os.path.dirname(__file__), "test_data", "osm", "osm.xml")) - network = Network('epsg:27700') - network.read_osm(osm_test_file, full_fat_default_config_path, 1) + network = read.read_osm(osm_test_file, full_fat_default_config_path, 1, 'epsg:27700') assert_semantically_equal(dict(network.nodes()), { '0': {'id': '0', 'x': 622502.8306679451, 'y': -5526117.781903352, 'lat': 0.008554364250688652, 'lon': -0.0006545205888310243, 's2_id': 1152921492875543713}, @@ -1814,22 +1811,12 @@ def test_reads_osm_network_into_the_right_schema(full_fat_default_config_path): assert satisfied -def test_read_matsim_network_delegates_to_matsim_reader_read_network(mocker): - mocker.patch.object(matsim_reader, 'read_network', return_value=(nx.MultiDiGraph(), 2, {}, {})) - - network = Network('epsg:27700') - network.read_matsim_network(pt2matsim_network_test_file) - - matsim_reader.read_network.assert_called_once_with(pt2matsim_network_test_file, network.transformer) - - def test_read_matsim_network_with_duplicated_node_ids_records_removal_in_changelog(mocker): dup_nodes = {'21667818': [ {'id': '21667818', 'x': 528504.1342843144, 'y': 182155.7435136598, 'lon': -0.14910908709500162, 'lat': 51.52370573323939, 's2_id': 5221390302696205321}]} mocker.patch.object(matsim_reader, 'read_network', return_value=(nx.MultiDiGraph(), 2, dup_nodes, {})) - network = Network('epsg:27700') - network.read_matsim_network(pt2matsim_network_test_file) + network = read.read_matsim(path_to_network=pt2matsim_network_test_file, epsg='epsg:27700') correct_change_log_df = pd.DataFrame( {'timestamp': {0: '2020-07-02 11:36:54'}, 'change_event': {0: 'remove'}, 'object_type': {0: 'node'}, @@ -1857,8 +1844,7 @@ def test_read_matsim_network_with_duplicated_link_ids_records_reindexing_in_chan mocker.patch.object(matsim_reader, 'read_network', return_value=(nx.MultiDiGraph(), correct_link_id_map, {}, dup_links)) mocker.patch.object(Network, 'link', return_value={'heyooo': '1'}) - network = Network('epsg:27700') - network.read_matsim_network(pt2matsim_network_test_file) + network = read.read_matsim(path_to_network=pt2matsim_network_test_file, epsg='epsg:27700') correct_change_log_df = pd.DataFrame( {'timestamp': {0: '2020-07-02 11:59:00'}, 'change_event': {0: 'modify'}, 'object_type': {0: 'link'}, @@ -1871,15 +1857,6 @@ def test_read_matsim_network_with_duplicated_link_ids_records_reindexing_in_chan check_dtype=False) -def test_read_matsim_schedule_runs_schedule_read_matsim_schedule_using_epsg_from_earlier_network_run(mocker): - mocker.patch.object(Schedule, 'read_matsim_schedule') - network = Network('epsg:27700') - network.read_matsim_network(pt2matsim_network_test_file) - network.read_matsim_schedule(pt2matsim_schedule_file, vehicles_path='') - - Schedule.read_matsim_schedule.assert_called_once_with(pt2matsim_schedule_file, '') - - def test_has_node_when_node_is_in_the_graph(): n = Network('epsg:27700') n.add_node('1') @@ -2425,3 +2402,149 @@ def test_saving_network_with_auxiliary_files_with_changes(aux_network, tmpdir): assert json.load(json_file)['car']['2']['in']['links'] == ['002'] assert pd.read_csv(expected_csv_aux_file)['links'].to_dict() == {0: '[None]', 1: '[None]', 2: '[None]', 3: "['04']"} + + +@pytest.fixture() +def network_1_geo_and_json(network1): + nodes = gpd.GeoDataFrame({ + '101982': {'id': '101982', 'x': '528704.1425925883', 'y': '182068.78193707118', 'lon': -0.14625948709424305, + 'lat': 51.52287873323954, 's2_id': 5221390329378179879, + 'geometry': Point(528704.1425925883, 182068.78193707118)}, + '101986': {'id': '101986', 'x': '528835.203274008', 'y': '182006.27331298392', 'lon': -0.14439428709377497, + 'lat': 51.52228713323965, 's2_id': 5221390328605860387, + 'geometry': Point(528835.203274008, 182006.27331298392)}}).T + nodes.index = nodes.index.set_names(['index']) + links = gpd.GeoDataFrame({ + '0': {'id': '0', 'from': '101982', 'to': '101986', 'freespeed': 4.166666666666667, 'capacity': 600.0, + 'permlanes': 1.0, 'oneway': '1', 'modes': ['car', 'bike'], 's2_from': 5221390329378179879, + 's2_to': 5221390328605860387, 'length': 52.765151087870265, + 'geometry': LineString( + [(528704.1425925883, 182068.78193707118), (528835.203274008, 182006.27331298392)]), + 'u': '101982', 'v': '101986', + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', + 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', + 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', + 'text': 'Brunswick Place'}}}}).T + links.index = links.index.set_names(['index']) + + # most networks are expected to have complex geometries + network1.apply_attributes_to_links( + {'0': { + 'modes': ['car', 'bike'], + 'geometry': LineString([(528704.1425925883, 182068.78193707118), (528835.203274008, 182006.27331298392)])}}) + + return { + 'network': network1, + 'expected_json': {'nodes': { + '101982': {'id': '101982', 'x': '528704.1425925883', 'y': '182068.78193707118', 'lon': -0.14625948709424305, + 'lat': 51.52287873323954, 's2_id': 5221390329378179879, + 'geometry': [528704.1425925883, 182068.78193707118]}, + '101986': {'id': '101986', 'x': '528835.203274008', 'y': '182006.27331298392', 'lon': -0.14439428709377497, + 'lat': 51.52228713323965, 's2_id': 5221390328605860387, + 'geometry': [528835.203274008, 182006.27331298392]}}, + 'links': { + '0': {'id': '0', 'from': '101982', 'to': '101986', 'freespeed': 4.166666666666667, 'capacity': 600.0, + 'permlanes': 1.0, 'oneway': '1', 'modes': ['car', 'bike'], 's2_from': 5221390329378179879, + 's2_to': 5221390328605860387, 'length': 52.765151087870265, + 'geometry': 'ez~hinaBc~sze|`@gx|~W|uo|J', 'u': '101982', 'v': '101986', + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', + 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', + 'text': 'Brunswick Place'}}}}}, + 'expected_sanitised_json': {'nodes': { + '101982': {'id': '101982', 'x': '528704.1425925883', 'y': '182068.78193707118', 'lon': -0.14625948709424305, + 'lat': 51.52287873323954, 's2_id': 5221390329378179879, + 'geometry': '528704.1425925883,182068.78193707118'}, + '101986': {'id': '101986', 'x': '528835.203274008', 'y': '182006.27331298392', 'lon': -0.14439428709377497, + 'lat': 51.52228713323965, 's2_id': 5221390328605860387, + 'geometry': '528835.203274008,182006.27331298392'}}, + 'links': { + '0': {'id': '0', 'from': '101982', 'to': '101986', 'freespeed': 4.166666666666667, 'capacity': 600.0, + 'permlanes': 1.0, 'oneway': '1', 'modes': 'car,bike', 's2_from': 5221390329378179879, + 's2_to': 5221390328605860387, 'length': 52.765151087870265, + 'geometry': 'ez~hinaBc~sze|`@gx|~W|uo|J', 'u': '101982', 'v': '101986', + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', + 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', + 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', + 'text': 'Brunswick Place'}}}}}, + 'expected_geodataframe': {'nodes': nodes, 'links': links} + } + + +def test_transforming_network_to_json(network_1_geo_and_json): + assert_semantically_equal(network_1_geo_and_json['network'].to_json(), network_1_geo_and_json['expected_json']) + + +def test_saving_network_to_json(network_1_geo_and_json, tmpdir): + network_1_geo_and_json['network'].write_to_json(tmpdir) + expected_network_json = os.path.join(tmpdir, 'network.json') + assert os.path.exists(expected_network_json) + with open(expected_network_json) as json_file: + output_json = json.load(json_file) + assert_semantically_equal( + output_json, + network_1_geo_and_json['expected_sanitised_json']) + + +def test_transforming_network_to_geodataframe(network_1_geo_and_json): + node_cols = ['id', 'x', 'y', 'lon', 'lat', 's2_id', 'geometry'] + link_cols = ['id', 'from', 'to', 'freespeed', 'capacity', 'permlanes', 'oneway', 'modes', 's2_from', 's2_to', + 'length', 'geometry', 'attributes', 'u', 'v'] + _network = network_1_geo_and_json['network'].to_geodataframe() + assert set(_network['nodes'].columns) == set(node_cols) + assert_frame_equal(_network['nodes'][node_cols], network_1_geo_and_json['expected_geodataframe']['nodes'][node_cols], check_dtype=False) + assert set(_network['links'].columns) == set(link_cols) + assert_frame_equal(_network['links'][link_cols], network_1_geo_and_json['expected_geodataframe']['links'][link_cols], check_dtype=False) + + +def test_saving_network_to_geojson(network1, correct_schedule, tmpdir): + network1.schedule = correct_schedule + network1.write_to_geojson(tmpdir) + assert set(os.listdir(tmpdir)) == {'network_nodes_geometry_only.geojson', 'network_nodes.geojson', + 'network_change_log.csv', 'schedule_links_geometry_only.geojson', + 'network_links.geojson', 'network_links_geometry_only.geojson', + 'schedule_nodes_geometry_only.geojson', 'schedule_links.geojson', + 'schedule_nodes.geojson', 'schedule_change_log.csv'} + + +def test_saving_network_to_csv(network1, correct_schedule, tmpdir): + network1.schedule = correct_schedule + network1.write_to_csv(tmpdir) + assert set(os.listdir(tmpdir)) == {'network', 'schedule'} + assert set(os.listdir(os.path.join(tmpdir, 'network'))) == {'nodes.csv', 'links.csv', 'network_change_log.csv'} + assert set(os.listdir(os.path.join(tmpdir, 'schedule'))) == {'calendar.csv', 'stop_times.csv', 'trips.csv', + 'routes.csv', 'schedule_change_log.csv', 'stops.csv'} + output_nodes = pd.read_csv(os.path.join(tmpdir, 'network', 'nodes.csv')) + assert_semantically_equal( + output_nodes.to_dict(), + {'index': {0: 101982, 1: 101986}, 'lat': {0: 51.52287873323954, 1: 51.52228713323965}, + 's2_id': {0: 5221390329378179879, 1: 5221390328605860387}, + 'lon': {0: -0.14625948709424305, 1: -0.14439428709377494}, 'id': {0: 101982, 1: 101986}, + 'x': {0: 528704.1425925883, 1: 528835.203274008}, + 'geometry': {0: '[528704.1425925883, 182068.78193707118]', + 1: '[528835.203274008, 182006.27331298392]'}, + 'y': {0: 182068.7819370712, 1: 182006.27331298392}} + ) + output_links = pd.read_csv(os.path.join(tmpdir, 'network', 'links.csv')) + assert_semantically_equal( + output_links.to_dict(), + {'index': {0: 0}, 'modes': {0: "['car']"}, 'to': {0: 101986}, 's2_from': {0: 5221390329378179879}, + 'length': {0: 52.76515108787025}, 'id': {0: 0}, 'from': {0: 101982}, 's2_to': {0: 5221390328605860387}, + 'capacity': {0: 600.0}, + 'u': {0: 101982}, + 'v': {0: 101986}, + 'geometry': {0: 'ez~hinaBc~sze|`@gx|~W|uo|J'}, + 'oneway': {0: 1}, 'freespeed': {0: 4.166666666666667}, 'permlanes': {0: 1.0}, 'attributes': { + 0: "{'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}"}} + ) diff --git a/tests/test_core_schedule.py b/tests/test_core_schedule.py index 21b17291..cc9c77b2 100644 --- a/tests/test_core_schedule.py +++ b/tests/test_core_schedule.py @@ -8,6 +8,7 @@ from tests.test_core_components_route import self_looping_route, route from tests.test_core_components_service import service from genet.inputs_handler import matsim_reader, gtfs_reader +from genet.inputs_handler import read from genet.schedule_elements import Schedule, Service, Route, Stop, read_vehicle_types from genet.utils import plot, spatial from genet.validate import schedule_validation @@ -19,7 +20,6 @@ os.path.join(os.path.dirname(__file__), "test_data", "matsim", "schedule.xml")) pt2matsim_vehicles_file = os.path.abspath( os.path.join(os.path.dirname(__file__), "test_data", "matsim", "vehicles.xml")) -gtfs_test_file = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "gtfs")) @pytest.fixture() @@ -919,18 +919,10 @@ def test_iter_stops_returns_stops_objects(test_service, different_test_service): assert all([isinstance(stop, Stop) for stop in schedule.stops()]) -def test_read_matsim_schedule_delegates_to_matsim_reader_read_schedule(mocker, route): - mocker.patch.object(matsim_reader, 'read_schedule', return_value=([Service(id='1', routes=[route])], {})) - - schedule = Schedule('epsg:27700') - schedule.read_matsim_schedule(pt2matsim_schedule_file) - - matsim_reader.read_schedule.assert_called_once_with(pt2matsim_schedule_file, schedule.epsg) - - def test_read_matsim_schedule_returns_expected_schedule(): - schedule = Schedule('epsg:27700') - schedule.read_matsim_schedule(pt2matsim_schedule_file) + schedule = read.read_matsim_schedule( + path_to_schedule=pt2matsim_schedule_file, + epsg='epsg:27700') correct_services = Service(id='10314', routes=[ Route( @@ -973,8 +965,10 @@ def test_read_matsim_schedule_returns_expected_schedule(): def test_reading_vehicles_with_a_schedule(): - schedule = Schedule('epsg:27700') - schedule.read_matsim_schedule(pt2matsim_schedule_file, pt2matsim_vehicles_file) + schedule = read.read_matsim_schedule( + path_to_schedule=pt2matsim_schedule_file, + path_to_vehicles=pt2matsim_vehicles_file, + epsg='epsg:27700') assert_semantically_equal(schedule.vehicles, {'veh_0_bus': {'type': 'bus'}}) assert_semantically_equal(schedule.vehicle_types['bus'], { @@ -988,9 +982,10 @@ def test_reading_vehicles_with_a_schedule(): def test_reading_vehicles_after_reading_schedule(): - schedule = Schedule('epsg:27700') - schedule.read_matsim_schedule(pt2matsim_schedule_file) - schedule.read_matsim_vehicles(pt2matsim_vehicles_file) + schedule = read.read_matsim_schedule( + path_to_schedule=pt2matsim_schedule_file, + path_to_vehicles=pt2matsim_vehicles_file, + epsg='epsg:27700') assert_semantically_equal(schedule.vehicles, {'veh_0_bus': {'type': 'bus'}}) assert_semantically_equal(schedule.vehicle_types['bus'], { @@ -1003,37 +998,6 @@ def test_reading_vehicles_after_reading_schedule(): 'passengerCarEquivalents': {'pce': '2.8'}}) -def test_read_gtfs_returns_expected_schedule(correct_stops_to_service_mapping_from_test_gtfs, - correct_stops_to_route_mapping_from_test_gtfs): - schedule = Schedule('epsg:4326') - schedule.read_gtfs_schedule(gtfs_test_file, '20190604') - - assert schedule['1001'] == Service( - '1001', - [Route( - route_short_name='BTR', - mode='bus', - stops=[Stop(id='BSE', x=-0.1413621, y=51.5226864, epsg='epsg:4326'), - Stop(id='BSN', x=-0.140053, y=51.5216199, epsg='epsg:4326')], - trips={'trip_id': ['BT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_0_bus']}, - arrival_offsets=['0:00:00', '0:02:00'], - departure_offsets=['0:00:00', '0:02:00'] - )]) - assert schedule['1002'] == Service( - '1002', - [Route( - route_short_name='RTR', - mode='rail', - stops=[Stop(id='RSN', x=-0.1410946, y=51.5231335, epsg='epsg:4326'), - Stop(id='RSE', x=-0.1421595, y=51.5192615, epsg='epsg:4326')], - trips={'trip_id': ['RT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_1_rail']}, - arrival_offsets=['0:00:00', '0:02:00'], - departure_offsets=['0:00:00', '0:02:00'] - )]) - assert_semantically_equal(schedule.stop_to_service_ids_map(), correct_stops_to_service_mapping_from_test_gtfs) - assert_semantically_equal(schedule.stop_to_route_ids_map(), correct_stops_to_route_mapping_from_test_gtfs) - - def test_is_strongly_connected_with_strongly_connected_schedule(strongly_connected_schedule): assert strongly_connected_schedule.is_strongly_connected() @@ -1179,7 +1143,7 @@ def test_building_trips_dataframe(schedule): def test_generating_vehicles(schedule): schedule.generate_vehicles() assert_semantically_equal(schedule.vehicles, {'veh_3_bus': {'type': 'bus'}, 'veh_2_bus': {'type': 'bus'}, - 'veh_1_bus': {'type': 'bus'}, 'veh_4_bus': {'type': 'bus'}}) + 'veh_1_bus': {'type': 'bus'}, 'veh_4_bus': {'type': 'bus'}}) def test_generating_vehicles_with_shared_vehicles_and_consistent_modes(mocker, schedule): @@ -1212,8 +1176,8 @@ def test_generating_additional_vehicles_by_default(schedule): 'veh_2_bus': {'type': '_bus'}} schedule.generate_vehicles() assert_semantically_equal(schedule.vehicles, {'veh_3_bus': {'type': '_bus'}, 'veh_4_bus': {'type': '_bus'}, - 'veh_1_bus': {'type': '_bus'}, 'veh_2_bus': {'type': '_bus'}, - 'some_bus_2': {'type': 'bus'}}) + 'veh_1_bus': {'type': '_bus'}, 'veh_2_bus': {'type': '_bus'}, + 'some_bus_2': {'type': 'bus'}}) def test_generating_new_vehicles_with_overwite_True(schedule): @@ -1223,7 +1187,7 @@ def test_generating_new_vehicles_with_overwite_True(schedule): 'veh_2_bus': {'type': '_bus'}} schedule.generate_vehicles(overwrite=True) assert_semantically_equal(schedule.vehicles, {'veh_3_bus': {'type': 'bus'}, 'veh_4_bus': {'type': 'bus'}, - 'veh_1_bus': {'type': 'bus'}, 'veh_2_bus': {'type': 'bus'}}) + 'veh_1_bus': {'type': 'bus'}, 'veh_2_bus': {'type': 'bus'}}) def test_rejects_inconsistent_modes_when_generating_vehicles(mocker, schedule): @@ -1433,3 +1397,201 @@ def test_reading_vehicle_types_from_a_yml_config(vehicle_definitions_config_path 'length': {'meter': '50.0'}, 'width': {'meter': '6.0'}, 'accessTime': {'secondsPerPerson': '0.5'}, 'egressTime': {'secondsPerPerson': '0.5'}, 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '7.1'}}}) + + +@pytest.fixture() +def json_schedule(): + return {'schedule': {'stops': { + '5': {'y': 2.0, 'name': '', 'id': '5', 'x': 4.0, 'lon': -7.557106577683727, 'lat': 49.76682779861249, + 's2_id': 5205973754090531959}, + '6': {'y': 2.0, 'name': '', 'id': '6', 'x': 1.0, 'lon': -7.557148039524952, 'lat': 49.766825803756994, + 's2_id': 5205973754090365183}, + '7': {'y': 3.0, 'name': '', 'id': '7', 'x': 3.0, 'lon': -7.557121424907424, 'lat': 49.76683608549253, + 's2_id': 5205973754090203369}, + '8': {'y': 5.0, 'name': '', 'id': '8', 'x': 7.0, 'lon': -7.5570681956375, 'lat': 49.766856648946295, + 's2_id': 5205973754097123809}, + '3': {'y': 3.0, 'name': '', 'id': '3', 'x': 3.0, 'lon': -7.557121424907424, 'lat': 49.76683608549253, + 's2_id': 5205973754090203369}, + '4': {'y': 5.0, 'name': '', 'id': '4', 'x': 7.0, 'lon': -7.5570681956375, 'lat': 49.766856648946295, + 's2_id': 5205973754097123809}, + '1': {'y': 2.0, 'name': '', 'id': '1', 'x': 4.0, 'lon': -7.557106577683727, 'lat': 49.76682779861249, + 's2_id': 5205973754090531959}, + '2': {'y': 2.0, 'name': '', 'id': '2', 'x': 1.0, 'lon': -7.557148039524952, 'lat': 49.766825803756994, + 's2_id': 5205973754090365183}}, + 'services': {'service': {'id': 'service', 'name': 'name', 'routes': { + '1': {'route_short_name': 'name', 'mode': 'bus', + 'trips': {'trip_id': ['1', '2'], 'trip_departure_time': ['13:00:00', '13:30:00'], + 'vehicle_id': ['veh_1_bus', 'veh_2_bus']}, + 'arrival_offsets': ['00:00:00', '00:03:00', '00:07:00', '00:13:00'], + 'departure_offsets': ['00:00:00', '00:05:00', '00:09:00', '00:15:00'], 'route_long_name': '', + 'id': '1', 'route': [], 'await_departure': [], 'ordered_stops': ['1', '2', '3', '4']}, + '2': {'route_short_name': 'name_2', 'mode': 'bus', + 'trips': {'trip_id': ['1', '2'], 'trip_departure_time': ['11:00:00', '13:00:00'], + 'vehicle_id': ['veh_3_bus', 'veh_4_bus']}, + 'arrival_offsets': ['00:00:00', '00:03:00', '00:07:00', '00:13:00'], + 'departure_offsets': ['00:00:00', '00:05:00', '00:09:00', '00:15:00'], 'route_long_name': '', + 'id': '2', 'route': [], 'await_departure': [], 'ordered_stops': ['5', '6', '7', '8']}}}}}, + 'vehicles': {'vehicle_types': { + 'bus': {'capacity': {'seats': {'persons': '70'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '18.0'}, 'width': {'meter': '2.5'}, 'accessTime': {'secondsPerPerson': '0.5'}, + 'egressTime': {'secondsPerPerson': '0.5'}, 'doorOperation': {'mode': 'serial'}, + 'passengerCarEquivalents': {'pce': '2.8'}}, + 'rail': {'capacity': {'seats': {'persons': '1000'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '200.0'}, 'width': {'meter': '2.8'}, + 'accessTime': {'secondsPerPerson': '0.25'}, 'egressTime': {'secondsPerPerson': '0.25'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '27.1'}}, + 'subway': {'capacity': {'seats': {'persons': '1000'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '30.0'}, 'width': {'meter': '2.45'}, + 'accessTime': {'secondsPerPerson': '0.1'}, 'egressTime': {'secondsPerPerson': '0.1'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '4.4'}}, + 'ferry': {'capacity': {'seats': {'persons': '250'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '50.0'}, 'width': {'meter': '6.0'}, + 'accessTime': {'secondsPerPerson': '0.5'}, 'egressTime': {'secondsPerPerson': '0.5'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '7.1'}}, + 'tram': {'capacity': {'seats': {'persons': '180'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '36.0'}, 'width': {'meter': '2.4'}, + 'accessTime': {'secondsPerPerson': '0.25'}, 'egressTime': {'secondsPerPerson': '0.25'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '5.2'}}, + 'funicular': {'capacity': {'seats': {'persons': '180'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '36.0'}, 'width': {'meter': '2.4'}, + 'accessTime': {'secondsPerPerson': '0.25'}, 'egressTime': {'secondsPerPerson': '0.25'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '5.2'}}, + 'gondola': {'capacity': {'seats': {'persons': '250'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '50.0'}, 'width': {'meter': '6.0'}, + 'accessTime': {'secondsPerPerson': '0.5'}, 'egressTime': {'secondsPerPerson': '0.5'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '7.1'}}, + 'cablecar': {'capacity': {'seats': {'persons': '250'}, 'standingRoom': {'persons': '0'}}, + 'length': {'meter': '50.0'}, 'width': {'meter': '6.0'}, + 'accessTime': {'secondsPerPerson': '0.5'}, 'egressTime': {'secondsPerPerson': '0.5'}, + 'doorOperation': {'mode': 'serial'}, 'passengerCarEquivalents': {'pce': '7.1'}}}, + 'vehicles': {'veh_3_bus': {'type': 'bus'}, 'veh_4_bus': {'type': 'bus'}, + 'veh_1_bus': {'type': 'bus'}, 'veh_2_bus': {'type': 'bus'}}}} + + +def test_transforming_schedule_to_json(schedule, json_schedule): + assert_semantically_equal(schedule.to_json(), json_schedule) + + +def test_writing_schedule_to_json(schedule, json_schedule, tmpdir): + schedule.write_to_json(tmpdir) + expected_schedule_json = os.path.join(tmpdir, 'schedule.json') + assert os.path.exists(expected_schedule_json) + with open(expected_schedule_json) as json_file: + output_json = json.load(json_file) + assert_semantically_equal(output_json, json_schedule) + + +def test_transforming_schedule_to_gtfs(schedule): + gtfs = schedule.to_gtfs(gtfs_day='19700101') + assert_semantically_equal( + gtfs['stops'].to_dict(), + {'stop_id': {'5': '5', '6': '6', '7': '7', '8': '8', '3': '3', '2': '2', '4': '4', '1': '1'}, + 'stop_name': {'5': '', '6': '', '7': '', '8': '', '3': '', '2': '', '4': '', '1': ''}, + 'stop_lat': {'5': 49.76682779861249, '6': 49.766825803756994, '7': 49.76683608549253, '8': 49.766856648946295, + '3': 49.76683608549253, '2': 49.766825803756994, '4': 49.766856648946295, '1': 49.76682779861249}, + 'stop_lon': {'5': -7.557106577683727, '6': -7.557148039524952, '7': -7.557121424907424, '8': -7.5570681956375, + '3': -7.557121424907424, '2': -7.557148039524952, '4': -7.5570681956375, '1': -7.557106577683727}, + 'stop_code': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), '3': float('nan'), + '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'stop_desc': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), '3': float('nan'), + '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'zone_id': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), '3': float('nan'), + '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'stop_url': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), '3': float('nan'), + '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'location_type': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), + '3': float('nan'), '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'parent_station': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), + '3': float('nan'), '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'stop_timezone': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), + '3': float('nan'), '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'wheelchair_boarding': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), + '3': float('nan'), '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'level_id': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), '3': float('nan'), + '2': float('nan'), '4': float('nan'), '1': float('nan')}, + 'platform_code': {'5': float('nan'), '6': float('nan'), '7': float('nan'), '8': float('nan'), + '3': float('nan'), '2': float('nan'), '4': float('nan'), '1': float('nan')}} + ) + assert_semantically_equal( + gtfs['routes'].to_dict(), + {'route_id': {0: 'service'}, 'route_short_name': {0: 'name_2'}, 'route_long_name': {0: ''}, + 'agency_id': {0: float('nan')}, 'route_desc': {0: float('nan')}, 'route_url': {0: float('nan')}, + 'route_type': {0: 3}, + 'route_color': {0: float('nan')}, 'route_text_color': {0: float('nan')}, 'route_sort_order': {0: float('nan')}, + 'continuous_pickup': {0: float('nan')}, 'continuous_drop_off': {0: float('nan')}} + ) + assert_semantically_equal( + gtfs['trips'].to_dict(), + {'route_id': {0: 'service', 1: 'service', 2: 'service', 3: 'service'}, + 'service_id': {0: 'service', 1: 'service', 2: 'service', 3: 'service'}, + 'trip_id': {0: '1', 1: '2', 2: '1', 3: '2'}, + 'trip_headsign': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'trip_short_name': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'direction_id': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'block_id': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'shape_id': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'wheelchair_accessible': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}, + 'bikes_allowed': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan')}} + ) + assert_semantically_equal( + gtfs['stop_times'].to_dict(), + {'trip_id': {0: '1', 1: '1', 2: '1', 3: '1', 4: '2', 5: '2', 6: '2', 7: '2', 8: '1', 9: '1', 10: '1', 11: '1', + 12: '2', 13: '2', 14: '2', 15: '2'}, + 'stop_id': {0: '5', 1: '6', 2: '7', 3: '8', 4: '5', 5: '6', 6: '7', 7: '8', 8: '1', 9: '2', 10: '3', 11: '4', + 12: '1', 13: '2', 14: '3', 15: '4'}, + 'stop_sequence': {0: 0, 1: 1, 2: 2, 3: 3, 4: 0, 5: 1, 6: 2, 7: 3, 8: 0, 9: 1, 10: 2, 11: 3, 12: 0, 13: 1, + 14: 2, 15: 3}, + 'departure_time': {0: '11:00:00', 1: '11:05:00', 2: '11:09:00', 3: '11:15:00', 4: '13:00:00', 5: '13:05:00', + 6: '13:09:00', 7: '13:15:00', 8: '13:00:00', 9: '13:05:00', 10: '13:09:00', 11: '13:15:00', + 12: '13:30:00', 13: '13:35:00', 14: '13:39:00', 15: '13:45:00'}, + 'arrival_time': {0: '11:00:00', 1: '11:03:00', 2: '11:07:00', 3: '11:13:00', 4: '13:00:00', 5: '13:03:00', + 6: '13:07:00', 7: '13:13:00', 8: '13:00:00', 9: '13:03:00', 10: '13:07:00', 11: '13:13:00', + 12: '13:30:00', 13: '13:33:00', 14: '13:37:00', 15: '13:43:00'}, + 'stop_headsign': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), + 11: float('nan'), 12: float('nan'), 13: float('nan'), 14: float('nan'), 15: float('nan')}, + 'pickup_type': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), + 11: float('nan'), 12: float('nan'), 13: float('nan'), 14: float('nan'), 15: float('nan')}, + 'drop_off_type': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), + 11: float('nan'), 12: float('nan'), 13: float('nan'), 14: float('nan'), 15: float('nan')}, + 'continuous_pickup': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), + 11: float('nan'), 12: float('nan'), 13: float('nan'), 14: float('nan'), + 15: float('nan')}, + 'continuous_drop_off': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), 11: float('nan'), 12: float('nan'), 13: float('nan'), + 14: float('nan'), 15: float('nan')}, + 'shape_dist_traveled': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), 11: float('nan'), 12: float('nan'), 13: float('nan'), + 14: float('nan'), 15: float('nan')}, + 'timepoint': {0: float('nan'), 1: float('nan'), 2: float('nan'), 3: float('nan'), 4: float('nan'), + 5: float('nan'), 6: float('nan'), 7: float('nan'), 8: float('nan'), 9: float('nan'), + 10: float('nan'), 11: float('nan'), + 12: float('nan'), 13: float('nan'), 14: float('nan'), 15: float('nan')}} + ) + assert_semantically_equal( + gtfs['calendar'].to_dict(), + {'route_id': {0: 'service'}, 'monday': {0: 1}, 'tuesday': {0: 1}, 'wednesday': {0: 1}, 'thursday': {0: 1}, + 'friday': {0: 1}, 'saturday': {0: 1}, 'sunday': {0: 1}, 'start_date': {0: '19700101'}, + 'end_date': {0: '19700101'}} + ) + + +def test_writing_schedule_to_csv(schedule, tmpdir): + schedule.write_to_csv(tmpdir) + assert set(os.listdir(tmpdir)) == {'calendar.csv', 'routes.csv', 'stop_times.csv', 'stops.csv', 'trips.csv', + 'schedule_change_log.csv'} + + +def test_writing_schedule_to_gtfs(schedule, tmpdir): + schedule.write_to_gtfs(tmpdir) + assert set(os.listdir(tmpdir)) == {'calendar.txt', 'routes.txt', 'stop_times.txt', 'stops.txt', 'trips.txt', + 'schedule_change_log.csv'} diff --git a/tests/test_core_schedule_elements.py b/tests/test_core_schedule_elements.py index 5cd893ee..0cc3c0fb 100644 --- a/tests/test_core_schedule_elements.py +++ b/tests/test_core_schedule_elements.py @@ -2,9 +2,7 @@ from networkx import Graph, DiGraph, set_node_attributes from genet.schedule_elements import Schedule, Service, Route, Stop, verify_graph_schema from genet.exceptions import ServiceIndexError, RouteIndexError, ScheduleElementGraphSchemaError -from genet.inputs_handler import gtfs_reader -from tests.fixtures import assert_semantically_equal, correct_schedule_dict_from_test_gtfs, \ - correct_stopdb_from_test_gtfs +from tests.fixtures import assert_semantically_equal def assert_all_elements_share_graph(elem): @@ -687,98 +685,6 @@ def test_route_subgraph(schedule): 'additional_attributes': {'linkRefId'}, 'linkRefId': '0', 'name': ''}}) -def test_reading_gtfs_into_schedule(correct_schedule_dict_from_test_gtfs, correct_stopdb_from_test_gtfs, mocker): - mocker.patch.object(gtfs_reader, 'read_to_dict_schedule_and_stopd_db', - return_value=(correct_schedule_dict_from_test_gtfs, correct_stopdb_from_test_gtfs)) - s = Schedule('epsg:27700') - s.read_gtfs_schedule('some_path_to_gtfs', 'day_for_gtfs') - - assert_semantically_equal(dict(s.graph().nodes(data=True)), - {'RSN': {'services': {'1002'}, 'routes': {'1002_0'}, 'id': 'RSN', 'x': 529061.7214134948, - 'y': 182106.20208785852, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5231335, - 'lon': -0.1410946, 's2_id': 5221390332291192399, 'additional_attributes': set()}, - 'RSE': {'services': {'1002'}, 'routes': {'1002_0'}, 'id': 'RSE', 'x': 528998.7798063147, - 'y': 181673.74458124593, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5192615, - 'lon': -0.1421595, 's2_id': 5221390324026756531, 'additional_attributes': set()}, - 'BSE': {'services': {'1001'}, 'routes': {'1001_0'}, 'id': 'BSE', 'x': 529044.4274520243, - 'y': 182056.01144580863, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5226864, - 'lon': -0.1413621, 's2_id': 5221390325135889957, 'additional_attributes': set()}, - 'BSN': {'services': {'1001'}, 'routes': {'1001_0'}, 'id': 'BSN', 'x': 529138.2570252238, - 'y': 181939.72009660664, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5216199, - 'lon': -0.140053, 's2_id': 5221390684150342605, 'additional_attributes': set()}}) - - assert set(s.route_ids()) == {'1001_0', '1002_0'} - - d_1001_0 = s.route('1001_0').__dict__ - del d_1001_0['_graph'] - assert_semantically_equal(d_1001_0, - {'ordered_stops': ['BSE', 'BSN'], 'route_short_name': 'BTR', 'mode': 'bus', - 'trips': {'trip_id': ['BT1'], 'trip_departure_time': ['03:21:00'], - 'vehicle_id': ['veh_0_bus']}, - 'arrival_offsets': ['0:00:00', '0:02:00'], - 'departure_offsets': ['0:00:00', '0:02:00'], 'route_long_name': '', 'id': '1001_0', - 'route': [], 'await_departure': [], 'epsg': 'epsg:27700'}) - - d_1002_0 = s.route('1002_0').__dict__ - del d_1002_0['_graph'] - assert_semantically_equal(d_1002_0, - {'ordered_stops': ['RSN', 'RSE'], 'route_short_name': 'RTR', 'mode': 'rail', - 'trips': {'trip_id': ['RT1'], 'trip_departure_time': ['03:21:00'], - 'vehicle_id': ['veh_1_rail']}, - 'arrival_offsets': ['0:00:00', '0:02:00'], - 'departure_offsets': ['0:00:00', '0:02:00'], 'route_long_name': '', 'id': '1002_0', - 'route': [], 'await_departure': [], 'epsg': 'epsg:27700'}) - - -def test_reading_gtfs_into_non_empty_schedule_gives_consistently_projected_stops(correct_schedule_dict_from_test_gtfs, - correct_stopdb_from_test_gtfs, - schedule, mocker): - mocker.patch.object(gtfs_reader, 'read_to_dict_schedule_and_stopd_db', - return_value=(correct_schedule_dict_from_test_gtfs, correct_stopdb_from_test_gtfs)) - s = schedule - s.read_gtfs_schedule('some_path_to_gtfs', 'day_for_gtfs') - - assert_semantically_equal(dict(s.graph().nodes(data=True)), - {'4': {'services': {'service2'}, 'routes': {'3', '4'}, 'id': '4', 'x': 529350.7866124967, - 'y': 182388.0201078112, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.52560003323918, - 'lon': -0.13682698708848137, 's2_id': 5221390668558830581, - 'additional_attributes': {'linkRefId'}, 'linkRefId': '4'}, - '5': {'services': {'service2'}, 'routes': {'4'}, 'id': '5', 'x': 529350.7866124967, - 'y': 182388.0201078112, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.52560003323918, - 'lon': -0.13682698708848137, 's2_id': 5221390668558830581, - 'additional_attributes': {'linkRefId'}, 'linkRefId': '5'}, - '3': {'services': {'service2'}, 'routes': {'3'}, 'id': '3', 'x': 529455.7452394223, - 'y': 182401.37630677427, 'epsg': 'epsg:27700', 'name': '', - 'lat': 51.525696033239186, 'lon': -0.13530998708775874, - 's2_id': 5221390668020036699, 'additional_attributes': {'linkRefId'}, - 'linkRefId': '3'}, - '2': {'services': {'service1'}, 'routes': {'2'}, 'id': '2', 'x': 529350.7866124967, - 'y': 182388.0201078112, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.52560003323918, - 'lon': -0.13682698708848137, 's2_id': 5221390668558830581, - 'additional_attributes': {'linkRefId'}, 'linkRefId': '2'}, - '0': {'services': {'service1'}, 'routes': {'1'}, 'id': '0', 'x': 529455.7452394223, - 'y': 182401.37630677427, 'epsg': 'epsg:27700', 'name': '', - 'lat': 51.525696033239186, 'lon': -0.13530998708775874, - 's2_id': 5221390668020036699, 'additional_attributes': {'linkRefId'}, - 'linkRefId': '0'}, - '1': {'services': {'service1'}, 'routes': {'2', '1'}, 'id': '1', 'x': 529350.7866124967, - 'y': 182388.0201078112, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.52560003323918, - 'lon': -0.13682698708848137, 's2_id': 5221390668558830581, - 'additional_attributes': {'linkRefId'}, 'linkRefId': '1'}, - 'RSN': {'services': {'1002'}, 'routes': {'1002_0'}, 'id': 'RSN', 'x': 529061.7214134948, - 'y': 182106.20208785852, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5231335, - 'lon': -0.1410946, 's2_id': 5221390332291192399, 'additional_attributes': set()}, - 'RSE': {'services': {'1002'}, 'routes': {'1002_0'}, 'id': 'RSE', 'x': 528998.7798063147, - 'y': 181673.74458124593, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5192615, - 'lon': -0.1421595, 's2_id': 5221390324026756531, 'additional_attributes': set()}, - 'BSE': {'services': {'1001'}, 'routes': {'1001_0'}, 'id': 'BSE', 'x': 529044.4274520243, - 'y': 182056.01144580863, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5226864, - 'lon': -0.1413621, 's2_id': 5221390325135889957, 'additional_attributes': set()}, - 'BSN': {'services': {'1001'}, 'routes': {'1001_0'}, 'id': 'BSN', 'x': 529138.2570252238, - 'y': 181939.72009660664, 'epsg': 'epsg:27700', 'name': '', 'lat': 51.5216199, - 'lon': -0.140053, 's2_id': 5221390684150342605, 'additional_attributes': set()}}) - - def test_building_route_from_graph(schedule_graph): r = Route(_graph=schedule_graph, **schedule_graph.graph['routes']['1']) assert r.reference_nodes() == {'1', '0'} diff --git a/tests/test_data/csv/links.csv b/tests/test_data/csv/links.csv new file mode 100644 index 00000000..4095f13a --- /dev/null +++ b/tests/test_data/csv/links.csv @@ -0,0 +1,3 @@ +index,from,modes,oneway,s2_to,attributes,capacity,freespeed,to,length,geometry,permlanes,id,s2_from +1,25508485,{'car'},1,5221390302696205321,"{'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}",600.0,4.166666666666667,21667818,52.765151087870265,kevj`maB_`la`}`@{ooxA`k~rH,1.0,1,5221390301001263407 +10,200048,{'car'},1,5221390299830573099,"{'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997927'}, 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Macfarren Place'}}",600.0,4.166666666666667,295927764,53.77508435879174,{nuphlaBkmquj|`@v`ab@uxieI,1.0,10,5221390299873156021 \ No newline at end of file diff --git a/tests/test_data/csv/nodes.csv b/tests/test_data/csv/nodes.csv new file mode 100644 index 00000000..fe3658ea --- /dev/null +++ b/tests/test_data/csv/nodes.csv @@ -0,0 +1,5 @@ +index,x,y,lat,lon,s2_id,geometry,id +25508485,528489.467895946,182206.20303669578,51.524162533239284,-0.14930198709481451,5221390301001263407,"(528489.467895946, 182206.20303669578)",25508485 +21667818,528504.1342843144,182155.7435136598,51.52370573323939,-0.14910908709500162,5221390302696205321,"(528504.1342843144, 182155.7435136598)",21667818 +295927764,528358.873300625,182147.6313714285,51.52366583323934,-0.15120468709594614,5221390299830573099,"(528358.873300625, 182147.6313714285)",295927764 +200048,528364.6182191424,182094.16422237462,51.52318403323943,-0.1511413870962065,5221390299873156021,"(528364.6182191424, 182094.16422237462)",200048 \ No newline at end of file diff --git a/tests/test_data/geojson/network_links.geojson b/tests/test_data/geojson/network_links.geojson new file mode 100644 index 00000000..61b32f50 --- /dev/null +++ b/tests/test_data/geojson/network_links.geojson @@ -0,0 +1,8 @@ +{ +"type": "FeatureCollection", +"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::27700" } }, +"features": [ +{ "type": "Feature", "properties": { "index": "1", "id": "1", "from": "25508485", "to": "21667818", "freespeed": 4.166666666666667, "capacity": 600.0, "permlanes": 1.0, "oneway": "1", "modes": "car", "s2_from": 5221390301001263407, "s2_to": 5221390302696205321, "attributes": { "osm:way:access": { "name": "osm:way:access", "class": "java.lang.String", "text": "permissive" }, "osm:way:highway": { "name": "osm:way:highway", "class": "java.lang.String", "text": "unclassified" }, "osm:way:id": { "name": "osm:way:id", "class": "java.lang.Long", "text": "26997928" }, "osm:way:name": { "name": "osm:way:name", "class": "java.lang.String", "text": "Brunswick Place" } }, "length": 52.765151087870265 }, "geometry": { "type": "LineString", "coordinates": [ [ 528489.467895945999771, 182206.203036695776973 ], [ 528504.134284314350225, 182155.743513659806922 ] ] } }, +{ "type": "Feature", "properties": { "index": "10", "id": "10", "from": "200048", "to": "295927764", "freespeed": 4.166666666666667, "capacity": 600.0, "permlanes": 1.0, "oneway": "1", "modes": "car", "s2_from": 5221390299873156021, "s2_to": 5221390299830573099, "attributes": { "osm:way:access": { "name": "osm:way:access", "class": "java.lang.String", "text": "permissive" }, "osm:way:highway": { "name": "osm:way:highway", "class": "java.lang.String", "text": "unclassified" }, "osm:way:id": { "name": "osm:way:id", "class": "java.lang.Long", "text": "26997927" }, "osm:way:name": { "name": "osm:way:name", "class": "java.lang.String", "text": "Macfarren Place" } }, "length": 53.775084358791737 }, "geometry": { "type": "LineString", "coordinates": [ [ 528364.618219142430462, 182094.164222374616656 ], [ 528358.873300625011325, 182147.631371428491548 ] ] } } +] +} diff --git a/tests/test_data/geojson/network_nodes.geojson b/tests/test_data/geojson/network_nodes.geojson new file mode 100644 index 00000000..e45fa58f --- /dev/null +++ b/tests/test_data/geojson/network_nodes.geojson @@ -0,0 +1,10 @@ +{ +"type": "FeatureCollection", +"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::27700" } }, +"features": [ +{ "type": "Feature", "properties": { "index": "25508485", "id": "25508485", "x": 528489.467895946, "y": 182206.20303669578, "lon": -0.14930198709481451, "lat": 51.524162533239284, "s2_id": 5221390301001263407 }, "geometry": { "type": "Point", "coordinates": [ 528489.467895945999771, 182206.203036695776973 ] } }, +{ "type": "Feature", "properties": { "index": "21667818", "id": "21667818", "x": 528504.13428431435, "y": 182155.74351365981, "lon": -0.14910908709500162, "lat": 51.523705733239389, "s2_id": 5221390302696205321 }, "geometry": { "type": "Point", "coordinates": [ 528504.134284314350225, 182155.743513659806922 ] } }, +{ "type": "Feature", "properties": { "index": "200048", "id": "200048", "x": 528364.61821914243, "y": 182094.16422237462, "lon": -0.1511413870962065, "lat": 51.523184033239431, "s2_id": 5221390299873156021 }, "geometry": { "type": "Point", "coordinates": [ 528364.618219142430462, 182094.164222374616656 ] } }, +{ "type": "Feature", "properties": { "index": "295927764", "id": "295927764", "x": 528358.87330062501, "y": 182147.63137142849, "lon": -0.15120468709594614, "lat": 51.523665833239342, "s2_id": 5221390299830573099 }, "geometry": { "type": "Point", "coordinates": [ 528358.873300625011325, 182147.631371428491548 ] } } +] +} diff --git a/tests/test_data/json/network.json b/tests/test_data/json/network.json new file mode 100644 index 00000000..c48a52d0 --- /dev/null +++ b/tests/test_data/json/network.json @@ -0,0 +1,126 @@ +{ + "nodes": { + "25508485": { + "id": "25508485", + "lon": -0.14930198709481451, + "y": 182206.20303669578, + "x": 528489.467895946, + "geometry": [ + 528489.467895946, + 182206.20303669578 + ], + "lat": 51.524162533239284, + "s2_id": 5221390301001263407 + }, + "21667818": { + "id": "21667818", + "lon": -0.14910908709500162, + "y": 182155.7435136598, + "x": 528504.1342843144, + "geometry": [ + 528504.1342843144, + 182155.7435136598 + ], + "lat": 51.52370573323939, + "s2_id": 5221390302696205321 + }, + "295927764": { + "id": "295927764", + "lon": -0.15120468709594614, + "y": 182147.6313714285, + "x": 528358.873300625, + "geometry": [ + 528358.873300625, + 182147.6313714285 + ], + "lat": 51.52366583323934, + "s2_id": 5221390299830573099 + }, + "200048": { + "id": "200048", + "lon": -0.1511413870962065, + "y": 182094.16422237462, + "x": 528364.6182191424, + "geometry": [ + 528364.6182191424, + 182094.16422237462 + ], + "lat": 51.52318403323943, + "s2_id": 5221390299873156021 + } + }, + "links": { + "1": { + "id": "1", + "attributes": { + "osm:way:access": { + "name": "osm:way:access", + "class": "java.lang.String", + "text": "permissive" + }, + "osm:way:highway": { + "name": "osm:way:highway", + "class": "java.lang.String", + "text": "unclassified" + }, + "osm:way:id": { + "name": "osm:way:id", + "class": "java.lang.Long", + "text": "26997928" + }, + "osm:way:name": { + "name": "osm:way:name", + "class": "java.lang.String", + "text": "Brunswick Place" + } + }, + "s2_from": 5221390301001263407, + "freespeed": 4.166666666666667, + "to": "21667818", + "permlanes": 1.0, + "modes": "car", + "geometry": "kevj`maB_`la`}`@{ooxA`k~rH", + "oneway": "1", + "from": "25508485", + "s2_to": 5221390302696205321, + "length": 52.765151087870265, + "capacity": 600.0 + }, + "10": { + "id": "10", + "attributes": { + "osm:way:access": { + "name": "osm:way:access", + "class": "java.lang.String", + "text": "permissive" + }, + "osm:way:highway": { + "name": "osm:way:highway", + "class": "java.lang.String", + "text": "unclassified" + }, + "osm:way:id": { + "name": "osm:way:id", + "class": "java.lang.Long", + "text": "26997927" + }, + "osm:way:name": { + "name": "osm:way:name", + "class": "java.lang.String", + "text": "Macfarren Place" + } + }, + "s2_from": 5221390299873156021, + "freespeed": 4.166666666666667, + "to": "295927764", + "permlanes": 1.0, + "modes": "car", + "geometry": "{nuphlaBkmquj|`@v`ab@uxieI", + "oneway": "1", + "from": "200048", + "s2_to": 5221390299830573099, + "length": 53.77508435879174, + "capacity": 600.0 + } + } +} \ No newline at end of file diff --git a/tests/test_data/json/schedule.json b/tests/test_data/json/schedule.json new file mode 100644 index 00000000..150bfda5 --- /dev/null +++ b/tests/test_data/json/schedule.json @@ -0,0 +1,120 @@ +{ + "schedule": { + "stops": { + "490000235X.link:1": { + "lon": 51.51668503324075, + "id": "490000235X.link:1", + "name": "Tottenham Court Road Station (Stop X)", + "y": 181412.0975758662, + "lat": -0.12809598708996447, + "x": 529981.7958802709, + "isBlocking": "false", + "linkRefId": "1", + "s2_id": 2507584377443783851 + }, + "490000235YB.link:10": { + "lon": 51.51609803324078, + "id": "490000235YB.link:10", + "name": "Oxford Street Soho Street (Stop YB)", + "y": 181336.2815925331, + "lat": -0.13404398709291862, + "x": 529570.7813227688, + "isBlocking": "false", + "linkRefId": "10", + "s2_id": 2507584474601580133 + } + }, + "services": { + "20274": { + "id": "20274", + "name": "N55", + "routes": { + "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e": { + "route_short_name": "N55", + "mode": "bus", + "trips": { + "trip_id": [ + "VJ4e00b97ca9c6c0c96da8f793dfbd37b11f647fa7_03:40:00" + ], + "trip_departure_time": [ + "03:40:00" + ], + "vehicle_id": [ + "veh_0_bus" + ] + }, + "arrival_offsets": [ + "00:00:00", + "00:02:20" + ], + "departure_offsets": [ + "00:00:00", + "00:02:20" + ], + "route_long_name": "", + "id": "VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e", + "route": [ + "1", + "10" + ], + "await_departure": [ + true, + true + ], + "ordered_stops": [ + "490000235X.link:1", + "490000235YB.link:10" + ] + } + } + } + }, + "minimal_transfer_times": { + "490000235X.link:1": { + "stop": "490000235YB.link:10", + "transferTime": 0.0 + }, + "490000235YB.link:10": { + "stop": "490000235X.link:1", + "transferTime": 100.0 + } + } + }, + "vehicles": { + "vehicle_types": { + "bus": { + "capacity": { + "seats": { + "persons": "70" + }, + "standingRoom": { + "persons": "0" + } + }, + "length": { + "meter": "18.0" + }, + "width": { + "meter": "2.5" + }, + "accessTime": { + "secondsPerPerson": "0.5" + }, + "egressTime": { + "secondsPerPerson": "0.5" + }, + "doorOperation": { + "mode": "serial" + }, + "passengerCarEquivalents": { + "pce": "2.8" + } + } + }, + "vehicles": { + "veh_0_bus": { + "type": "bus" + } + } + } +} \ No newline at end of file diff --git a/tests/test_data/loopy_gtfs/calendar.txt b/tests/test_data/loopy_gtfs/calendar.txt new file mode 100644 index 00000000..10a1189a --- /dev/null +++ b/tests/test_data/loopy_gtfs/calendar.txt @@ -0,0 +1,2 @@ +service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,start_date,end_date +6630,1,1,1,1,1,1,1,20190603,20200228 \ No newline at end of file diff --git a/tests/test_data/loopy_gtfs/routes.txt b/tests/test_data/loopy_gtfs/routes.txt new file mode 100644 index 00000000..2fbe1742 --- /dev/null +++ b/tests/test_data/loopy_gtfs/routes.txt @@ -0,0 +1,2 @@ +route_id,agency_id,route_short_name,route_long_name,route_type,route_url,route_color,route_text_color,checkin_duration +1001,OP550,BTR,Bus Test Route,3,,CE312D,FFFFFF, \ No newline at end of file diff --git a/tests/test_data/loopy_gtfs/stop_times.txt b/tests/test_data/loopy_gtfs/stop_times.txt new file mode 100644 index 00000000..8848df68 --- /dev/null +++ b/tests/test_data/loopy_gtfs/stop_times.txt @@ -0,0 +1,7 @@ +trip_id,arrival_time,departure_time,stop_id,stop_sequence,stop_headsign,pickup_type,drop_off_type,timepoint,stop_direction_name +BT1,03:21:00,03:21:00,BSE,0,,0,1,1, +BT1,03:23:00,03:23:00,BSN,1,,0,0,0, +BT1,03:25:00,03:25:00,BSN,2,,0,0,0, +BT1,03:25:00,03:25:00,BSN,2,,0,0,0, +BT1,03:25:00,03:25:00,BSE,2,,0,0,0, +BT1,03:25:00,03:25:00,BSN,2,,0,0,0, diff --git a/tests/test_data/loopy_gtfs/stops.txt b/tests/test_data/loopy_gtfs/stops.txt new file mode 100644 index 00000000..c755d59c --- /dev/null +++ b/tests/test_data/loopy_gtfs/stops.txt @@ -0,0 +1,3 @@ +stop_id,stop_code,stop_name,stop_lat,stop_lon,wheelchair_boarding,stop_timezone,location_type,parent_station,platform_code +BSE,,Bus Stop snap to edge,51.5226864,-0.1413621,,,0.0,210G433, +BSN,,Bus Stop snap to node,51.5216199,-0.140053,,,0.0,210G432, \ No newline at end of file diff --git a/tests/test_data/loopy_gtfs/trips.txt b/tests/test_data/loopy_gtfs/trips.txt new file mode 100644 index 00000000..2d967963 --- /dev/null +++ b/tests/test_data/loopy_gtfs/trips.txt @@ -0,0 +1,2 @@ +route_id,service_id,trip_id,trip_headsign,block_id,wheelchair_accessible,trip_direction_name,exceptional +1001,6630,BT1,Bus Test trip,,0,, \ No newline at end of file diff --git a/tests/test_inputs_handler_gtfs_reader.py b/tests/test_inputs_handler_gtfs_reader.py index ddea99c9..508b0060 100644 --- a/tests/test_inputs_handler_gtfs_reader.py +++ b/tests/test_inputs_handler_gtfs_reader.py @@ -1,6 +1,7 @@ import json import os import sys +from pandas.testing import assert_frame_equal from tests.fixtures import * from genet.inputs_handler import gtfs_reader @@ -14,15 +15,13 @@ def test_read_services_from_calendar_correct(): assert services == ['6630', '6631'] -def test_read_gtfs_to_db_like_tables_correct(correct_stop_times, correct_stop_times_db, correct_stops_db, - correct_trips_db, correct_routes_db): - stop_times, stop_times_db, stops_db, trips_db, routes_db = gtfs_reader.read_gtfs_to_db_like_tables(gtfs_test_file) +def test_read_gtfs_to_db_like_tables_correct(correct_stop_times_db, correct_stops_db, correct_trips_db, correct_routes_db): + stop_times_db, stops_db, trips_db, routes_db = gtfs_reader.read_gtfs_to_db_like_tables(gtfs_test_file) - assert stop_times == correct_stop_times - assert stop_times_db == correct_stop_times_db - assert stops_db == correct_stops_db - assert trips_db == correct_trips_db - assert routes_db == correct_routes_db + assert_frame_equal(stop_times_db, correct_stop_times_db) + assert_frame_equal(stops_db, correct_stops_db) + assert_frame_equal(trips_db, correct_trips_db) + assert_frame_equal(routes_db, correct_routes_db) def test_get_mode_returns_mode_if_given_int(): @@ -37,24 +36,30 @@ def test_get_mode_returns_other_if_doesnt_recognise(): assert gtfs_reader.get_mode('99999999') == 'other' -def test_parse_db_to_schedule_dict_correct(correct_schedule_dict, correct_stop_times_db, correct_stops_db, - correct_trips_db, correct_routes_db): - schedule = gtfs_reader.parse_db_to_schedule_dict(stop_times_db=correct_stop_times_db, stops_db=correct_stops_db, - trips_db=correct_trips_db, route_db=correct_routes_db, - services=['6630', '6631']) - - assert_semantically_equal(schedule, correct_schedule_dict) - - -def test_read_to_schedule_correct(correct_schedule_dict_from_test_gtfs, correct_stopdb_from_test_gtfs): - schedule, stops_db = gtfs_reader.read_to_dict_schedule_and_stopd_db(gtfs_test_file, '20190604') - - assert_semantically_equal(schedule, correct_schedule_dict_from_test_gtfs) - assert_semantically_equal(stops_db, correct_stopdb_from_test_gtfs) - - -def test_zip_read_to_schedule_correct(correct_schedule_dict_from_test_gtfs, correct_stopdb_from_test_gtfs): - schedule, stops_db = gtfs_reader.read_to_dict_schedule_and_stopd_db(gtfs_test_zip_file, '20190604') - - assert_semantically_equal(schedule, correct_schedule_dict_from_test_gtfs) - assert_semantically_equal(stops_db, correct_stopdb_from_test_gtfs) +def test_read_to_schedule_correct(correct_schedule_graph_nodes_from_test_gtfs, + correct_schedule_graph_edges_from_test_gtfs, + correct_schedule_graph_data_from_test_gtfs): + schedule_graph = gtfs_reader.read_gtfs_to_schedule_graph(gtfs_test_file, '20190604') + assert_semantically_equal(dict(schedule_graph.nodes(data=True)), correct_schedule_graph_nodes_from_test_gtfs) + assert_semantically_equal(schedule_graph.edges._adjdict, correct_schedule_graph_edges_from_test_gtfs) + del schedule_graph.graph['change_log'] + del correct_schedule_graph_data_from_test_gtfs['change_log'] + assert_semantically_equal(schedule_graph.graph, correct_schedule_graph_data_from_test_gtfs) + + +def test_zip_read_to_schedule_correct(correct_schedule_graph_nodes_from_test_gtfs, + correct_schedule_graph_edges_from_test_gtfs, + correct_schedule_graph_data_from_test_gtfs): + schedule_graph = gtfs_reader.read_gtfs_to_schedule_graph(gtfs_test_file, '20190604') + assert_semantically_equal(dict(schedule_graph.nodes(data=True)), correct_schedule_graph_nodes_from_test_gtfs) + assert_semantically_equal(schedule_graph.edges._adjdict, correct_schedule_graph_edges_from_test_gtfs) + del schedule_graph.graph['change_log'] + del correct_schedule_graph_data_from_test_gtfs['change_log'] + assert_semantically_equal(schedule_graph.graph, correct_schedule_graph_data_from_test_gtfs) + + +def test_reading_loopy_gtfs_removes_duplicated_stops(): + schedule_graph = gtfs_reader.read_gtfs_to_schedule_graph( + os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "loopy_gtfs")), + '20190604') + assert schedule_graph.graph['routes']['1001_0']['ordered_stops'] == ['BSE', 'BSN', 'BSE', 'BSN'] diff --git a/tests/test_inputs_handler_matsim_reader.py b/tests/test_inputs_handler_matsim_reader.py index 0af62db5..e5b7ef65 100644 --- a/tests/test_inputs_handler_matsim_reader.py +++ b/tests/test_inputs_handler_matsim_reader.py @@ -1,6 +1,6 @@ from pyproj import Proj, Transformer from shapely.geometry import LineString -from genet.inputs_handler import matsim_reader +from genet.inputs_handler import matsim_reader, read from tests.fixtures import * sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) @@ -64,8 +64,7 @@ def test_read_network_builds_graph_with_correct_data_on_nodes_and_edges(): def test_reading_NZ_network(): - n = Network('epsg:2193') - n.read_matsim_network(pt2matsim_NZ_network) + n = read.read_matsim(path_to_network=pt2matsim_NZ_network, epsg='epsg:2193') assert_semantically_equal(dict(n.nodes()), { '7872447671905026061': {'id': '7872447671905026061', 'x': 1789300.631705982, 'y': 5494320.626099871, 'lon': 175.23998223484716, 'lat': -40.68028521526985, 's2_id': 7872447671905026061}, @@ -241,8 +240,7 @@ def test_read_network_rejects_non_unique_nodes(): def test_reading_matsim_output_network(): - n = Network('epsg:27700') - n.read_matsim_network(matsim_output_network) + n = read.read_matsim(path_to_network=matsim_output_network, epsg='epsg:27700') correct_nodes = { '21667818': {'id': '21667818', 's2_id': 5221390302696205321, 'x': 528504.1342843144, 'y': 182155.7435136598, @@ -290,9 +288,7 @@ def test_reading_network_with_geometry_attributes(): 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'} }} } - - n = Network('epsg:27700') - n.read_matsim_network(pt2matsim_network_with_geometry_file) + n = read.read_matsim(path_to_network=pt2matsim_network_with_geometry_file, epsg='epsg:27700') assert_semantically_equal(dict(n.links()), correct_links) @@ -314,9 +310,7 @@ def test_reading_network_with_singular_geometry_attribute_cleans_up_empty_attrib 'modes': {'car'} } } - - n = Network('epsg:27700') - n.read_matsim_network(pt2matsim_network_with_singular_geometry_file) + n = read.read_matsim(path_to_network=pt2matsim_network_with_singular_geometry_file, epsg='epsg:27700') assert_semantically_equal(dict(n.links()), correct_links) diff --git a/tests/test_inputs_read.py b/tests/test_inputs_read.py new file mode 100644 index 00000000..106c1f42 --- /dev/null +++ b/tests/test_inputs_read.py @@ -0,0 +1,194 @@ +from genet.inputs_handler import read +from tests.fixtures import * +from shapely.geometry import LineString + + +json_test_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "json")) + +def test_reading_json(): + n = read.read_json(network_path=os.path.join(json_test_folder, 'network.json'), + schedule_path=os.path.join(json_test_folder, 'schedule.json'), + epsg='epsg:27700') + assert_semantically_equal( + dict(n.nodes()), + {'25508485': {'x': 528489.467895946, 'y': 182206.20303669575, 'lat': 51.52416253323928, + 'lon': -0.14930198709481451, 's2_id': 5.221390301001263e+18, 'id': '25508485'}, + '21667818': {'x': 528504.1342843144, 'y': 182155.7435136598, 'lat': 51.523705733239396, + 'lon': -0.14910908709500162, 's2_id': 5.221390302696205e+18, 'id': '21667818'}, + '295927764': {'x': 528358.873300625, 'y': 182147.63137142852, 'lat': 51.52366583323935, + 'lon': -0.15120468709594614, 's2_id': 5.221390299830573e+18, 'id': '295927764'}, + '200048': {'x': 528364.6182191424, 'y': 182094.16422237465, 'lat': 51.52318403323943, + 'lon': -0.1511413870962065, 's2_id': 5.221390299873156e+18, 'id': '200048'}} + ) + assert_semantically_equal( + dict(n.links()), + {'1': {'from': '25508485', 'modes': {'car'}, 'oneway': '1', 's2_to': 5221390302696205321, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '21667818', 'length': 52.76515108787025, + 'geometry': LineString([(528489.4679, 182206.20304), (528504.13428, 182155.74351)]), + 'permlanes': 1.0, 'id': '1', 's2_from': 5221390301001263407}, + '10': {'from': '200048', 'modes': {'car'}, 'oneway': '1', 's2_to': 5221390299830573099, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997927'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Macfarren Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '295927764', 'length': 53.775084358791744, + 'geometry': LineString([(528364.61822, 182094.16422), (528358.8733, 182147.63137)]), + 'permlanes': 1.0, 'id': '10', 's2_from': 5221390299873156021}} + ) + g = n.schedule._graph.graph + del g['change_log'] + assert_semantically_equal( + n.schedule._graph.graph, + {'name': 'Schedule graph', 'route_to_service_map': {'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e': '20274'}, + 'service_to_route_map': {'20274': ['VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e']}, + 'routes': {'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e': + {'route_short_name': 'N55', 'mode': 'bus', + 'trips': {'trip_id': ['VJ4e00b97ca9c6c0c96da8f793dfbd37b11f647fa7_03:40:00'], + 'trip_departure_time': ['03:40:00'], + 'vehicle_id': ['veh_0_bus']}, + 'arrival_offsets': ['00:00:00', '00:02:20'], + 'departure_offsets': ['00:00:00', '00:02:20'], + 'route_long_name': '', + 'id': 'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e', + 'route': ['1', '10'], + 'await_departure': [True, True], + 'ordered_stops': ['490000235X.link:1', '490000235YB.link:10']}}, + 'services': {'20274': {'id': '20274', 'name': 'N55'}}, 'crs': {'init': 'epsg:27700'}} + ) + assert_semantically_equal( + dict(n.schedule._graph.nodes(data=True)), + {'490000235X.link:1': {'services': {'20274'}, 'routes': {'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e'}, + 'id': '490000235X.link:1', 'x': 529981.7958802709, 'y': 181412.0975758662, + 'epsg': 'epsg:27700', 'name': 'Tottenham Court Road Station (Stop X)', + 'lat': -0.12809598708996447, 'lon': 51.51668503324075, 's2_id': 2507584377443783851, + 'additional_attributes': {'isBlocking', 'linkRefId'}, 'isBlocking': 'false', + 'linkRefId': '1'}, + '490000235YB.link:10': {'services': {'20274'}, 'routes': {'VJ6c64ab7b477e201cae950efde5bd0cb4e2e8888e'}, + 'id': '490000235YB.link:10', 'x': 529570.7813227688, 'y': 181336.2815925331, + 'epsg': 'epsg:27700', 'name': 'Oxford Street Soho Street (Stop YB)', + 'lat': -0.13404398709291862, 'lon': 51.51609803324078, 's2_id': 2507584474601580133, + 'additional_attributes': {'isBlocking', 'linkRefId'}, 'isBlocking': 'false', + 'linkRefId': '10'}} + ) + + +geojson_test_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "geojson")) + +def test_reading_geojson(): + n = read.read_geojson_network(nodes_path=os.path.join(geojson_test_folder, 'network_nodes.geojson'), + links_path=os.path.join(geojson_test_folder, 'network_links.geojson'), + epsg='epsg:27700') + assert_semantically_equal( + dict(n.nodes()), + {'25508485': {'x': 528489.467895946, 'y': 182206.20303669575, 'lat': 51.52416253323928, + 'lon': -0.14930198709481451, 's2_id': 5.221390301001263e+18, 'id': '25508485'}, + '21667818': {'x': 528504.1342843144, 'y': 182155.7435136598, 'lat': 51.523705733239396, + 'lon': -0.14910908709500162, 's2_id': 5.221390302696205e+18, 'id': '21667818'}, + '295927764': {'x': 528358.873300625, 'y': 182147.63137142852, 'lat': 51.52366583323935, + 'lon': -0.15120468709594614, 's2_id': 5.221390299830573e+18, 'id': '295927764'}, + '200048': {'x': 528364.6182191424, 'y': 182094.16422237465, 'lat': 51.52318403323943, + 'lon': -0.1511413870962065, 's2_id': 5.221390299873156e+18, 'id': '200048'}} + ) + links = dict(n.links()) + assert [(round(x, 6), round(y, 6)) for x,y in links['1']['geometry'].coords] == [(528489.467896, 182206.203037), (528504.134284, 182155.743514)] + assert [(round(x, 6), round(y, 6)) for x,y in links['10']['geometry'].coords] == [(528364.618219, 182094.164222), (528358.873301, 182147.631371)] + del links['1']['geometry'] + del links['10']['geometry'] + assert_semantically_equal( + links, + {'1': {'from': '25508485', 'modes': {'car'}, 'oneway': '1', 's2_to': 5221390302696205321, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '21667818', 'length': 52.76515108787025, + 'permlanes': 1.0, 'id': '1', 's2_from': 5221390301001263407}, + '10': {'from': '200048', 'modes': {'car'}, 'oneway': '1', 's2_to': 5221390299830573099, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997927'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Macfarren Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '295927764', 'length': 53.775084358791744, + 'permlanes': 1.0, 'id': '10', 's2_from': 5221390299873156021}} + ) + + +csv_test_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "csv")) + + +def test_reading_network_csv(): + n = read.read_csv(os.path.join(csv_test_folder, 'nodes.csv'), os.path.join(csv_test_folder, 'links.csv'), + 'epsg:27700') + assert_semantically_equal( + dict(n.nodes()), + {'25508485': {'x': 528489.467895946, 'y': 182206.20303669575, 'lat': 51.52416253323928, + 'lon': -0.14930198709481451, 's2_id': 5.221390301001263e+18, 'id': '25508485'}, + '21667818': {'x': 528504.1342843144, 'y': 182155.7435136598, 'lat': 51.523705733239396, + 'lon': -0.14910908709500162, 's2_id': 5.221390302696205e+18, 'id': '21667818'}, + '295927764': {'x': 528358.873300625, 'y': 182147.63137142852, 'lat': 51.52366583323935, + 'lon': -0.15120468709594614, 's2_id': 5.221390299830573e+18, 'id': '295927764'}, + '200048': {'x': 528364.6182191424, 'y': 182094.16422237465, 'lat': 51.52318403323943, + 'lon': -0.1511413870962065, 's2_id': 5.221390299873156e+18, 'id': '200048'}} + ) + assert_semantically_equal( + dict(n.links()), + {'1': {'from': '25508485', 'modes': {'car'}, 'oneway': 1, 's2_to': 5221390302696205321, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997928'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Brunswick Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '21667818', 'length': 52.76515108787025, + 'geometry': LineString([(528489.4679, 182206.20304), (528504.13428, 182155.74351)]), + 'permlanes': 1.0, 'id': '1', 's2_from': 5221390301001263407}, + '10': {'from': '200048', 'modes': {'car'}, 'oneway': 1, 's2_to': 5221390299830573099, + 'attributes': { + 'osm:way:access': {'name': 'osm:way:access', 'class': 'java.lang.String', 'text': 'permissive'}, + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', 'text': 'unclassified'}, + 'osm:way:id': {'name': 'osm:way:id', 'class': 'java.lang.Long', 'text': '26997927'}, + 'osm:way:name': {'name': 'osm:way:name', 'class': 'java.lang.String', 'text': 'Macfarren Place'}}, + 'capacity': 600.0, 'freespeed': 4.166666666666667, 'to': '295927764', 'length': 53.775084358791744, + 'geometry': LineString([(528364.61822, 182094.16422), (528358.8733, 182147.63137)]), + 'permlanes': 1.0, 'id': '10', 's2_from': 5221390299873156021}} + ) + + +gtfs_test_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data", "gtfs")) + + +def test_read_gtfs_returns_expected_schedule(correct_stops_to_service_mapping_from_test_gtfs, + correct_stops_to_route_mapping_from_test_gtfs): + schedule = read.read_gtfs(gtfs_test_folder, '20190604') + + assert schedule['1001'] == Service( + '1001', + [Route( + route_short_name='BTR', + mode='bus', + stops=[Stop(id='BSE', x=-0.1413621, y=51.5226864, epsg='epsg:4326'), + Stop(id='BSN', x=-0.140053, y=51.5216199, epsg='epsg:4326')], + trips={'trip_id': ['BT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_0_bus']}, + arrival_offsets=['0:00:00', '0:02:00'], + departure_offsets=['0:00:00', '0:02:00'] + )]) + assert schedule['1002'] == Service( + '1002', + [Route( + route_short_name='RTR', + mode='rail', + stops=[Stop(id='RSN', x=-0.1410946, y=51.5231335, epsg='epsg:4326'), + Stop(id='RSE', x=-0.1421595, y=51.5192615, epsg='epsg:4326')], + trips={'trip_id': ['RT1'], 'trip_departure_time': ['03:21:00'], 'vehicle_id': ['veh_1_rail']}, + arrival_offsets=['0:00:00', '0:02:00'], + departure_offsets=['0:00:00', '0:02:00'] + )]) + assert_semantically_equal(schedule.stop_to_service_ids_map(), correct_stops_to_service_mapping_from_test_gtfs) + assert_semantically_equal(schedule.stop_to_route_ids_map(), correct_stops_to_route_mapping_from_test_gtfs) diff --git a/tests/test_outputs_handler_geojson.py b/tests/test_outputs_handler_geojson.py index d1b7d454..66a57345 100644 --- a/tests/test_outputs_handler_geojson.py +++ b/tests/test_outputs_handler_geojson.py @@ -26,47 +26,49 @@ def test_saving_values_which_result_in_overflow(tmpdir): n.add_node('0', attribs={'x': 528704.1425925883, 'y': 182068.78193707118, 's2_id': 7860190995130875979}) n.add_node('1', attribs={'x': 528804.1425925883, 'y': 182168.78193707118, 's2_id': 12118290696817869383}) n.add_link('link_0', '0', '1', attribs={'length': 123, 'modes': ['car', 'walk'], 'ids': ['1', '2']}) - n.save_network_to_geojson(tmpdir) + n.write_to_geojson(tmpdir) def test_generating_network_graph_geodataframe(network): - nodes, links = gngeojson.generate_geodataframes(network.graph) + gdfs = gngeojson.generate_geodataframes(network.graph) + nodes, links = gdfs['nodes'], gdfs['links'] correct_nodes = { 'x': {'0': 528704.1425925883, '1': 528804.1425925883}, 'y': {'0': 182068.78193707118, '1': 182168.78193707118}} - correct_links = {'length': {0: 123, 1: 123, 2: 123}, - 'modes': {0: ['car', 'walk'], 1: ['bike'], 2: ['rail']}, - 'freespeed': {0: 10.0, 1: float('nan'), 2: float('nan')}, - 'capacity': {0: 5.0, 1: float('nan'), 2: float('nan')}, - 'from': {0: '0', 1: '0', 2: '1'}, 'to': {0: '1', 1: '1', 2: '0'}, - 'id': {0: 'link_0', 1: 'link_1', 2: 'link_2'}, 'u': {0: '0', 1: '0', 2: '1'}, - 'v': {0: '1', 1: '1', 2: '0'}, 'key': {0: 0, 1: 1, 2: 0}, - 'attributes': {0: float('nan'), - 1: {'osm:way:highway': {'name': 'osm:way:highway', - 'class': 'java.lang.String', - 'text': 'unclassified'}}, - 2: float('nan')}} + correct_links = {'u': {'link_0': '0', 'link_1': '0', 'link_2': '1'}, + 'v': {'link_0': '1', 'link_1': '1', 'link_2': '0'}, + 'length': {'link_0': 123, 'link_1': 123, 'link_2': 123}, + 'attributes': {'link_0': float('nan'), 'link_1': { + 'osm:way:highway': {'name': 'osm:way:highway', 'class': 'java.lang.String', + 'text': 'unclassified'}}, 'link_2': float('nan')}, + 'to': {'link_0': '1', 'link_1': '1', 'link_2': '0'}, + 'from': {'link_0': '0', 'link_1': '0', 'link_2': '1'}, + 'freespeed': {'link_0': 10.0, 'link_1': float('nan'), 'link_2': float('nan')}, + 'id': {'link_0': 'link_0', 'link_1': 'link_1', 'link_2': 'link_2'}, + 'capacity': {'link_0': 5.0, 'link_1': float('nan'), 'link_2': float('nan')}, + 'modes': {'link_0': ['car', 'walk'], 'link_1': ['bike'], 'link_2': ['rail']}} assert_semantically_equal(nodes[set(nodes.columns) - {'geometry'}].to_dict(), correct_nodes) assert_semantically_equal(links[set(links.columns) - {'geometry'}].to_dict(), correct_links) - assert round(nodes.loc['0', 'geometry'].coords[:][0][0], 7) == round(-0.14625948709424305, 7) - assert round(nodes.loc['0', 'geometry'].coords[:][0][1], 7) == round(51.52287873323954, 7) - assert round(nodes.loc['1', 'geometry'].coords[:][0][0], 7) == round(-0.14478238148334213, 7) - assert round(nodes.loc['1', 'geometry'].coords[:][0][1], 7) == round(51.523754629002234, 7) + assert round(nodes.loc['0', 'geometry'].coords[:][0][0], 7) == round(528704.1425925883, 7) + assert round(nodes.loc['0', 'geometry'].coords[:][0][1], 7) == round(182068.78193707118, 7) + assert round(nodes.loc['1', 'geometry'].coords[:][0][0], 7) == round(528804.1425925883, 7) + assert round(nodes.loc['1', 'geometry'].coords[:][0][1], 7) == round(182168.78193707118, 7) - points = links.loc[0, 'geometry'].coords[:] - assert round(points[0][0], 7) == round(-0.14625948709424305, 7) - assert round(points[0][1], 7) == round(51.52287873323954, 7) - assert round(points[1][0], 7) == round(-0.14478238148334213, 7) - assert round(points[1][1], 7) == round(51.523754629002234, 7) + points = links.loc['link_0', 'geometry'].coords[:] + assert round(points[0][0], 7) == round(528704.1425925883, 7) + assert round(points[0][1], 7) == round(182068.78193707118, 7) + assert round(points[1][0], 7) == round(528804.1425925883, 7) + assert round(points[1][1], 7) == round(182168.78193707118, 7) - assert nodes.crs == "EPSG:4326" - assert links.crs == "EPSG:4326" + assert nodes.crs == "EPSG:27700" + assert links.crs == "EPSG:27700" def test_generating_schedule_graph_geodataframe(network): - nodes, links = gngeojson.generate_geodataframes(network.schedule.graph()) + gdfs = gngeojson.generate_geodataframes(network.schedule.graph()) + nodes, links = gdfs['nodes'], gdfs['links'] correct_nodes = {'services': {'0': {'service'}, '1': {'service'}}, 'routes': {'0': {'1', '2'}, '1': {'1', '2'}}, 'id': {'0': '0', '1': '1'}, 'x': {'0': 529455.7452394223, '1': 529350.7866124967}, @@ -82,33 +84,33 @@ def test_generating_schedule_graph_geodataframe(network): correct_links = {'services': {0: {'service'}}, 'routes': {0: {'1', '2'}}, 'u': {0: '0'}, - 'v': {0: '1'}, - 'key': {0: 0}} + 'v': {0: '1'}} assert_semantically_equal(nodes[set(nodes.columns) - {'geometry'}].to_dict(), correct_nodes) assert_semantically_equal(links[set(links.columns) - {'geometry'}].to_dict(), correct_links) - assert round(nodes.loc['0', 'geometry'].coords[:][0][0], 7) == round(-0.13530998708775874, 7) - assert round(nodes.loc['0', 'geometry'].coords[:][0][1], 7) == round(51.525696033239186, 7) - assert round(nodes.loc['1', 'geometry'].coords[:][0][0], 7) == round(-0.13682698708848137, 7) - assert round(nodes.loc['1', 'geometry'].coords[:][0][1], 7) == round(51.52560003323918, 7) + assert round(nodes.loc['0', 'geometry'].coords[:][0][0], 7) == round(529455.7452394223, 7) + assert round(nodes.loc['0', 'geometry'].coords[:][0][1], 7) == round(182401.37630677427, 7) + assert round(nodes.loc['1', 'geometry'].coords[:][0][0], 7) == round(529350.7866124967, 7) + assert round(nodes.loc['1', 'geometry'].coords[:][0][1], 7) == round(182388.0201078112, 7) points = links.loc[0, 'geometry'].coords[:] - assert round(points[0][0], 7) == round(-0.13530998708775874, 7) - assert round(points[0][1], 7) == round(51.525696033239186, 7) - assert round(points[1][0], 7) == round(-0.13682698708848137, 7) - assert round(points[1][1], 7) == round(51.52560003323918, 7) + assert round(points[0][0], 7) == round(529455.7452394223, 7) + assert round(points[0][1], 7) == round(182401.37630677427, 7) + assert round(points[1][0], 7) == round(529350.7866124967, 7) + assert round(points[1][1], 7) == round(182388.0201078112, 7) - assert nodes.crs == "EPSG:4326" - assert links.crs == "EPSG:4326" + assert nodes.crs == "EPSG:27700" + assert links.crs == "EPSG:27700" def test_modal_subset(network): - nodes, links = gngeojson.generate_geodataframes(network.graph) + gdfs = gngeojson.generate_geodataframes(network.graph) + nodes, links = gdfs['nodes'], gdfs['links'] car = links[links.apply(lambda x: gngeojson.modal_subset(x, {'car'}), axis=1)] assert len(car) == 1 - assert car.loc[0, 'modes'] == ['car', 'walk'] + assert car.loc['link_0', 'modes'] == ['car', 'walk'] def test_generating_standard_outputs_after_modifying_modes_in_schedule(network, tmpdir): @@ -118,11 +120,11 @@ def test_generating_standard_outputs_after_modifying_modes_in_schedule(network, def test_save_to_geojson(network, tmpdir): assert os.listdir(tmpdir) == [] - network.save_network_to_geojson(tmpdir) - assert set(os.listdir(tmpdir)) == { - 'network_nodes.geojson', 'network_links.geojson', 'network_links_geometry_only.geojson', - 'network_nodes_geometry_only.geojson', 'schedule_nodes.geojson', 'schedule_links.geojson', - 'schedule_links_geometry_only.geojson', 'schedule_nodes_geometry_only.geojson', 'shp_files'} + network.write_to_geojson(tmpdir) + assert set(os.listdir(tmpdir)) == {'schedule_nodes.geojson', 'schedule_links.geojson', 'network_nodes.geojson', + 'schedule_nodes_geometry_only.geojson', 'network_nodes_geometry_only.geojson', + 'schedule_links_geometry_only.geojson', 'network_links_geometry_only.geojson', + 'network_links.geojson', 'network_change_log.csv', 'schedule_change_log.csv'} def test_generating_standard_outputs(network, tmpdir): @@ -165,12 +167,12 @@ def test_generating_standard_outputs(network, tmpdir): )]) ]) assert os.listdir(tmpdir) == [] - network.generate_standard_outputs(tmpdir) + network.generate_standard_outputs(tmpdir, include_shp_files=True) assert set(os.listdir(tmpdir)) == {'graph', 'schedule_links_geometry_only.geojson', 'network_nodes_geometry_only.geojson', 'network_links.geojson', 'network_links_geometry_only.geojson', 'schedule_nodes.geojson', 'schedule_nodes_geometry_only.geojson', 'schedule', 'network_nodes.geojson', - 'shp_files', 'schedule_links.geojson'} + 'schedule_links.geojson', 'network_change_log.csv', 'schedule_change_log.csv'} assert set(os.listdir(os.path.join(tmpdir, 'graph'))) == {'car_capacity_subgraph.geojson', 'car_freespeed_subgraph.geojson', 'car_osm_highway_unclassified.geojson', @@ -219,24 +221,25 @@ def test_generating_standard_outputs(network, tmpdir): 'vehicles_per_hour_bus.geojson', 'vehicles_per_hour_rail.geojson'} assert set(os.listdir(os.path.join(tmpdir, 'schedule', 'vehicles_per_hour', 'shp_files'))) == { - 'vehicles_per_hour_all_modes.cpg', 'vehicles_per_hour_bus.prj', 'vehicles_per_hour_rail.dbf', - 'vph_all_modes_within_6:30-7:30.shx', 'vehicles_per_hour_bus.shp', 'vehicles_per_hour_rail.cpg', - 'vehicles_per_hour_all_modes.prj', 'vehicles_per_hour_all_modes.shp', 'vehicles_per_hour_rail.shx', - 'vehicles_per_hour_rail.prj', 'vph_all_modes_within_6:30-7:30.cpg', 'vehicles_per_hour_bus.shx', - 'vehicles_per_hour_bus.dbf', 'vph_all_modes_within_6:30-7:30.shp', 'vph_all_modes_within_6:30-7:30.prj', - 'vph_all_modes_within_6:30-7:30.dbf', 'vehicles_per_hour_bus.cpg', 'vehicles_per_hour_all_modes.dbf', - 'vehicles_per_hour_rail.shp', 'vehicles_per_hour_all_modes.shx'} + 'vehicles_per_hour_all_modes.cpg', 'vph_all_modes_within_6:30-7:30.shx', 'vehicles_per_hour_rail.prj', + 'vehicles_per_hour_bus.shp', 'vehicles_per_hour_bus.dbf', 'vehicles_per_hour_rail.shx', + 'vehicles_per_hour_bus.prj', + 'vehicles_per_hour_all_modes.prj', 'vehicles_per_hour_bus.shx', 'vehicles_per_hour_rail.dbf', + 'vph_all_modes_within_6:30-7:30.dbf', 'vehicles_per_hour_rail.cpg', 'vph_all_modes_within_6:30-7:30.shp', + 'vehicles_per_hour_rail.shp', 'vehicles_per_hour_all_modes.shx', 'vehicles_per_hour_bus.cpg', + 'vehicles_per_hour_all_modes.shp', 'vph_all_modes_within_6:30-7:30.prj', 'vehicles_per_hour_all_modes.dbf', + 'vph_all_modes_within_6:30-7:30.cpg'} assert set(os.listdir(os.path.join(tmpdir, 'schedule', 'subgraphs'))) == {'schedule_subgraph_links_bus.geojson', 'schedule_subgraph_links_rail.geojson', 'shp_files', 'schedule_subgraph_nodes_bus.geojson', 'schedule_subgraph_nodes_rail.geojson'} assert set(os.listdir(os.path.join(tmpdir, 'schedule', 'subgraphs', 'shp_files'))) == { - 'schedule_subgraph_nodes_bus.shx', 'schedule_subgraph_links_rail.dbf', 'schedule_subgraph_nodes_rail.cpg', - 'schedule_subgraph_nodes_bus.prj', 'schedule_subgraph_links_bus.prj', 'schedule_subgraph_nodes_rail.shx', - 'schedule_subgraph_links_bus.cpg', 'schedule_subgraph_nodes_rail.shp', 'schedule_subgraph_nodes_rail.dbf', - 'schedule_subgraph_nodes_bus.dbf', 'schedule_subgraph_nodes_rail.prj', 'schedule_subgraph_nodes_bus.shp', - 'schedule_subgraph_links_rail.shx', 'schedule_subgraph_links_rail.shp', 'schedule_subgraph_links_rail.prj', - 'schedule_subgraph_links_rail.cpg', 'schedule_subgraph_nodes_bus.cpg', 'schedule_subgraph_links_bus.shp', - 'schedule_subgraph_links_bus.shx', 'schedule_subgraph_links_bus.dbf'} + 'schedule_subgraph_nodes_rail.prj', 'schedule_subgraph_links_bus.shx', 'schedule_subgraph_links_bus.prj', + 'schedule_subgraph_nodes_rail.dbf', 'schedule_subgraph_nodes_rail.shx', 'schedule_subgraph_links_rail.dbf', + 'schedule_subgraph_links_rail.shx', 'schedule_subgraph_nodes_bus.cpg', 'schedule_subgraph_links_rail.shp', + 'schedule_subgraph_nodes_bus.prj', 'schedule_subgraph_nodes_bus.dbf', 'schedule_subgraph_links_rail.cpg', + 'schedule_subgraph_links_bus.dbf', 'schedule_subgraph_links_bus.shp', 'schedule_subgraph_links_rail.prj', + 'schedule_subgraph_nodes_bus.shx', 'schedule_subgraph_links_bus.cpg', 'schedule_subgraph_nodes_bus.shp', + 'schedule_subgraph_nodes_rail.cpg', 'schedule_subgraph_nodes_rail.shp'} assert os.path.exists(tmpdir + '.zip') diff --git a/tests/test_outputs_handler_matsim_xml_writer.py b/tests/test_outputs_handler_matsim_xml_writer.py index 5c0e2914..781ab1b6 100644 --- a/tests/test_outputs_handler_matsim_xml_writer.py +++ b/tests/test_outputs_handler_matsim_xml_writer.py @@ -8,6 +8,7 @@ from genet.outputs_handler import matsim_xml_writer from genet.core import Network from genet.schedule_elements import read_vehicle_types +from genet.inputs_handler import read import xml.etree.cElementTree as ET sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))) @@ -63,8 +64,7 @@ def test_network_from_test_osm_data_produces_valid_matsim_network_xml_file(full_ tmpdir): osm_test_file = os.path.abspath( os.path.join(os.path.dirname(__file__), "test_data", "osm", "osm.xml")) - network = Network('epsg:27700') - network.read_osm(osm_test_file, full_fat_default_config_path, 1) + network = read.read_osm(osm_test_file, full_fat_default_config_path, 1, 'epsg:27700') network.write_to_matsim(tmpdir) generated_network_file_path = os.path.join(tmpdir, 'network.xml') @@ -87,9 +87,7 @@ def test_network_with_extra_attribs_produces_valid_matsim_network_xml_file(tmpdi assert network_dtd.validate(xml_obj), \ 'Doc generated at {} is not valid against DTD due to {}'.format(generated_network_file_path, network_dtd.error_log.filter_from_errors()) - - _network_from_file = Network(epsg='epsg:27700') - _network_from_file.read_matsim_network(generated_network_file_path) + _network_from_file = read.read_matsim(path_to_network=generated_network_file_path, epsg='epsg:27700') assert_semantically_equal(dict(_network_from_file.nodes()), { '0': {'id': '0', 'x': 1.0, 'y': 2.0, 'lon': -7.557148039524952, 'lat': 49.766825803756994, 's2_id': 5205973754090365183}, @@ -121,8 +119,7 @@ def test_tolerates_networks_with_no_oneway_flag_on_links(tmpdir, network_dtd): 'Doc generated at {} is not valid against DTD due to {}'.format(generated_network_file_path, network_dtd.error_log.filter_from_errors()) - _network_from_file = Network(epsg='epsg:27700') - _network_from_file.read_matsim_network(generated_network_file_path) + _network_from_file = read.read_matsim(path_to_network=generated_network_file_path, epsg='epsg:27700') assert_semantically_equal(dict(_network_from_file.nodes()), { '0': {'id': '0', 'x': 1.0, 'y': 2.0, 'lon': -7.557148039524952, 'lat': 49.766825803756994, 's2_id': 5205973754090365183}, diff --git a/tests/test_outputs_handler_sanitiser.py b/tests/test_outputs_handler_sanitiser.py index 6be0dce9..eda4cbcd 100644 --- a/tests/test_outputs_handler_sanitiser.py +++ b/tests/test_outputs_handler_sanitiser.py @@ -25,16 +25,15 @@ def test_sanitising_geodataframes_with_ids_list(tmpdir): 'x': {'0': 528704.1425925883, '1': 528804.1425925883}, 'y': {'0': 182068.78193707118, '1': 182168.78193707118}, 's2_id': {'0': '7860190995130875979', '1': '12118290696817869383'}} - correct_links = {'length': {0: 123}, 'modes': {0: 'car,walk'}, 'from': {0: '0'}, 'to': {0: '1'}, - 'id': {0: 'link_0'}, 'ids': {0: '1,2'}, 'u': {0: '0'}, 'v': {0: '1'}, 'key': {0: 0}} + correct_links = {'length': {'link_0': 123}, 'from': {'link_0': '0'}, 'to': {'link_0': '1'}, + 'id': {'link_0': 'link_0'}, 'ids': {'link_0': '1,2'}, 'u': {'link_0': '0'}, 'v': {'link_0': '1'}, + 'modes': {'link_0': 'car,walk'}} - nodes, links = gngeojson.generate_geodataframes(n.graph) + gdfs = gngeojson.generate_geodataframes(n.graph) + nodes, links = gdfs['nodes'], gdfs['links'] nodes = sanitiser.sanitise_geodataframe(nodes) links = sanitiser.sanitise_geodataframe(links) assert_semantically_equal(nodes[['x', 'y', 's2_id']].to_dict(), correct_nodes) - assert_semantically_equal(links[['length', 'from', 'to', 'id', 'ids', 'u', 'v', 'key', 'modes']].to_dict(), + assert_semantically_equal(links[['length', 'from', 'to', 'id', 'ids', 'u', 'v', 'modes']].to_dict(), correct_links) - - - diff --git a/tests/test_road_pricing.py b/tests/test_road_pricing.py index 9e7d4dc6..d4bed069 100644 --- a/tests/test_road_pricing.py +++ b/tests/test_road_pricing.py @@ -7,6 +7,7 @@ from genet.core import Network from genet.use import road_pricing +from genet.inputs_handler import read # paths in use assume we're in the repo's root, so make sure we always are root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) @@ -29,9 +30,7 @@ def road_pricing_sample_xml(): def network_object(): network_xml_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_data/road_pricing/network.xml")) - n = Network(epsg='epsg:27700') - n.read_matsim_network(network_xml_path) - yield n + yield read.read_matsim(path_to_network=network_xml_path, epsg='epsg:27700') @pytest.fixture def road_pricing_xml_tree(): diff --git a/tests/test_use_schedule.py b/tests/test_use_schedule.py index 86baa6c9..46fb3d3e 100644 --- a/tests/test_use_schedule.py +++ b/tests/test_use_schedule.py @@ -65,7 +65,8 @@ def test_offsets_going_over_24_hrs_why_not(): def test_generating_edge_vph_geodataframe(schedule): - nodes, links = gngeojson.generate_geodataframes(schedule.graph()) + gdfs = gngeojson.generate_geodataframes(schedule.graph()) + nodes, links = gdfs['nodes'], gdfs['links'] df = schedule.route_trips_with_stops_to_dataframe() df = use_schedule.generate_edge_vph_geodataframe(df, links) @@ -87,36 +88,25 @@ def test_generating_edge_vph_geodataframe(schedule): 11: 'Stop_3'}, 'vph': {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}, 'geometry': { - 0: LineString([(-7.557106577683727, 49.76682779861249), - (-7.557148039524952, 49.766825803756994)]), - 1: LineString([(-7.557106577683727, 49.76682779861249), - (-7.557148039524952, 49.766825803756994)]), - 2: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 3: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 4: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557121424907424, 49.76683608549253)]), - 5: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557121424907424, 49.76683608549253)]), - 6: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 7: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 8: LineString([(-7.557121424907424, 49.76683608549253), - (-7.5570681956375, 49.766856648946295)]), - 9: LineString([(-7.557121424907424, 49.76683608549253), - (-7.5570681956375, 49.766856648946295)]), - 10: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)]), - 11: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)])}}, crs='epsg:4326') + 0: LineString([(4,2), (1,2)]), + 1: LineString([(4,2), (1,2)]), + 2: LineString([(1,2), (4,2)]), + 3: LineString([(1,2), (4,2)]), + 4: LineString([(1,2), (3,3)]), + 5: LineString([(1,2), (3,3)]), + 6: LineString([(3,3), (1,2)]), + 7: LineString([(3,3), (1,2)]), + 8: LineString([(3,3), (7,5)]), + 9: LineString([(3,3), (7,5)]), + 10: LineString([(7,5), (3,3)]), + 11: LineString([(7,5), (3,3)])}}, crs='epsg:27700') assert_geodataframe_equal(df.sort_index(axis=1), correct_df.sort_index(axis=1), check_less_precise=True) def test_generating_edge_vph_geodataframe_for_service(schedule): - nodes, links = gngeojson.generate_geodataframes(schedule['service'].graph()) + gdfs = gngeojson.generate_geodataframes(schedule['service'].graph()) + nodes, links = gdfs['nodes'], gdfs['links'] df = schedule['service'].route_trips_with_stops_to_dataframe() df = use_schedule.generate_edge_vph_geodataframe(df, links) @@ -138,36 +128,25 @@ def test_generating_edge_vph_geodataframe_for_service(schedule): 11: 'Stop_3'}, 'vph': {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1}, 'geometry': { - 0: LineString([(-7.557106577683727, 49.76682779861249), - (-7.557148039524952, 49.766825803756994)]), - 1: LineString([(-7.557106577683727, 49.76682779861249), - (-7.557148039524952, 49.766825803756994)]), - 2: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 3: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 4: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557121424907424, 49.76683608549253)]), - 5: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557121424907424, 49.76683608549253)]), - 6: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 7: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 8: LineString([(-7.557121424907424, 49.76683608549253), - (-7.5570681956375, 49.766856648946295)]), - 9: LineString([(-7.557121424907424, 49.76683608549253), - (-7.5570681956375, 49.766856648946295)]), - 10: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)]), - 11: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)])}}, crs='epsg:4326') + 0: LineString([(4, 2), (1, 2)]), + 1: LineString([(4, 2), (1, 2)]), + 2: LineString([(1, 2), (4, 2)]), + 3: LineString([(1, 2), (4, 2)]), + 4: LineString([(1, 2), (3, 3)]), + 5: LineString([(1, 2), (3, 3)]), + 6: LineString([(3, 3), (1, 2)]), + 7: LineString([(3, 3), (1, 2)]), + 8: LineString([(3, 3), (7, 5)]), + 9: LineString([(3, 3), (7, 5)]), + 10: LineString([(7, 5), (3, 3)]), + 11: LineString([(7, 5), (3, 3)])}}, crs='epsg:27700') assert_geodataframe_equal(df.sort_index(axis=1), correct_df.sort_index(axis=1), check_less_precise=True) def test_generating_edge_vph_geodataframe_for_route(schedule): - nodes, links = gngeojson.generate_geodataframes(schedule.route('2').graph()) + gdfs = gngeojson.generate_geodataframes(schedule.route('2').graph()) + nodes, links = gdfs['nodes'], gdfs['links'] df = schedule.route('2').route_trips_with_stops_to_dataframe() df = use_schedule.generate_edge_vph_geodataframe(df, links) @@ -180,18 +159,12 @@ def test_generating_edge_vph_geodataframe_for_route(schedule): 'to_stop_name': {0: 'Stop_1', 1: 'Stop_1', 2: 'Stop_2', 3: 'Stop_2', 4: 'Stop_3', 5: 'Stop_3'}, 'vph': {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}, - 'geometry': {0: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 1: LineString([(-7.557148039524952, 49.766825803756994), - (-7.557106577683727, 49.76682779861249)]), - 2: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 3: LineString([(-7.557121424907424, 49.76683608549253), - (-7.557148039524952, 49.766825803756994)]), - 4: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)]), - 5: LineString([(-7.5570681956375, 49.766856648946295), - (-7.557121424907424, 49.76683608549253)])}}, crs='epsg:4326') + 'geometry': {0: LineString([(1, 2), (4, 2)]), + 1: LineString([(1, 2), (4, 2)]), + 2: LineString([(3, 3), (1, 2)]), + 3: LineString([(3, 3), (1, 2)]), + 4: LineString([(7, 5), (3, 3)]), + 5: LineString([(7, 5), (3, 3)])}}, crs='epsg:27700') assert_geodataframe_equal(df.sort_index(axis=1), correct_df.sort_index(axis=1), check_less_precise=True)