class Monitor: def __init__(self): self.data_collector = DataCollector() self.new_location = DataCollector() def collect_default_data(self): self.data_collector.filter_radius() def relocate(self, location=None, coordinates=None, radius: int = 250): if location is not None: geolocator = Nominatim(user_agent="team_1_earthquake_detector") location_latitude = geolocator.geocode(location).latitude location_longitude = geolocator.geocode(location).longitude location_coordinates = (location_latitude, location_longitude) return self.new_location.filter_radius(location_coordinates, radius) if coordinates is not None: return self.new_location.filter_radius(coordinates, radius) def build_map(self, location=None, coordinates=None, radius=None): self.map = Map() if location is None and coordinates is None: self.map.set_up_map() self.collect_default_data() earthquake_overlay = EarthquakeOverlay( self.data_collector.earthquake_data_clean) earthquake_overlay.apply_circle_markers(self.map.map) earthquake_overlay.apply_magnitude_markers(self.map.map) earthquake_overlay.apply_connective_lines(self.map.map) earthquake_overlay.apply_heatmap(self.map.map) tectonic_overlay = TectonicOverlay() tectonic_overlay.apply_overlay(self.map.map) tectonic_overlay.add_to_layer_control(self.map.map) return self.map if location is not None or coordinates is not None: self.map.set_up_map(location=coordinates) self.relocate(location=location, coordinates=coordinates, radius=radius) earthquake_overlay = EarthquakeOverlay( self.new_location.earthquake_data_clean) earthquake_overlay.apply_circle_markers(self.map.map) earthquake_overlay.apply_magnitude_markers(self.map.map) earthquake_overlay.apply_connective_lines(self.map.map, coordinates) earthquake_overlay.apply_heatmap(self.map.map) tectonic_overlay = TectonicOverlay() tectonic_overlay.apply_overlay(self.map.map) tectonic_overlay.add_to_layer_control(self.map.map) return self.map def perform_earthquake_analytics(self, location=None, radius=None): self.data_collector.prep_data() self.data_collector.filter_radius() earthquake_analytics = EarthquakeAnalytics( self.data_collector.earthquake_data, self.data_collector.earthquake_data_clean) total_filtered = earthquake_analytics.get_total_filtered_earthquakes( location=location, radius=radius) minor_filtered = earthquake_analytics.get_filtered_minor_earthquakes( location=location, radius=radius) moderate_filtered = earthquake_analytics.get_filtered_moderate_earthquakes( location=location, radius=radius) strong_filtered = earthquake_analytics.get_filtered_strong_earthquakes( location=location, radius=radius) closest_filtered = earthquake_analytics.get_closest_filtered_earthquake( location=location) place_of_closest_filtered = earthquake_analytics.get_place_of_closest_filtered_earthquake( location=location) strongest_filtered = earthquake_analytics.get_strongest_filtered_earthquake( location=location, radius=radius) total_worldwide = earthquake_analytics.get_total_earthquakes_worldwide( ) minor_worldwide = earthquake_analytics.get_minor_earthquakes_worldwide( ) moderate_worldwide = earthquake_analytics.get_moderate_earthquakes_worldwide( ) strong_worldwide = earthquake_analytics.get_strong_earthquakes_worldwide( ) strongest_worldwide = earthquake_analytics.get_strongest_earthquake_worldwide( ) place_of_strongest_worldwide = earthquake_analytics.get_place_of_strongest_earthquake_worldwide( ) return total_filtered, minor_filtered, moderate_filtered, strong_filtered, closest_filtered, place_of_closest_filtered,\ strongest_filtered, total_worldwide, minor_worldwide, moderate_worldwide, strong_worldwide, strongest_worldwide, \ place_of_strongest_worldwide
class EarthquakeAnalytics: def __init__(self, earthquake_data, earthquake_data_clean): self.earthquake_data = earthquake_data self.earthquake_data_clean = earthquake_data_clean self.data_collector = DataCollector() self.new_location = DataCollector() def get_total_filtered_earthquakes(self, location=None, radius: int = 250): total_filtered_earthquakes = len( self.new_location.filter_radius(location=location, user_provided_radius=radius)) return total_filtered_earthquakes def get_filtered_minor_earthquakes(self, location=None, radius: int = 250): minor_earthquakes = [] for earthquake in self.new_location.filter_radius( location=location, user_provided_radius=radius): if earthquake["magnitude"] <= 2.5: minor_earthquakes.append(earthquake) filtered_minor_earthquakes = len(minor_earthquakes) return filtered_minor_earthquakes def get_filtered_moderate_earthquakes(self, location=None, radius: int = 250): moderate_earthquakes = [] for earthquake in self.new_location.filter_radius( location=location, user_provided_radius=radius): if 2.5 < earthquake["magnitude"] <= 6.0: moderate_earthquakes.append(earthquake) filtered_moderate_earthquakes = len(moderate_earthquakes) return filtered_moderate_earthquakes def get_filtered_strong_earthquakes(self, location=None, radius: int = 250): strong_earthquakes = [] for earthquake in self.new_location.filter_radius( location=location, user_provided_radius=radius): if earthquake["magnitude"] > 6.0: strong_earthquakes.append(earthquake) filtered_strong_earthquakes = len(strong_earthquakes) return filtered_strong_earthquakes def get_closest_filtered_earthquake(self, location=None): closest_filtered_earthquake = min([ earthquake['distance'] for earthquake in self.new_location.filter_radius( location=location, user_provided_radius=15000) ], default="-") return closest_filtered_earthquake def get_place_of_closest_filtered_earthquake(self, location=None): earthquake_data_clean = self.new_location.filter_radius( location=location, user_provided_radius=15000) distances = [] for i in range(len(earthquake_data_clean)): distances.append(earthquake_data_clean[i]["distance"]) if len(earthquake_data_clean) != 0: index_of_closest_filtered_earthquake = distances.index( min(distances)) place_of_closest_filtered_earthquake = earthquake_data_clean[ index_of_closest_filtered_earthquake]["place"] return place_of_closest_filtered_earthquake else: return "-" def get_strongest_filtered_earthquake(self, location=None, radius: int = 250): strongest_filtered_earthquake = max([ earthquake['magnitude'] for earthquake in self.new_location.filter_radius( location=location, user_provided_radius=radius) ], default="-") return strongest_filtered_earthquake def get_total_earthquakes_worldwide(self): total_earthquakes_worldwide = len(self.data_collector.prep_data()) return total_earthquakes_worldwide def get_minor_earthquakes_worldwide(self): minor_earthquakes = [] for earthquake in self.new_location.prep_data(): if earthquake["magnitude"] <= 2.5: minor_earthquakes.append(earthquake) minor_earthquakes_worldwide = len(minor_earthquakes) return minor_earthquakes_worldwide def get_moderate_earthquakes_worldwide(self): moderate_earthquakes = [] for earthquake in self.new_location.prep_data(): if 2.5 < earthquake["magnitude"] <= 6.0: moderate_earthquakes.append(earthquake) moderate_earthquakes_worldwide = len(moderate_earthquakes) return moderate_earthquakes_worldwide def get_strong_earthquakes_worldwide(self): strong_earthquakes = [] for earthquake in self.new_location.prep_data(): if earthquake["magnitude"] > 6.0: strong_earthquakes.append(earthquake) strong_earthquakes_worldwide = len(strong_earthquakes) return strong_earthquakes_worldwide def get_strongest_earthquake_worldwide(self): strongest_earthquake_worldwide = max([ earthquake['magnitude'] for earthquake in self.data_collector.prep_data() ], default="-") return strongest_earthquake_worldwide def get_place_of_strongest_earthquake_worldwide(self): earthquake_data = self.data_collector.prep_data() magnitudes = [] for i in range(len(earthquake_data)): magnitudes.append(earthquake_data[i]["magnitude"]) if len(earthquake_data) != 0: index_of_strongest_earthquake_worldwide = magnitudes.index( max(magnitudes)) place_of_strongest_earthquake_worldwide = earthquake_data[ index_of_strongest_earthquake_worldwide]["place"] return place_of_strongest_earthquake_worldwide else: return "-"