aprsd 1.0.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

aprsd/plugins/fortune.py

@@ -0,0 +1,61 @@
+import logging
+import shutil
+import subprocess
+
+from aprsd import packets, plugin
+from aprsd.utils import trace
+
+
+LOG = logging.getLogger("APRSD")
+
+DEFAULT_FORTUNE_PATH = '/usr/games/fortune'
+
+
+class FortunePlugin(plugin.APRSDRegexCommandPluginBase):
+    """Fortune."""
+
+    command_regex = r"^([f]|[f]\s|fortune)"
+    command_name = "fortune"
+    short_description = "Give me a fortune"
+
+    fortune_path = None
+
+    def setup(self):
+        self.fortune_path = shutil.which(DEFAULT_FORTUNE_PATH)
+        LOG.info(f"Fortune path {self.fortune_path}")
+        if not self.fortune_path:
+            self.enabled = False
+        else:
+            self.enabled = True
+
+    @trace.trace
+    def process(self, packet: packets.MessagePacket):
+        LOG.info("FortunePlugin")
+
+        # fromcall = packet.get("from")
+        # message = packet.get("message_text", None)
+        # ack = packet.get("msgNo", "0")
+
+        reply = None
+
+        try:
+            cmnd = [self.fortune_path, "-s", "-n 60"]
+            command = " ".join(cmnd)
+            output = subprocess.check_output(
+                command,
+                shell=True,
+                timeout=3,
+                universal_newlines=True,
+            )
+            output = (
+                output.replace("\r", "")
+                .replace("\n", "")
+                .replace("  ", "")
+                .replace("\t", " ")
+            )
+        except subprocess.CalledProcessError as ex:
+            reply = f"Fortune command failed '{ex.output}'"
+        else:
+            reply = output
+
+        return reply

aprsd/plugins/location.py

