aprsd 3.2.2__py2.py3-none-any.whl → 3.3.1__py2.py3-none-any.whl

aprsd/log/log.py

@@ -1,13 +1,12 @@
 import logging
-from logging import NullHandler
-from logging.handlers import RotatingFileHandler
+from logging.handlers import QueueHandler
 import queue
 import sys
 
+from loguru import logger
 from oslo_config import cfg
 
 from aprsd import conf
-from aprsd.log import rich as aprsd_logging
 
 
 CONF = cfg.CONF
@@ -15,75 +14,84 @@ LOG = logging.getLogger("APRSD")
 logging_queue = queue.Queue()
 
 
+class InterceptHandler(logging.Handler):
+    def emit(self, record):
+        # get corresponding Loguru level if it exists
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        # find caller from where originated the logged message
+        frame, depth = sys._getframe(6), 6
+        while frame and frame.f_code.co_filename == logging.__file__:
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+
 # Setup the log faciility
 # to disable log to stdout, but still log to file
 # use the --quiet option on the cmdln
-def setup_logging(loglevel, quiet):
-    log_level = conf.log.LOG_LEVELS[loglevel]
-    LOG.setLevel(log_level)
-    date_format = CONF.logging.date_format
-    rh = None
-    fh = None
-
-    rich_logging = False
-    if CONF.logging.get("rich_logging", False) and not quiet:
-        log_format = "%(message)s"
-        log_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
-        rh = aprsd_logging.APRSDRichHandler(
-            show_thread=True, thread_width=20,
-            rich_tracebacks=True, omit_repeated_times=False,
+def setup_logging(loglevel=None, quiet=False):
+    if not loglevel:
+        log_level = CONF.logging.log_level
+    else:
+        log_level = conf.log.LOG_LEVELS[loglevel]
+
+    # intercept everything at the root logger
+    logging.root.handlers = [InterceptHandler()]
+    logging.root.setLevel(log_level)
+
+    imap_list = [
+        "imapclient.imaplib", "imaplib", "imapclient",
+        "imapclient.util",
+    ]
+    aprslib_list = [
+        "aprslib",
+        "aprslib.parsing",
+        "aprslib.exceptions",
+    ]
+
+    # We don't really want to see the aprslib parsing debug output.
+    disable_list = imap_list + aprslib_list
+
+    # remove every other logger's handlers
+    # and propagate to root logger
+    for name in logging.root.manager.loggerDict.keys():
+        logging.getLogger(name).handlers = []
+        if name in disable_list:
+            logging.getLogger(name).propagate = False
+        else:
+            logging.getLogger(name).propagate = True
+
+    handlers = [
+        {
+            "sink": sys.stdout, "serialize": False,
+            "format": CONF.logging.logformat,
+        },
+    ]
+    if CONF.logging.logfile:
+        handlers.append(
+            {
+                "sink": CONF.logging.logfile, "serialize": False,
+                "format": CONF.logging.logformat,
+            },
         )
-        rh.setFormatter(log_formatter)
-        LOG.addHandler(rh)
-        rich_logging = True
 
-    log_file = CONF.logging.logfile
-    log_format = CONF.logging.logformat
-    log_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
-
-    if log_file:
-        fh = RotatingFileHandler(log_file, maxBytes=(10248576 * 5), backupCount=4)
-        fh.setFormatter(log_formatter)
-        LOG.addHandler(fh)
-
-    imap_logger = None
     if CONF.email_plugin.enabled and CONF.email_plugin.debug:
-        imap_logger = logging.getLogger("imapclient.imaplib")
-        imap_logger.setLevel(log_level)
-        if rh:
-            imap_logger.addHandler(rh)
-        if fh:
-            imap_logger.addHandler(fh)
+        for name in imap_list:
+            logging.getLogger(name).propagate = True
 
     if CONF.admin.web_enabled:
-        qh = logging.handlers.QueueHandler(logging_queue)
-        q_log_formatter = logging.Formatter(
-            fmt=CONF.logging.logformat,
-            datefmt=CONF.logging.date_format,
+        qh = QueueHandler(logging_queue)
+        handlers.append(
+            {
+                "sink": qh, "serialize": False,
+                "format": CONF.logging.logformat,
+            },
         )
-        qh.setFormatter(q_log_formatter)
-        LOG.addHandler(qh)
-
-    if not quiet and not rich_logging:
-        sh = logging.StreamHandler(sys.stdout)
-        sh.setFormatter(log_formatter)
-        LOG.addHandler(sh)
-        if imap_logger:
-            imap_logger.addHandler(sh)
-
-
-def setup_logging_no_config(loglevel, quiet):
-    log_level = conf.log.LOG_LEVELS[loglevel]
-    LOG.setLevel(log_level)
-    log_format = CONF.logging.logformat
-    date_format = CONF.logging.date_format
-    log_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
-    fh = NullHandler()
-
-    fh.setFormatter(log_formatter)
-    LOG.addHandler(fh)
-
-    if not quiet:
-        sh = logging.StreamHandler(sys.stdout)
-        sh.setFormatter(log_formatter)
-        LOG.addHandler(sh)
+
+    # configure loguru
+    logger.configure(handlers=handlers)

aprsd/main.py

@@ -59,20 +59,25 @@ click_completion.core.startswith = custom_startswith
 click_completion.init()
 
 
-@click.group(context_settings=CONTEXT_SETTINGS)
+@click.group(cls=cli_helper.AliasedGroup, context_settings=CONTEXT_SETTINGS)
 @click.version_option()
 @click.pass_context
 def cli(ctx):
     pass
 
 
-def main():
-    # First import all the possible commands for the CLI
-    # The commands themselves live in the cmds directory
+def load_commands():
     from .cmds import (  # noqa
         completion, dev, fetch_stats, healthcheck, list_plugins, listen,
         send_message, server, webchat,
     )
+
+
+def main():
+    # First import all the possible commands for the CLI
+    # The commands themselves live in the cmds directory
+    load_commands()
+    utils.load_entry_points("aprsd.extension")
     cli(auto_envvar_prefix="APRSD")
 
 
@@ -120,12 +125,7 @@ def sample_config(ctx):
     def get_namespaces():
         args = []
 
-        all = imp.entry_points()
-        selected = []
-        if "oslo.config.opts" in all:
-            for x in all["oslo.config.opts"]:
-                if x.group == "oslo.config.opts":
-                    selected.append(x)
+        selected = imp.entry_points(group="oslo.config.opts")
         for entry in selected:
             if "aprsd" in entry.name:
                 args.append("--namespace")
@@ -146,8 +146,8 @@ def sample_config(ctx):
             raise SystemExit
         raise
     LOG.warning(conf.namespace)
-    return
     generator.generate(conf)
+    return
 
 
 @cli.command()

aprsd/packets/__init__.py

@@ -1,6 +1,6 @@
 from aprsd.packets.core import (  # noqa: F401
-    AckPacket, GPSPacket, MessagePacket, MicEPacket, Packet, RejectPacket,
-    StatusPacket, WeatherPacket,
+    AckPacket, BeaconPacket, GPSPacket, MessagePacket, MicEPacket, Packet,
+    RejectPacket, StatusPacket, WeatherPacket,
 )
 from aprsd.packets.packet_list import PacketList  # noqa: F401
 from aprsd.packets.seen_list import SeenList  # noqa: F401

aprsd/packets/core.py

@@ -148,7 +148,6 @@ class Packet(metaclass=abc.ABCMeta):
             self.from_call,
             self.payload,
         )
-        LOG.debug(f"_build_raw: payload '{self.payload}' raw '{self.raw}'")
 
     @staticmethod
     def factory(raw_packet):
@@ -466,6 +465,26 @@ class GPSPacket(Packet):
         )
 
 
