bugfix, typing and cosmetics

Author: xoolive

traffic/__init__.py

@@ -2,6 +2,9 @@
 import imp
 import inspect
 import logging
+import os
+import subprocess
+import sys
 from pathlib import Path
 
 from appdirs import user_cache_dir, user_config_dir
@@ -31,9 +34,19 @@
 config = configparser.ConfigParser()
 config.read(config_file.as_posix())
 
+
+def edit_config():
+    if sys.platform.startswith("darwin"):
+        subprocess.call(("open", config_file))
+    elif os.name == "nt":  # For Windows
+        os.startfile(config_dir)
+    elif os.name == "posix":  # For Linux, Mac, etc.
+        subprocess.call(("xdg-open", config_file))
+
+
 _selected = [
-    s.strip() for s in config.get("plugins", "enabled_plugins",
-                                  fallback="").split(",")
+    s.strip()
+    for s in config.get("plugins", "enabled_plugins", fallback="").split(",")
 ]
 _plugin_paths = [Path(__file__).parent / "plugins", config_dir / "plugins"]
 _all_plugins = []

traffic/core/flight.py

@@ -7,11 +7,13 @@
                     Set, Tuple, Union, cast)
 
 import numpy as np
+from matplotlib.artist import Artist
 from matplotlib.axes._subplots import Axes
 
 import geodesy.wgs84 as geo
 import pandas as pd
 import scipy.signal
+from cartopy.crs import PlateCarree
 from cartopy.mpl.geoaxes import GeoAxesSubplot
 from shapely.geometry import LineString, base
 
@@ -32,6 +34,10 @@ def _split(data: pd.DataFrame, value, unit) -> Iterator[pd.DataFrame]:
         yield data
 
 