@@ -0,0 +1,179 @@
+import logging
+import re
+import time
+
+from geopy.geocoders import ArcGIS, AzureMaps, Baidu, Bing, GoogleV3
+from geopy.geocoders import HereV7, Nominatim, OpenCage, TomTom, What3WordsV3, Woosmap
+from oslo_config import cfg
+
+from aprsd import packets, plugin, plugin_utils
+from aprsd.utils import trace
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class UsLocation:
+    raw = {}
+
+    def __init__(self, info):
+        self.info = info
+
+    def __str__(self):
+        return self.info
+
+
+class USGov:
+    """US Government geocoder that uses the geopy API.
+
+    This is a dummy class the implements the geopy reverse API,
+    so the factory can return an object that conforms to the API.
+    """
+    def reverse(self, coordinates):
+        """Reverse geocode a coordinate."""
+        LOG.info(f"USGov reverse geocode {coordinates}")
+        coords = coordinates.split(",")
+        lat = float(coords[0])
+        lon = float(coords[1])
+        result = plugin_utils.get_weather_gov_for_gps(lat, lon)
+        # LOG.info(f"WEATHER: {result}")
+        # LOG.info(f"area description {result['location']['areaDescription']}")
+        if 'location' in result:
+            loc = UsLocation(result['location']['areaDescription'])
+        else:
+            loc = UsLocation("Unknown Location")
+
+        LOG.info(f"USGov reverse geocode LOC {loc}")
+        return loc
+
+
+def geopy_factory():
+    """Factory function for geopy geocoders."""
+    geocoder = CONF.location_plugin.geopy_geocoder
+    LOG.info(f"Using geocoder: {geocoder}")
+    user_agent = CONF.location_plugin.user_agent
+    LOG.info(f"Using user_agent: {user_agent}")
+
+    if geocoder == "Nominatim":
+        return Nominatim(user_agent=user_agent)
+    elif geocoder == "USGov":
+        return USGov()
+    elif geocoder == "ArcGIS":
+        return ArcGIS(
+            username=CONF.location_plugin.arcgis_username,
+            password=CONF.location_plugin.arcgis_password,
+            user_agent=user_agent,
+        )
+    elif geocoder == "AzureMaps":
+        return AzureMaps(
+            user_agent=user_agent,
+            subscription_key=CONF.location_plugin.azuremaps_subscription_key,
+        )
+    elif geocoder == "Baidu":
+        return Baidu(user_agent=user_agent, api_key=CONF.location_plugin.baidu_api_key)
+    elif geocoder == "Bing":
+        return Bing(user_agent=user_agent, api_key=CONF.location_plugin.bing_api_key)
+    elif geocoder == "GoogleV3":
+        return GoogleV3(user_agent=user_agent, api_key=CONF.location_plugin.google_api_key)
+    elif geocoder == "HERE":
+        return HereV7(user_agent=user_agent, api_key=CONF.location_plugin.here_api_key)
+    elif geocoder == "OpenCage":
+        return OpenCage(user_agent=user_agent, api_key=CONF.location_plugin.opencage_api_key)
+    elif geocoder == "TomTom":
+        return TomTom(user_agent=user_agent, api_key=CONF.location_plugin.tomtom_api_key)
+    elif geocoder == "What3Words":
+        return What3WordsV3(user_agent=user_agent, api_key=CONF.location_plugin.what3words_api_key)
+    elif geocoder == "Woosmap":
+        return Woosmap(user_agent=user_agent, api_key=CONF.location_plugin.woosmap_api_key)
+    else:
+        raise ValueError(f"Unknown geocoder: {geocoder}")
+
+
+class LocationPlugin(plugin.APRSDRegexCommandPluginBase, plugin.APRSFIKEYMixin):
+    """Location!"""
+
+    command_regex = r"^([l]|[l]\s|location)"
+    command_name = "location"
+    short_description = "Where in the world is a CALLSIGN's last GPS beacon?"
+
+    def setup(self):
+        self.ensure_aprs_fi_key()
+
+    @trace.trace
+    def process(self, packet: packets.MessagePacket):
+        LOG.info("Location Plugin")
+        fromcall = packet.from_call
+        message = packet.get("message_text", None)
+
+        api_key = CONF.aprs_fi.apiKey
+
+        # optional second argument is a callsign to search
+        a = re.search(r"^.*\s+(.*)", message)
+        if a is not None:
+            searchcall = a.group(1)
+            searchcall = searchcall.upper()
+        else:
+            # if no second argument, search for calling station
+            searchcall = fromcall
+
+        try:
+            aprs_data = plugin_utils.get_aprs_fi(api_key, searchcall)
+        except Exception as ex:
+            LOG.error(f"Failed to fetch aprs.fi '{ex}'")
+            return "Failed to fetch aprs.fi location"
+
+        LOG.debug(f"LocationPlugin: aprs_data = {aprs_data}")
+        if not len(aprs_data["entries"]):
+            LOG.error("Didn't get any entries from aprs.fi")
+            return "Failed to fetch aprs.fi location"
+
+        lat = float(aprs_data["entries"][0]["lat"])
+        lon = float(aprs_data["entries"][0]["lng"])
+
+        # Get some information about their location
+        try:
+            tic = time.perf_counter()
+            geolocator = geopy_factory()
+            LOG.info(f"Using GEOLOCATOR: {geolocator}")
+            coordinates = f"{lat:0.6f}, {lon:0.6f}"
+            location = geolocator.reverse(coordinates)
+            address = location.raw.get("address")
+            LOG.debug(f"GEOLOCATOR address: {address}")
+            toc = time.perf_counter()
+            if address:
+                LOG.info(f"Geopy address {address} took {toc - tic:0.4f}")
+                if address.get("country_code") == "us":
+                    area_info = f"{address.get('county')}, {address.get('state')}"
+                else:
+                    # what to do for address for non US?
+                    area_info = f"{address.get('country'), 'Unknown'}"
+            else:
+                area_info = str(location)
+        except Exception as ex:
+            LOG.error(ex)
+            LOG.error(f"Failed to fetch Geopy address {ex}")
+            area_info = "Unknown Location"
+
+        try:  # altitude not always provided
+            alt = float(aprs_data["entries"][0]["altitude"])
+        except Exception:
+            alt = 0
+        altfeet = int(alt * 3.28084)
+        aprs_lasttime_seconds = aprs_data["entries"][0]["lasttime"]
+        # aprs_lasttime_seconds = aprs_lasttime_seconds.encode(
+        #    "ascii", errors="ignore"
+        # )  # unicode to ascii
+        delta_seconds = time.time() - int(aprs_lasttime_seconds)
+        delta_hours = delta_seconds / 60 / 60
+
+        reply = "{}: {} {}' {},{} {}h ago".format(
+            searchcall,
+            area_info,
+            str(altfeet),
+            f"{lat:0.2f}",
+            f"{lon:0.2f}",
+            str("%.1f" % round(delta_hours, 1)),
+        ).rstrip()
+
+        return reply