+@dataclass(unsafe_hash=True)
+class BeaconPacket(GPSPacket):
+    def _build_payload(self):
+        """The payload is the non headers portion of the packet."""
+        time_zulu = self._build_time_zulu()
+        lat = self.convert_latitude(self.latitude)
+        long = self.convert_longitude(self.longitude)
+
+        self.payload = (
+            f"@{time_zulu}z{lat}{self.symbol_table}"
+            f"{long}{self.symbol}APRSD Beacon"
+        )
+
+    def _build_raw(self):
+        self.raw = (
+            f"{self.from_call}>APZ100:"
+            f"{self.payload}"
+        )
+
+
 @dataclass
 class MicEPacket(GPSPacket):
     messagecapable: bool = False

aprsd/plugin_utils.py

@@ -76,6 +76,7 @@ def fetch_openweathermap(api_key, lat, lon, units="metric", exclude=None):
                 exclude,
             )
         )
+        LOG.debug(f"Fetching OWM weather '{url}'")
         response = requests.get(url)
     except Exception as e:
         LOG.error(e)

aprsd/plugins/fortune.py

@@ -8,6 +8,8 @@ from aprsd.utils import trace
 
 LOG = logging.getLogger("APRSD")
 
+DEFAULT_FORTUNE_PATH = '/usr/games/fortune'
+
 
 class FortunePlugin(plugin.APRSDRegexCommandPluginBase):
     """Fortune."""
