pygnss 0.3.0__cp313-cp313-musllinux_1_2_i686.whl → 0.5.0__cp313-cp313-musllinux_1_2_i686.whl

pygnss/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.0"
+__version__ = "0.5.0"

pygnss/decorator.py

@@ -1,3 +1,6 @@
+import gzip
+from functools import wraps
+import subprocess
 import warnings
 
 
@@ -12,3 +15,33 @@ def deprecated(alternative):
             return func(*args, **kwargs)
         return new_func
     return decorator
+
+
+def read_contents(func):
+    """
+    Decorator to handle gzip compression based on filename and pass its contents
+    to the function
+    """
+
+    @wraps(func)
+    def wrapper(filename, *args, **kwargs):
+
+        doc = None
+
+        if filename.endswith('.gz'):
+            with gzip.open(filename, 'rt', encoding='utf-8') as fh:
+                doc = fh.read()
+        elif filename.endswith('.Z'):
+            result = subprocess.run(['uncompress', '-c', filename],
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE,
+                                    check=True,
+                                    text=True)
+            doc = result.stdout
+        else:
+            with open(filename, 'rt', encoding='utf-8') as fh:
+                doc = fh.read()
+
+        return func(doc, *args, **kwargs)
+
+    return wrapper

pygnss/ionex.py