aprsd/plugins/notify.py

@@ -0,0 +1,61 @@
+import logging
+
+from oslo_config import cfg
+
+from aprsd import packets, plugin
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class NotifySeenPlugin(plugin.APRSDWatchListPluginBase):
+    """Notification plugin to send seen message for callsign.
+
+
+    This plugin will track callsigns in the watch list and report
+    when a callsign has been seen when the last time they were
+    seen was older than the configured age limit.
+    """
+
+    short_description = "Notify me when a CALLSIGN is recently seen on APRS-IS"
+
+    def process(self, packet: packets.MessagePacket):
+        LOG.info("NotifySeenPlugin")
+
+        notify_callsign = CONF.watch_list.alert_callsign
+        fromcall = packet.from_call
+
+        wl = packets.WatchList()
+        age = wl.age(fromcall)
+
+        if fromcall != notify_callsign:
+            if wl.is_old(fromcall):
+                LOG.info(
+                    "NOTIFY {} last seen {} max age={}".format(
+                        fromcall,
+                        age,
+                        wl.max_delta(),
+                    ),
+                )
+                packet_type = packet.__class__.__name__
+                # we shouldn't notify the alert user that they are online.
+                pkt = packets.MessagePacket(
+                    from_call=CONF.callsign,
+                    to_call=notify_callsign,
+                    message_text=(
+                        f"{fromcall} was just seen by type:'{packet_type}'"
+                    ),
+                    allow_delay=False,
+                )
+                pkt.allow_delay = False
+                return pkt
+            else:
+                LOG.debug(
+                    "Not old enough to notify on callsign "
+                    f"'{fromcall}' : {age} < {wl.max_delta()}",
+                )
+                return packets.NULL_MESSAGE
+        else:
+            LOG.debug("fromcall and notify_callsign are the same, ignoring")
+            return packets.NULL_MESSAGE

aprsd/plugins/ping.py

@@ -0,0 +1,31 @@
+import logging
+import time
+
+from aprsd import plugin
+from aprsd.utils import trace
+
+
+LOG = logging.getLogger("APRSD")
+
+
+class PingPlugin(plugin.APRSDRegexCommandPluginBase):
+    """Ping."""
+
+    command_regex = r"^([p]|[p]\s|ping)"
+    command_name = "ping"
+    short_description = "reply with a Pong!"
+
+    @trace.trace
+    def process(self, packet):
+        LOG.info("PingPlugin")
+        # fromcall = packet.get("from")
+        # message = packet.get("message_text", None)
+        # ack = packet.get("msgNo", "0")
+        stm = time.localtime()
+        h = stm.tm_hour
+        m = stm.tm_min
+        s = stm.tm_sec
+        reply = (
+            "Pong! " + str(h).zfill(2) + ":" + str(m).zfill(2) + ":" + str(s).zfill(2)
+        )
+        return reply.rstrip()

aprsd/plugins/time.py