@@ -19,7 +21,8 @@ class FortunePlugin(plugin.APRSDRegexCommandPluginBase):
     fortune_path = None
 
     def setup(self):
-        self.fortune_path = shutil.which("fortune")
+        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:

aprsd/plugins/location.py

@@ -2,7 +2,8 @@ import logging
 import re
 import time
 
-from geopy.geocoders import Nominatim
+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
@@ -13,6 +14,82 @@ 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!"""
 
@@ -57,19 +134,24 @@ class LocationPlugin(plugin.APRSDRegexCommandPluginBase, plugin.APRSFIKEYMixin):
         # Get some information about their location
         try:
             tic = time.perf_counter()
-            geolocator = Nominatim(user_agent="APRSD")
+            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')}"
+                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:
-                # what to do for address for non US?
-                area_info = f"{address.get('country'), 'Unknown'}"
+                area_info = str(location)
         except Exception as ex:
+            LOG.error(ex)
             LOG.error(f"Failed to fetch Geopy address {ex}")
             area_info = "Unknown Location"
 

aprsd/plugins/weather.py

@@ -26,7 +26,9 @@ class USWeatherPlugin(plugin.APRSDRegexCommandPluginBase, plugin.APRSFIKEYMixin)
     "weather" - returns weather near the calling callsign
     """
 
-    command_regex = r"^([w][x]|[w][x]\s|weather)"
+    # command_regex = r"^([w][x]|[w][x]\s|weather)"
+    command_regex = r"^[wW]"
+
     command_name = "USWeather"
     short_description = "Provide USA only weather of GPS Beacon location"
 
@@ -189,7 +191,9 @@ class OWMWeatherPlugin(plugin.APRSDRegexCommandPluginBase):
 
     """
 
-    command_regex = r"^([w][x]|[w][x]\s|weather)"
+    # command_regex = r"^([w][x]|[w][x]\s|weather)"
+    command_regex = r"^[wW]"
+
     command_name = "OpenWeatherMap"
     short_description = "OpenWeatherMap weather of GPS Beacon location"
 
@@ -211,7 +215,7 @@ class OWMWeatherPlugin(plugin.APRSDRegexCommandPluginBase):
 
     @trace.trace
     def process(self, packet):
-        fromcall = packet.get("from")
+        fromcall = packet.get("from_call")
         message = packet.get("message_text", None)
         # ack = packet.get("msgNo", "0")
         LOG.info(f"OWMWeather Plugin '{message}'")

aprsd/threads/__init__.py

@@ -4,7 +4,7 @@ import queue
 # aprsd.threads
 from .aprsd import APRSDThread, APRSDThreadList  # noqa: F401
 from .keep_alive import KeepAliveThread  # noqa: F401
-from .rx import APRSDRXThread  # noqa: F401
+from .rx import APRSDRXThread, APRSDDupeRXThread, APRSDProcessPacketThread  # noqa: F401
 
 
 packet_queue = queue.Queue(maxsize=20)

aprsd/threads/registry.py

@@ -0,0 +1,56 @@
+import logging
+import time
+
+from oslo_config import cfg
+import requests
+
+import aprsd
+from aprsd import threads as aprsd_threads
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class APRSRegistryThread(aprsd_threads.APRSDThread):
+    """This sends service information to the configured APRS Registry."""
+    _loop_cnt: int = 1
+
+    def __init__(self):
+        super().__init__("APRSRegistryThread")
+        self._loop_cnt = 1
+        if not CONF.aprs_registry.enabled:
+            LOG.error(
+                "APRS Registry is not enabled.  ",
+            )
+            LOG.error(
+                "APRS Registry thread is STOPPING.",
+            )
+            self.stop()
+        LOG.info(
+            "APRS Registry thread is running and will send "
+            f"info every {CONF.aprs_registry.frequency_seconds} seconds "
+            f"to {CONF.aprs_registry.registry_url}.",
+        )
+
+    def loop(self):
+        # Only call the registry every N seconds
+        if self._loop_cnt % CONF.aprs_registry.frequency_seconds == 0:
+            info = {
+                "callsign": CONF.callsign,
+                "description": CONF.aprs_registry.description,
+                "service_website": CONF.aprs_registry.service_website,
+                "software": f"APRSD version {aprsd.__version__} "
+                            "https://github.com/craigerl/aprsd",
+            }
+            try:
+                requests.post(
+                    f"{CONF.aprs_registry.registry_url}",
+                    json=info,
+                )
+            except Exception as e:
+                LOG.error(f"Failed to send registry info: {e}")
+
+        time.sleep(1)
+        self._loop_cnt += 1
+        return True

aprsd/threads/rx.py

@@ -58,12 +58,13 @@ class APRSDRXThread(APRSDThread):
         pass
 
 
-class APRSDPluginRXThread(APRSDRXThread):
+class APRSDDupeRXThread(APRSDRXThread):
     """Process received packets.
 
     This is the main APRSD Server command thread that