+class Position(PointMixin, pd.core.series.Series):
+    pass
+
+
 class Flight(DataFrameMixin, ShapelyMixin, GeographyMixin):
     """Flight is the basic class associated to an aircraft itinerary.
 
@@ -101,7 +107,7 @@ def stop(self) -> pd.Timestamp:
     @property
     def callsign(self) -> Union[str, Set[str], None]:
         """Returns the unique callsign value(s) of the DataFrame."""
-        if 'callsign' not in self.data.columns:
+        if "callsign" not in self.data.columns:
             return None
         tmp = set(self.data.callsign)
         if len(tmp) == 1:
@@ -537,18 +543,16 @@ def comet(b, **kwargs) -> "Flight":
             ).ffill()
         )
 
-    def at(self, time: Optional[timelike] = None) -> Optional[pd.core.series.Series]:
-        class Position(PointMixin, pd.core.series.Series):
-            pass
+    def at(self, time: Optional[timelike] = None) -> Optional[Position]:
 
         if time is None:
             return Position(self.data.ffill().iloc[-1])
 
         index = to_datetime(time)
         df = self.data.set_index("timestamp")
         if index not in df.index:
-            id_ = getattr(self, 'flight_id', self.callsign)
-            logging.warn(f'No index {index} for flight {id_}')
+            id_ = getattr(self, "flight_id", self.callsign)
+            logging.warn(f"No index {index} for flight {id_}")
             return None
         return Position(df.loc[index])
 
@@ -618,13 +622,13 @@ def _clip_generator():
 
     # -- Visualisation --
 
-    def plot(self, ax: GeoAxesSubplot, **kwargs) -> None:
-        if "projection" in ax.__dict__ and "transform" not in kwargs:
-            from cartopy.crs import PlateCarree
+    def plot(self, ax: GeoAxesSubplot, **kwargs) -> List[Artist]:
 
+        if "projection" in ax.__dict__ and "transform" not in kwargs:
             kwargs["transform"] = PlateCarree()
         if self.shape is not None:
             return ax.plot(*self.shape.xy, **kwargs)
+        return []
 
     def plot_time(
         self,

traffic/core/mixins.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from functools import lru_cache, partial
 from pathlib import Path
 from typing import List, Tuple, Union
@@ -195,6 +196,8 @@ class PointMixin(object):
 
     latitude: float
     longitude: float
+    altitude: float
+    timestamp: datetime
 
     def plot(
         self, ax: Axes, text_kw=None, shift=dict(units="dots", x=15), **kwargs

traffic/core/traffic.py

@@ -136,11 +136,7 @@ def end_time(self) -> pd.Timestamp:
     @lru_cache()
     def callsigns(self) -> Set[str]:
         """Return only the most relevant callsigns"""
-        sub = (
-            self.data.query("callsign == callsign")
-            .groupby(["callsign", "icao24"])
-            .filter(lambda x: len(x) > 10)
-        )
+        sub = self.data.query("callsign == callsign")
         return set(cs for cs in sub.callsign if len(cs) > 3 and " " not in cs)
 
     @property

traffic/data/adsb/decode.py

@@ -27,6 +27,7 @@ class StoppableThread(threading.Thread):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.daemon = True  # is it redundant?
         self._stop_event = threading.Event()
 
     def stop(self):

traffic/drawing/ipywidgets.py

@@ -180,20 +180,21 @@ def create_map(
             with plt.style.context("traffic"):
 
                 self.fig_map.clear()
-                self.ax = self.fig_map.add_subplot(
+                self.trajectories.clear()
+                self.ax_map = self.fig_map.add_subplot(
                     111, projection=self.projection
                 )
-                self.ax.add_feature(countries())
+                self.ax_map.add_feature(countries())
                 if projection.__class__.__name__.split(".")[-1] in [
                     "Lambert93"
                 ]:
-                    self.ax.add_feature(rivers())
+                    self.ax_map.add_feature(rivers())
 
                 self.fig_map.set_tight_layout(True)
-                self.ax.background_patch.set_visible(False)
-                self.ax.outline_patch.set_visible(False)
-                self.ax.format_coord = lambda x, y: ""
-                self.ax.set_global()
+                self.ax_map.background_patch.set_visible(False)
+                self.ax_map.outline_patch.set_visible(False)
+                self.ax_map.format_coord = lambda x, y: ""
+                self.ax_map.set_global()
 
             self.default_plot()
             self.canvas_map.draw_idle()
@@ -205,8 +206,9 @@ def default_plot(self) -> None:
                 for elt in value:
                     elt.remove()
             self.trajectories.clear()
+            self.ax_map.set_prop_cycle(None)
 
-            lon_min, lon_max, lat_min, lat_max = self.ax.get_extent(
+            lon_min, lon_max, lat_min, lat_max = self.ax_map.get_extent(
                 PlateCarree()
             )
             cur_flights = list(
@@ -223,7 +225,7 @@ def params(at):
                     return dict(s=8, text_kw=dict(s=""))
 
             for at in cur_flights:
-                self.trajectories[at.callsign] += at.plot(self.ax, **params(at))
+                self.trajectories[at.callsign] += at.plot(self.ax_map, **params(at))
 
             self.canvas_map.draw_idle()
 
@@ -238,13 +240,11 @@ def create_timeplot(self) -> None:
     def on_projection_change(self, change: Dict[str, Any]) -> None:
         with self.output:
             if change["name"] == "value":
-                self.trajectories.clear()
                 self.create_map(change["new"])
 
     def on_clear_button(self, elt: Dict[str, Any]) -> None:
         with self.output:
             self.t_view = self.traffic.sort_values("timestamp")
-            self.trajectories.clear()
             self.create_map(self.projection)
             self.create_timeplot()
 
@@ -268,20 +268,20 @@ def on_area_click(self, elt: Dict[str, Any]) -> None:
                 return
             from ..data import airac
 
-            self.ax.set_extent(airac[elt["new"][0]])
+            self.ax_map.set_extent(airac[elt["new"][0]])
             self.canvas_map.draw_idle()
 
     def on_extent_button(self, elt: Dict[str, Any]) -> None:
         with self.output:
             if len(self.area_select.value) == 0:
                 if len(self.area_input.value) == 0:
-                    self.ax.set_global()
+                    self.ax_map.set_global()
                 else:
-                    self.ax.set_extent(location(self.area_input.value))
+                    self.ax_map.set_extent(location(self.area_input.value))
             else:
                 from ..data import airac
 
-                self.ax.set_extent(airac[self.area_select.value[0]])
+                self.ax_map.set_extent(airac[self.area_select.value[0]])
 
             t1, t2 = self.time_slider.index
             low, up = self.altitude_select.value
@@ -319,32 +319,32 @@ def on_plot_button(self, elt: Dict[str, Any]) -> None:
                 if len(self.area_input.value) == 0:
                     return self.default_plot()
                 location(self.area_input.value).plot(
-                    self.ax, color="grey", linestyle="dashed"
+                    self.ax_map, color="grey", linestyle="dashed"
                 )
             else:
                 from ..data import airac
 
                 airspace = airac[self.area_select.value[0]]
                 if airspace is not None:
-                    airspace.plot(self.ax)
+                    airspace.plot(self.ax_map)
             self.canvas_map.draw_idle()
 
     def on_plot_airport(self, elt: Dict[str, Any]) -> None:
         with self.output:
             if len(self.area_input.value) == 0:
                 from cartotools.osm import request, tags
 
-                west, east, south, north = self.ax.get_extent(crs=PlateCarree())
+                west, east, south, north = self.ax_map.get_extent(crs=PlateCarree())
                 if abs(east - west) > 1 or abs(north - south) > 1:
                     # that would be a too big request
                     return
                 request((west, south, east, north), **tags.airport).plot(
-                    self.ax
+                    self.ax_map
                 )
             else:
                 from ..data import airports
 
-                airports[self.area_input.value].plot(self.ax)
+                airports[self.area_input.value].plot(self.ax_map)
             self.canvas_map.draw_idle()
 
     def on_id_change(self, change: Dict[str, Any]) -> None:
@@ -364,9 +364,9 @@ def on_id_change(self, change: Dict[str, Any]) -> None:
                 f = self.t_view[c]
                 if f is not None:
                     try:
-                        self.trajectories[c] += f.plot(self.ax)
+                        self.trajectories[c] += f.plot(self.ax_map)
                         self.trajectories[c] += f.at().plot(
-                            self.ax, s=8, text_kw=dict(s=c)
+                            self.ax_map, s=8, text_kw=dict(s=c)
                         )
                     except TypeError:  # NoneType object is not iterable
                         pass
@@ -401,7 +401,7 @@ def on_id_change(self, change: Dict[str, Any]) -> None:
 
     def on_filter(self, low, up, t1, t2) -> None:
         with self.output:
-            west, east, south, north = self.ax.get_extent(crs=PlateCarree())
+            west, east, south, north = self.ax_map.get_extent(crs=PlateCarree())
 
             self.t_view = (
                 self.traffic.between(self.dates[t1], self.dates[t2])