@@ -0,0 +1,115 @@
+import logging
+import re
+
+from oslo_config import cfg
+import pytz
+from tzlocal import get_localzone
+
+from aprsd import packets, plugin, plugin_utils
+from aprsd.utils import fuzzy, trace
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class TimePlugin(plugin.APRSDRegexCommandPluginBase):
+    """Time command."""
+
+    # Look for t or t<space> or T<space> or time
+    command_regex = r"^([t]|[t]\s|time)"
+    command_name = "time"
+    short_description = "What is the current local time."
+
+    def _get_local_tz(self):
+        lz = get_localzone()
+        return pytz.timezone(str(lz))
+
+    def _get_utcnow(self):
+        return pytz.datetime.datetime.utcnow()
+
+    def build_date_str(self, localzone):
+        utcnow = self._get_utcnow()
+        gmt_t = pytz.utc.localize(utcnow)
+        local_t = gmt_t.astimezone(localzone)
+
+        local_short_str = local_t.strftime("%H:%M %Z")
+        local_hour = local_t.strftime("%H")
+        local_min = local_t.strftime("%M")
+        cur_time = fuzzy(int(local_hour), int(local_min), 1)
+
+        reply = "{} ({})".format(
+            cur_time,
+            local_short_str,
+        )
+
+        return reply
+
+    @trace.trace
+    def process(self, packet: packets.Packet):
+        LOG.info("TIME COMMAND")
+        # So we can mock this in unit tests
+        localzone = self._get_local_tz()
+        return self.build_date_str(localzone)
+
+
+class TimeOWMPlugin(TimePlugin, plugin.APRSFIKEYMixin):
+    """OpenWeatherMap based timezone fetching."""
+
+    command_regex = r"^([t]|[t]\s|time)"
+    command_name = "time"
+    short_description = "Current time of GPS beacon's timezone. Uses OpenWeatherMap"
+
+    def setup(self):
+        self.ensure_aprs_fi_key()
+
+    @trace.trace
+    def process(self, packet: packets.MessagePacket):
+        fromcall = packet.from_call
+        message = packet.message_text
+        # ack = packet.get("msgNo", "0")
+
+        # optional second argument is a callsign to search
+        a = re.search(r"^.*\s+(.*)", message)
+        if a is not None:
+            searchcall = a.group(1)
+            searchcall = searchcall.upper()
+        else:
+            # if no second argument, search for calling station
+            searchcall = fromcall
+
+        api_key = CONF.aprs_fi.apiKey
+        try:
+            aprs_data = plugin_utils.get_aprs_fi(api_key, searchcall)
+        except Exception as ex:
+            LOG.error(f"Failed to fetch aprs.fi data {ex}")
+            return "Failed to fetch location"
+
+        LOG.debug(f"LocationPlugin: aprs_data = {aprs_data}")
+        if not len(aprs_data["entries"]):
+            LOG.error("Didn't get any entries from aprs.fi")
+            return "Failed to fetch aprs.fi location"
+
+        lat = aprs_data["entries"][0]["lat"]
+        lon = aprs_data["entries"][0]["lng"]
+
+        try:
+            self.config.exists(
+                ["services", "openweathermap", "apiKey"],
+            )
+        except Exception as ex:
+            LOG.error(f"Failed to find config openweathermap:apiKey {ex}")
+            return "No openweathermap apiKey found"
+
+        api_key = self.config["services"]["openweathermap"]["apiKey"]
+        try:
+            results = plugin_utils.fetch_openweathermap(api_key, lat, lon)
+        except Exception as ex:
+            LOG.error(f"Couldn't fetch openweathermap api '{ex}'")
+            # default to UTC
+            localzone = pytz.timezone("UTC")
+        else:
+            tzone = results["timezone"]
+            localzone = pytz.timezone(tzone)
+
+        return self.build_date_str(localzone)

aprsd/plugins/version.py

@@ -0,0 +1,31 @@
+import logging
+
+import aprsd
+from aprsd import plugin
+from aprsd.stats import collector
+
+
+LOG = logging.getLogger("APRSD")
+
+
+class VersionPlugin(plugin.APRSDRegexCommandPluginBase):
+    """Version of APRSD Plugin."""
+
+    command_regex = r"^([v]|[v]\s|version)"
+    command_name = "version"
+    short_description = "What is the APRSD Version"
+
+    # message_number:time combos so we don't resend the same email in
+    # five mins {int:int}
+    email_sent_dict = {}
+
+    def process(self, packet):
+        LOG.info("Version COMMAND")
+        # fromcall = packet.get("from")
+        # message = packet.get("message_text", None)
+        # ack = packet.get("msgNo", "0")
+        s = collector.Collector().collect()
+        return "APRSD ver:{} uptime:{}".format(
+            aprsd.__version__,
+            s["APRSDStats"]["uptime"],
+        )