@@ -0,0 +1,259 @@
+import datetime
+import math
+from typing import List
+
+import numpy as np
+
+from .iono import gim
+from .decorator import read_contents
+
+
+def load(filename: str,  gim_handler: gim.GimHandler):
+    """
+    Load an IONEX file and process its contents using the provided GIM handler.
+
+    :param filename: The path to the IONEX file to load.
+    :param gim_handler: An instance of a GIM handler to process the GIMs read from the file.
+    :return: The result of processing the IONEX file.
+    """
+
+    return _load(filename, gim_handler)
+
+
+def write(filename: str, gims: List[gim.Gim], gim_type: gim.GimType,
+          pgm: str = "pygnss", runby: str = "pygnss", comment_lines: List[str] = []) -> None:
+    """
+    Write a list of GIMs to an IONEX file.
+
+    :param filename: The path to the IONEX file to write.
+    :param gims: A list of GIM objects to write to the file.
+    """
+
+    EXPONENT = -1
+    FACTOR = math.pow(10, EXPONENT)
+
+    if not gims:
+        raise ValueError("The list of GIMs is empty. Cannot write to the IONEX file.")
+
+    # Extract latitudes and longitudes from the first GIM
+    latitudes = gims[0].latitudes
+    longitudes = gims[0].longitudes
+
+    lon1 = longitudes[0]
+    lon2 = longitudes[-1]
+    dlon = longitudes[1] - longitudes[0]
+
+    # Ensure all GIMs have the same latitudes and longitudes
+    for gim_obj in gims:
+        if np.array_equal(gim_obj.latitudes, latitudes) == False or \
+           np.array_equal(gim_obj.longitudes, longitudes) == False:
+            raise ValueError("All GIMs must have the same latitudes and longitudes.")
+
+    # Sort the IONEX files by epoch
+    gims.sort(key=lambda gim: gim.epoch)
+
+    first_epoch = gims[0].epoch
+    last_epoch = gims[-1].epoch
+    n_maps = len(gims)
+
+    lat_0 = gims[0].latitudes[0]
+    lat_1 = gims[0].latitudes[-1]
+    dlat = gims[0].latitudes[1] - gims[0].latitudes[0]
+
+    # We will print the map from North to South, therefore check if the
+    # latitudes need to be reversed
+    latitude_reversal = lat_0 < lat_1
+    if latitude_reversal:
+        lat_0 = gims[0].latitudes[-1]
+        lat_1 = gims[0].latitudes[0]
+        dlat = gims[0].latitudes[0] - gims[0].latitudes[1]
+
+    lon_0 = gims[0].longitudes[0]
+    lon_1 = gims[0].longitudes[-1]
+    dlon = gims[0].longitudes[1] - gims[0].longitudes[0]
+
+    doc = ""
+
+    # Header
+    today = datetime.datetime.now()
+    epoch_str = today.strftime('%d-%b-%y %H:%M')
+
+    doc +="     1.0            IONOSPHERE MAPS     NEQUICK             IONEX VERSION / TYPE\n"
+    doc +=f"{pgm[:20]:<20}{runby[:20]:<20}{epoch_str[:20]:<20}PGM / RUN BY / DATE\n"
+
+    for comment_line in comment_lines:
+        doc += f"{comment_line[:60]:<60}COMMENT\n"
+
+    doc += first_epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF FIRST MAP\n")
+    doc += last_epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF LAST MAP\n")
+    doc += "     0                                                      INTERVAL\n"
+    doc += f"{n_maps:>6}                                                      # OF MAPS IN FILE\n"
+    doc += "  NONE                                                      MAPPING FUNCTION\n"
+    doc += "     0.0                                                    ELEVATION CUTOFF\n"
+    doc += "                                                            OBSERVABLES USED\n"
+    doc += "  6371.0                                                    BASE RADIUS\n"
+    doc += "     2                                                      MAP DIMENSION\n"
+    doc += "   450.0 450.0   0.0                                        HGT1 / HGT2 / DHGT\n"
+    doc += f"  {lat_0:6.1f}{lat_1:6.1f}{dlat:6.1f}                                        LAT1 / LAT2 / DLAT\n"
+    doc += f"  {lon_0:6.1f}{lon_1:6.1f}{dlon:6.1f}                                        LON1 / LON2 / DLON\n"
+    doc += f"{EXPONENT:>6}                                                      EXPONENT\n"
+    doc += "                                                            END OF HEADER\n"
+
+    # Write each GIM
+    for i_map, gim_obj in enumerate(gims):
+
+        doc += f"{i_map+1:>6}                                                      START OF {gim_type.name} MAP\n"
+
+        # Write the epoch
+        epoch = gim_obj.epoch
+        doc += epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF CURRENT MAP\n")
+
+
+        for i, _ in enumerate(latitudes):
+
+            if latitude_reversal:
+                i = len(latitudes) - 1 - i
+
+            lat = latitudes[i]
+
+            doc += f"  {lat:6.1f}{lon1:6.1f}{lon2:6.1f}{dlon:6.1f} 450.0                            LAT/LON1/LON2/DLON/H\n"
+
+            lat_row = gim_obj.vtec_values[i]
+            for j in range(0, len(longitudes), 16):
+                doc += "".join(f"{round(vtec / FACTOR):5d}" for vtec in lat_row[j:j+16]) + "\n"
+
+        doc += f"{i_map+1:>6}                                                      END OF {gim_type.name} MAP\n"
+
+    # Tail
+    doc += "                                                            END OF FILE\n"
+
+    with open(filename, "wt") as fh:
+        fh.write(doc)
+
+
+
+def diff(filename_lhs: str, filename_rhs: str, output_file: str) -> None:
+    """
+    Compute the difference between two IONEX files and write the result in IONEX format
+    """
+
+    gim_handler_lhs = gim.GimHandlerArray()
+    gim_handler_rhs = gim.GimHandlerArray()
+
+    load(filename_lhs, gim_handler=gim_handler_lhs)
+    load(filename_rhs, gim_handler=gim_handler_rhs)
+
+    gim_diffs = gim.subtract_gims(gim_handler_lhs.vtec_gims, gim_handler_rhs.vtec_gims)
+
+    write(output_file, gim_diffs, gim.GimType.TEC)
+
+
+@read_contents
+def _load(doc: str, gim_handler: gim.GimHandler):
+    """
+    Parse the contents of an IONEX file and process each GIM using the provided handler.
+
+    :param doc: The contents of the IONEX file as a string.
+    :param gim_handler: An instance of a GIM handler to process the GIMs read from the file.
+    :raises ValueError: If the file is not a valid IONEX file or contains unsupported features.
+    """
+
+    lines = doc.splitlines()
+    n_lines = len(lines)
+    i_body = 0
+
+    latitudes_deg: List[float] = []
+    longitudes_deg: List[float] = []
+
+    header_mark_found = False
+
+    # Header
+    for i in range(n_lines):
+
+        line = lines[i]
+
+        if line[60:].startswith('IONEX VERSION / TYPE'):
+            header_mark_found = True
+
+        elif line[60:].startswith('HGT1 / HGT2 / DHGT'):
+            _hgt1, _hgt2, _dhgt = [float(v) for v in line.split()[:3]]
+            if _dhgt != 0.0:
+                raise ValueError('Multi-layer Ionex files not supported')
+
+        elif line[60:].startswith('LAT1 / LAT2 / DLAT'):
+            _lat1, _lat2, _dlat = [float(v) for v in line.split()[:3]]
+            latitudes_deg = np.arange(_lat1, _lat2 + _dlat/2, _dlat)
+
+        elif line[60:].startswith('LON1 / LON2 / DLON'):
+            _lon1, _lon2, _dlon = [float(v) for v in line.split()[:3]]
+            longitudes_deg = np.arange(_lon1, _lon2 + _dlon/2, _dlon)
+
+        elif line[60:].startswith('EXPONENT'):
+            exponent: float = float(line[:6])
+
+        elif line[60:].startswith('END OF HEADER'):
+            i_body = i + 1
+            break
+
+    if header_mark_found is False:
+        raise ValueError(f'The input does not seem to be a IONEX file [ {doc[:10]} ]')
+
+    n_lines_lat_row = int(np.ceil(len(longitudes_deg) / 16))
+
+    current_gim = None
+    gim_type = None
+
+    # Body
+    for i in range(i_body, n_lines):
+
+        line = lines[i]
+
+        if line[60:].startswith('START OF TEC MAP'):
+
+            i_lat_row = 0
+
+            gim_type = gim.GimType.TEC
+
+        elif line[60:].startswith('START OF RMS MAP'):
+
+            i_lat_row = 0
+
+            gim_type = gim.GimType.RMS
+
+        elif line[60:].startswith('EPOCH OF CURRENT MAP'):
+
+            # Initialize map
+            current_gim = gim.Gim(_parse_ionex_epoch(line),
+                                  longitudes_deg, latitudes_deg,
+                                  [[0] * len(longitudes_deg)] * len(latitudes_deg))
+
+        elif line[60:].startswith('LAT/LON1/LON2/DLON/H'):
+
+            lat_row = ''.join([lines[i + 1 + j] for j in range(n_lines_lat_row)])
+
+            values = np.array([float(v) for v in lat_row.split()])
+
+            i += n_lines_lat_row
+
+            current_gim.vtec_values[i_lat_row] = (values * np.power(10, exponent)).tolist()
+
+            i_lat_row = i_lat_row + 1
+
+        # If end of map reached, send them to appropriate processor
+        elif line[60:].startswith('END OF TEC MAP') or line[60:].startswith('END OF RMS MAP'):
+            gim_handler.process(current_gim, gim_type)
+
+
+def _parse_ionex_epoch(ionex_line: str) -> datetime.datetime:
+    """
+    Parse the epoch from a IONEX line
+
+    >>> _parse_ionex_epoch("  2024    12    11     0     0    14                        EPOCH OF FIRST MAP")
+    datetime.datetime(2024, 12, 11, 0, 0, 14)
+    >>> _parse_ionex_epoch("  2024    12    11     0     0     0                        EPOCH OF CURRENT MAP")
+    datetime.datetime(2024, 12, 11, 0, 0)
+    """
+
+    _HEADER_EPOCH_FORMAT = "  %Y    %m    %d    %H    %M    %S"
+
+    return datetime.datetime.strptime(ionex_line[:36], _HEADER_EPOCH_FORMAT)