-    receives packets from APRIS and then sends them for
-    processing in the PluginProcessPacketThread.
+    receives packets and makes sure the packet
+    hasn't been seen previously before sending it on
+    to be processed.
     """
 
     def process_packet(self, *args, **kwargs):
@@ -118,6 +119,13 @@ class APRSDPluginRXThread(APRSDRXThread):
                 self.packet_queue.put(packet)
 
 
+class APRSDPluginRXThread(APRSDDupeRXThread):
+    """"Process received packets.
+
+    For backwards compatibility, we keep the APRSDPluginRXThread.
+    """
+
+
 class APRSDProcessPacketThread(APRSDThread):
     """Base class for processing received packets.
 
@@ -157,7 +165,7 @@ class APRSDProcessPacketThread(APRSDThread):
 
     def process_packet(self, packet):
         """Process a packet received from aprs-is server."""
-        LOG.debug(f"RXPKT-LOOP {self._loop_cnt}")
+        LOG.debug(f"ProcessPKT-LOOP {self._loop_cnt}")
         our_call = CONF.callsign.lower()
 
         from_call = packet.from_call
@@ -202,7 +210,7 @@ class APRSDProcessPacketThread(APRSDThread):
                 self.process_other_packet(
                     packet, for_us=(to_call.lower() == our_call),
                 )
-        LOG.debug("Packet processing complete")
+        LOG.debug(f"Packet processing complete for pkt '{packet.key}'")
         return False
 
     @abc.abstractmethod

aprsd/threads/tx.py

@@ -37,6 +37,7 @@ msg_throttle_decorator = decorator.ThrottleDecorator(throttle=msg_t)
 ack_throttle_decorator = decorator.ThrottleDecorator(throttle=ack_t)
 
 
+@msg_throttle_decorator.sleep_and_retry
 def send(packet: core.Packet, direct=False, aprs_client=None):
     """Send a packet either in a thread or directly to the client."""
     # prepare the packet for sending.
@@ -194,3 +195,42 @@ class SendAckThread(aprsd_threads.APRSDThread):
         time.sleep(1)
         self.loop_count += 1
         return True
+
+
+class BeaconSendThread(aprsd_threads.APRSDThread):
+    """Thread that sends a GPS beacon packet periodically.
+
+    Settings are in the [DEFAULT] section of the config file.
+    """
+    _loop_cnt: int = 1
+
+    def __init__(self):
+        super().__init__("BeaconSendThread")
+        self._loop_cnt = 1
+        # Make sure Latitude and Longitude are set.
+        if not CONF.latitude or not CONF.longitude:
+            LOG.error(
+                "Latitude and Longitude are not set in the config file."
+                "Beacon will not be sent and thread is STOPPED.",
+            )
+            self.stop()
+        LOG.info(
+            "Beacon thread is running and will send "
+            f"beacons every {CONF.beacon_interval} seconds.",
+        )
+
+    def loop(self):
+        # Only dump out the stats every N seconds
+        if self._loop_cnt % CONF.beacon_interval == 0:
+            pkt = core.BeaconPacket(
+                from_call=CONF.callsign,
+                to_call="APRS",
+                latitude=float(CONF.latitude),
+                longitude=float(CONF.longitude),
+                comment="APRSD GPS Beacon",
+                symbol=CONF.beacon_symbol,
+            )
+            send(pkt, direct=True)
+        self._loop_cnt += 1
+        time.sleep(1)
+        return True