pygnss/iono/gim.py

@@ -0,0 +1,131 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+import datetime
+import enum
+from typing import List
+
+import numpy as np
+
+
+class GimType(enum.Enum):
+    """
+    Type of Global Ionospheric Map (VTEC, RMS)
+    """
+
+    TEC = enum.auto()
+    RMS = enum.auto()
+
+
+@dataclass
+class Gim():
+    epoch: datetime.datetime
+    longitudes: List[float]
+    latitudes: List[float]
+    vtec_values: List[List[float]]  # Grid of VTEC values n_latitudes (rows) x n_longitudes (columns)
+
+    def __sub__(self, other: 'Gim') -> 'Gim':
+        """
+        Subtract the VTEC values of another Gim from this Gim
+
+        :param other: The Gim to subtract.
+
+        :return: A new Gim with the resulting VTEC values.
+        """
+
+        return subtract(self, other)
+
+
+class GimHandler(ABC):
+
+    @abstractmethod
+    def process(self, gim: Gim, type: GimType):
+        """
+        Process a GIM file
+        """
+        pass
+
+class GimHandlerArray(GimHandler):
+    """
+    Handler to store the incoming GIMs in arrays
+    """
+
+    def __init__(self):
+        self.vtec_gims = []
+        self.rms_gims = []
+
+    def process(self, gim: Gim, type: GimType):
+        """
+        Process a GIM file
+        """
+
+        if type == GimType.TEC:
+            self.vtec_gims.append(gim)
+
+        elif type == GimType.RMS:
+            self.rms_gims.append(gim)
+
+        else:
+            raise ValueError(f'Gim Type [ {type} ] not supported')
+
+
+def subtract(lhs: Gim, rhs: Gim) -> Gim:
+    """
+    Subtract the VTEC values of two GIMs (lhs - rhs)
+
+    :param lhs: Left-hand operand
+    :param rhs: Right-hand operand
+
+    :return: A new Gim with the resulting difference of VTEC values.
+
+    :raises ValueError: If the dimensions of the GIMs do not match.
+    """
+
+    if lhs.epoch != rhs.epoch:
+        raise ValueError(f"Epochs of both GIMs differ: {lhs.epoch} != {rhs.epoch}")
+
+    if np.array_equal(lhs.latitudes, rhs.latitudes) == False:
+        raise ValueError("Latitudes do not match between the two GIMs.")
+
+    if np.array_equal(lhs.longitudes, rhs.longitudes) == False:
+        raise ValueError("Longitude do not match between the two GIMs.")
+
+    vtec_diff = np.subtract(lhs.vtec_values, rhs.vtec_values)
+
+    return Gim(
+        epoch=lhs.epoch,  # Keep the epoch of the first Gim
+        longitudes=lhs.longitudes,
+        latitudes=lhs.latitudes,
+        vtec_values=vtec_diff.tolist(),
+    )
+
+
+def subtract_gims(lhs: List[Gim], rhs: List[Gim]) -> List[Gim]:
+    """
+    Subtract the VTEC values of two lists of GIMs (lhs - rhs).
+
+    The subtraction is performed only for GIMs with matching epochs, latitudes, and longitudes.
+    If a GIM in one list does not have a matching epoch in the other list, it is ignored.
+
+    :param lhs: The first list of GIMs (left-hand operand).
+    :param rhs: The second list of GIMs (right-hand operand).
+    :return: A list of GIMs resulting from the subtraction.
+    :raises ValueError: If latitudes or longitudes do not match for matching epochs.
+    """
+    result = []
+
+    # Create a dictionary for quick lookup of GIMs in the rhs list by epoch
+    rhs_dict = {gim.epoch: gim for gim in rhs}
+
+    for gim_lhs in lhs:
+
+        # Check if there is a matching epoch in the rhs list
+        if gim_lhs.epoch in rhs_dict:
+            gim_rhs = rhs_dict[gim_lhs.epoch]
+
+            try:
+                result.append(gim_lhs - gim_rhs)
+            except ValueError as e:
+                raise ValueError(f"Error subtracting GIMs for epoch {gim_lhs.epoch}: {e}")
+
+    return result
+