aprsd/utils/__init__.py

@@ -4,6 +4,7 @@ import errno
 import os
 import re
 import sys
+import traceback
 
 import update_checker
 
@@ -131,3 +132,21 @@ def parse_delta_str(s):
         return {key: float(val) for key, val in m.groupdict().items()}
     else:
         return {}
+
+
+def load_entry_points(group):
+    """Load all extensions registered to the given entry point group"""
+    print(f"Loading extensions for group {group}")
+    try:
+        import importlib_metadata
+    except ImportError:
+        # For python 3.10 and later
+        import importlib.metadata as importlib_metadata
+
+    eps = importlib_metadata.entry_points(group=group)
+    for ep in eps:
+        try:
+            ep.load()
+        except Exception as e:
+            print(f"Extension {ep.name} of group {group} failed to load with {e}", file=sys.stderr)
+            print(traceback.format_exc(), file=sys.stderr)

aprsd/utils/objectstore.py

@@ -28,6 +28,9 @@ class ObjectStoreMixin:
     def __len__(self):
         return len(self.data)
 
+    def __iter__(self):
+        return iter(self.data)
+
     def get_all(self):
         with self.lock:
             return self.data
@@ -96,11 +99,14 @@ class ObjectStoreMixin:
                         LOG.debug(
                             f"{self.__class__.__name__}::Loaded {len(self)} entries from disk.",
                         )
-                        LOG.debug(f"{self.data}")
+                    else:
+                        LOG.debug(f"{self.__class__.__name__}::No data to load.")
             except (pickle.UnpicklingError, Exception) as ex:
                 LOG.error(f"Failed to UnPickle {self._save_filename()}")
                 LOG.error(ex)
                 self.data = {}
+        else:
+            LOG.debug(f"{self.__class__.__name__}::No save file found.")
 
     def flush(self):
         """Nuke the old pickle file that stored the old results from last aprsd run."""

aprsd/web/chat/static/images/globe.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-globe" viewBox="0 0 16 16">
+  <path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8m7.5-6.923c-.67.204-1.335.82-1.887 1.855A8 8 0 0 0 5.145 4H7.5zM4.09 4a9.3 9.3 0 0 1 .64-1.539 7 7 0 0 1 .597-.933A7.03 7.03 0 0 0 2.255 4zm-.582 3.5c.03-.877.138-1.718.312-2.5H1.674a7 7 0 0 0-.656 2.5zM4.847 5a12.5 12.5 0 0 0-.338 2.5H7.5V5zM8.5 5v2.5h2.99a12.5 12.5 0 0 0-.337-2.5zM4.51 8.5a12.5 12.5 0 0 0 .337 2.5H7.5V8.5zm3.99 0V11h2.653c.187-.765.306-1.608.338-2.5zM5.145 12q.208.58.468 1.068c.552 1.035 1.218 1.65 1.887 1.855V12zm.182 2.472a7 7 0 0 1-.597-.933A9.3 9.3 0 0 1 4.09 12H2.255a7 7 0 0 0 3.072 2.472M3.82 11a13.7 13.7 0 0 1-.312-2.5h-2.49c.062.89.291 1.733.656 2.5zm6.853 3.472A7 7 0 0 0 13.745 12H11.91a9.3 9.3 0 0 1-.64 1.539 7 7 0 0 1-.597.933M8.5 12v2.923c.67-.204 1.335-.82 1.887-1.855q.26-.487.468-1.068zm3.68-1h2.146c.365-.767.594-1.61.656-2.5h-2.49a13.7 13.7 0 0 1-.312 2.5m2.802-3.5a7 7 0 0 0-.656-2.5H12.18c.174.782.282 1.623.312 2.5zM11.27 2.461c.247.464.462.98.64 1.539h1.835a7 7 0 0 0-3.072-2.472c.218.284.418.598.597.933M10.855 4a8 8 0 0 0-.468-1.068C9.835 1.897 9.17 1.282 8.5 1.077V4z"/>
+</svg>