pygnss/nequick.py

@@ -6,6 +6,9 @@ import numpy as np
 
 import nequick
 
+from pygnss import ionex
+import pygnss.iono.gim
+
 
 class GimIonexHandler(nequick.GimHandler):
     """
@@ -32,102 +35,23 @@ class GimIonexHandler(nequick.GimHandler):
 
         self._gims.append(gim)
 
-    def to_ionex(self, pgm: str = "pygnss", runby: str = "pygnss") -> str:
-
-        EXPONENT = -1
-
-        # Sort the IONEX files by epoch
-        self._gims.sort(key=lambda gim: gim.epoch)
-
-        first_epoch = self._gims[0].epoch
-        last_epoch = self._gims[-1].epoch
-        n_maps = len(self._gims)
-
-        lat_0 = self._gims[0].latitudes[0]
-        lat_1 = self._gims[0].latitudes[-1]
-        dlat = self._gims[0].latitudes[1] - self._gims[0].latitudes[0]
-
-        # We will print the map from North to South, therefore check if the
-        # latitudes need to be reversed
-        latitude_reversal = lat_0 < lat_1
-        if latitude_reversal:
-            lat_0 = self._gims[0].latitudes[-1]
-            lat_1 = self._gims[0].latitudes[0]
-            dlat = self._gims[0].latitudes[0] - self._gims[0].latitudes[1]
-
-        lon_0 = self._gims[0].longitudes[0]
-        lon_1 = self._gims[0].longitudes[-1]
-        dlon = self._gims[0].longitudes[1] - self._gims[0].longitudes[0]
-
-        doc = ""
-
-        # Header
-        today = datetime.datetime.now()
-        epoch_str = today.strftime('%d-%b-%y %H:%M')
-
-        doc +="     1.0            IONOSPHERE MAPS     NEQUICK             IONEX VERSION / TYPE\n"
-        doc +=f"{pgm[:20]:<20}{runby[:20]:<20}{epoch_str[:20]:<20}PGM / RUN BY / DATE\n"
-        doc +="Maps computed using the NeQuick model with the following    COMMENT\n"
-        doc +="coefficients:                                               COMMENT\n"
-        doc += f"{EXPONENT:>6}                                                      EXPONENT\n"
-        doc +=f"a0={self._coeffs.a0:<17.6f}a1={self._coeffs.a1:<17.8f}a2={self._coeffs.a2:<17.11f}COMMENT\n"
-        doc += first_epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF FIRST MAP\n")
-        doc += last_epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF LAST MAP\n")
-        doc += "     0                                                      INTERVAL\n"
-        doc += f"{n_maps:>6}                                                      # OF MAPS IN FILE\n"
-        doc += "  NONE                                                      MAPPING FUNCTION\n"
-        doc += "     0.0                                                    ELEVATION CUTOFF\n"
-        doc += "                                                            OBSERVABLES USED\n"
-        doc += "  6371.0                                                    BASE RADIUS\n"
-        doc += "     2                                                      MAP DIMENSION\n"
-        doc += "   450.0 450.0   0.0                                        HGT1 / HGT2 / DHGT\n"
-        doc += f"  {lat_0:6.1f}{lat_1:6.1f}{dlat:6.1f}                                        LAT1 / LAT2 / DLAT\n"
-        doc += f"  {lon_0:6.1f}{lon_1:6.1f}{dlon:6.1f}                                        LON1 / LON2 / DLON\n"
-        doc += "                                                            END OF HEADER\n"
-
-        # Body: For each GIM file, write the VTEC values
-        for i, gim in enumerate(self._gims):
+    def to_ionex(self, filename: str, pgm: str = "pygnss", runby: str = "pygnss") -> None:
 
-            doc += f"{i+1:>6}                                                      START OF TEC MAP\n"
-            doc += gim.epoch.strftime("  %Y    %m    %d    %H    %M    %S                        EPOCH OF CURRENT MAP\n")
+        comment_lines = [
+            "Maps computed using the NeQuick model with the following",
+            "coefficients:",
+            f"a0={self._coeffs.a0:<17.6f}a1={self._coeffs.a1:<17.8f}a2={self._coeffs.a2:<17.11f}"
+        ]
 
-            n_latitudes = len(gim.latitudes)
+        ionex.write(filename, self._gims, pygnss.iono.gim.GimType.TEC, pgm, runby,
+                    comment_lines=comment_lines)
 
-            for i_lat, lat in enumerate(gim.latitudes):
 
-                if latitude_reversal:
-                    i_lat = n_latitudes - 1 - i_lat
-
-                lat = gim.latitudes[i_lat]
-                doc += f"  {lat:6.1f}{lon_0:6.1f}{lon_1:6.1f}{dlon:6.1f} 450.0                            LAT/LON1/LON2/DLON/H"
-
-                lat_row = gim.vtec_values[i_lat]
-                for i_lon, _ in enumerate(gim.longitudes):
-
-                    if i_lon % 16 == 0:
-                        doc += "\n"
-
-                    vtec = lat_row[i_lon] / math.pow(10, EXPONENT)
-                    doc += f"{int(vtec):>5d}"
-
-                doc += "\n"
-
-            doc += f"{i+1:>6}                                                      END OF TEC MAP\n"
-
-        # Tail
-        doc += "                                                            END OF FILE\n"
-
-        return doc
-
-def to_ionex(coeffs: nequick.Coefficients, dates: List[datetime.datetime]) -> str:
-
-    doc = None
+def to_ionex(filename: str, coeffs: nequick.Coefficients, dates: List[datetime.datetime]):
 
     gim_handler = GimIonexHandler(coeffs)
 
     for date in dates:
         nequick.to_gim(coeffs, date, gim_handler=gim_handler)
 
-    doc = gim_handler.to_ionex()
-
-    return doc
+    gim_handler.to_ionex(filename)

{pygnss-0.3.0.dist-info → pygnss-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygnss
-Version: 0.3.0
+Version: 0.5.0
 Summary: Package with utilities and tools for GNSS data processing
 Author-email: Miquel Garcia-Fernandez <miquel@mgfernan.com>
 License: MIT

{pygnss-0.3.0.dist-info → pygnss-0.5.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
-pygnss/__init__.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+pygnss/__init__.py,sha256=LBK46heutvn3KmsCrKIYu8RQikbfnjZaj2xFrXaeCzQ,22
 pygnss/_c_ext.cpython-313-i386-linux-musl.so,sha256=9CwtpxkeyS2ajcDuwlLpG1R9QsgwtBkl6wMFDeK4LNw,81152
 pygnss/cl.py,sha256=ISmd2RjikUMmj3nLPN0VSjvQLG5rLizp2X2ajeBkoDE,4509
 pygnss/constants.py,sha256=1hF6K92X6E6Ofo0rAuCBCgrwln9jxio26RV2a6vyURk,133
-pygnss/decorator.py,sha256=ldlZuvwuIlJf2pkoWteyXyp5tLds8KRkphrPsrURw9U,491
+pygnss/decorator.py,sha256=qB-0jl2GTEHJdvmDruNll5X3RrdySssv94u9Hok5-lA,1438
 pygnss/file.py,sha256=kkMBWjoTPkxJD1UgH0mXJT2fxnhU8u7_l2Ph5Xz2-hY,933
 pygnss/geodetic.py,sha256=3q8Rpl4b5CxGlhdn1nQRBHHSW1v-0PBFz54zOeVyO74,33633
 pygnss/hatanaka.py,sha256=P9XG6bZwUzfAPYn--6-DXfFQIEefeimE7fMJm_DF5zE,1951
+pygnss/ionex.py,sha256=n_5IADZcTg1nCKApT19fvnAh5823QgbRkX8oPYDdpSI,9244
 pygnss/logger.py,sha256=4kvcTWXPoiG-MlyP6B330l4Fu7MfCuDjuIlIiLA8f1Y,1479
-pygnss/nequick.py,sha256=ewtccKH1tdh8z6iuM6yEvDCakOKbzgkMnEWh3jWg6R4,5490
+pygnss/nequick.py,sha256=tSsUw3FoRWS-TBKKVb0_c90DFz_2jUTkUvNPsGQOLA8,1722
 pygnss/rinex.py,sha256=LsOOh3Fc263kkM8KOUBNeMeIAmbOn2ASSBO4rAUJWj8,68783
 pygnss/sinex.py,sha256=nErOmGCFFmGSnmWGNTJhaj3yZ6IIB8GgtW5WPypJc6U,3057
 pygnss/stats.py,sha256=GYZfcyDvbM9xamWIyVlqyN5-DPJzTLJrybRrcNV6Z6o,1912
@@ -25,13 +26,15 @@ pygnss/gnss/edit.py,sha256=T1r0WbJmt8tLJpG_IIsy4Atej6cy0IStBaSGxw0S5ho,1884
 pygnss/gnss/observables.py,sha256=0x0NLkTjxf8cO9F_f_Q1b-1hEeoNjWB2x-53ecUEv0M,1656
 pygnss/gnss/residuals.py,sha256=8qKGNOYkrqxHGOSjIfH21K82PAqEh2068kf78j5usL8,1244
 pygnss/gnss/types.py,sha256=lmL15KRckRiTwVkYvGzF4c1BrojnQlegrYCXSz1hGaI,10377
+pygnss/iono/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygnss/iono/gim.py,sha256=bJ-1jRIrkZj790fuCk3np72NrPaG_Qvx-EVZsvWMfsk,3521
 pygnss/orbit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygnss/orbit/kepler.py,sha256=QORTgg5yBtsQXxLWSzoZ1pmh-CwPiZlFdIYqhQhv1a0,1745
 pygnss/orbit/tle.py,sha256=6CIEielPgui3DXNv46XxOGlig31ROIwjH42xLGaeE5M,5905
 pygnss/parsers/rtklib/stats.py,sha256=YV6yadxMeQMQYZvsUCaSf4ZTpK8Bbv3f2xgu0l4PekA,5449
-pygnss-0.3.0.dist-info/METADATA,sha256=kDz5U4Y1CzGww42HgE5Fkj05KGNXZOs1SkYhuiHmPL8,1659
-pygnss-0.3.0.dist-info/WHEEL,sha256=qeaIuaJB-6C86fEu4NQSDId-fDkNNB1_xWNvSM-4W7I,110
-pygnss-0.3.0.dist-info/entry_points.txt,sha256=mCuKrljB_wh9ZQVROiId9m68EDbTiY1oef_L1N3IDDA,262
-pygnss-0.3.0.dist-info/top_level.txt,sha256=oZRSR-qOv98VW2PRRMGCVNCJmewcJjyJYmxzxfeimtg,7
-pygnss-0.3.0.dist-info/RECORD,,
-pygnss-0.3.0.dist-info/licenses/LICENSE,sha256=Wwany6RAAZ9vVHjFLA9KBJ0HE77d52s2NOUA1CPAEug,1067
+pygnss-0.5.0.dist-info/METADATA,sha256=9HBJeG5a0H-MIxtMwwkPP3DqulH3GIoX_8l5O0E77pk,1659
+pygnss-0.5.0.dist-info/WHEEL,sha256=qeaIuaJB-6C86fEu4NQSDId-fDkNNB1_xWNvSM-4W7I,110
+pygnss-0.5.0.dist-info/entry_points.txt,sha256=mCuKrljB_wh9ZQVROiId9m68EDbTiY1oef_L1N3IDDA,262
+pygnss-0.5.0.dist-info/top_level.txt,sha256=oZRSR-qOv98VW2PRRMGCVNCJmewcJjyJYmxzxfeimtg,7
+pygnss-0.5.0.dist-info/RECORD,,
+pygnss-0.5.0.dist-info/licenses/LICENSE,sha256=Wwany6RAAZ9vVHjFLA9KBJ0HE77d52s2NOUA1CPAEug,1067