igs-slm 0.1.0b0__py3-none-any.whl

igs_tools/defines/data_center.py

@@ -0,0 +1,75 @@
+from enum_properties import EnumProperties, p, s
+from pathlib import Path
+from .rinex import DataRate
+from igs_tools.utils import day_of_year
+
+
+class DataCenter(
+    EnumProperties,
+    p('protocol'), s('domain'), p('port'), s('full_name')
+):
+
+    IGN   = 'IGN',   'ftp',   'igs.ign.fr',             21,  "Institut National de l'Information Géographique et Forestière"
+    SIO   = 'SIO',   'ftp',   'garner.ucsd.edu',        21,  'Scripps Institution of Oceanography'
+    KASI  = 'KASI',  'ftp',   'nfs.kasi.re.kr',         21,  'Korea Astronomy and Space Science Institute'
+    CDDIS = 'CDDIS', 'https', 'https://cddis.nasa.gov', 443, 'NASA Center for Data and Information Services'
+
+    @property
+    def label(self):
+        return self.name
+
+    def __str__(self):
+        return str(self.label)
+
+    def directory(self, rinex_version, data_rate, date, hours=None):
+        """
+        todo this interface should be changed to return a list of paths and
+        honor the hours parameter
+        :param rinex_version:
+        :param data_rate:
+        :param date:
+        :param hours:
+        :return:
+        """
+        if self == self.IGN:
+            path = Path('/pub/igs/data')
+            if data_rate == DataRate.HOURLY:
+                path /= 'hourly'
+            elif data_rate == DataRate.HIGH_RATE:
+                path /= 'highrate'
+            path /= str(date.year)
+            path /= f'{day_of_year(date):03d}'
+            return str(path)
+        if self == self.SIO:
+            path = Path('/pub/rinex')
+            if data_rate == DataRate.HOURLY:
+                return None
+            elif data_rate == DataRate.HIGH_RATE:
+                path /= 'rinex_highrate'
+            path /= str(date.year)
+            path /= f'{day_of_year(date):03d}'
+            return str(path)
+        if self == self.KASI:
+            path = Path('/gps/data')  # todo add constellation to list
+            if data_rate == DataRate.HOURLY or data_rate == DataRate.HIGH_RATE:
+                return None
+            elif data_rate == DataRate.DAILY:
+                path /= 'daily'
+            path /= str(date.year)
+            path /= f'{day_of_year(date):03d}'
+            path /= f'{str(date.year)[2:]}d'
+            return str(path)
+        if self == self.CDDIS:
+            path = Path('/archive/gnss/data')
+            if data_rate in [DataRate.HOURLY, DataRate.HIGH_RATE]:
+                path /= 'hourly'
+            elif data_rate == DataRate.DAILY:
+                path /= 'daily'
+            path /= str(date.year)
+            path /= f'{day_of_year(date):03d}'
+            if data_rate in [DataRate.DAILY, DataRate.HIGH_RATE]:
+                path /= f'{str(date.year)[2:]}d'
+            if data_rate in [DataRate.HOURLY, DataRate.HIGH_RATE]:
+                path /= '01'
+            return path
+        raise NotImplementedError(f'{self} must implement directory()')

igs_tools/defines/rinex.py

@@ -0,0 +1,49 @@
+from datetime import date
+from enum_properties import IntEnumProperties, IntFlagProperties, p, s
+
+
+class RinexVersion(
+    IntEnumProperties,
+    s('label'), s('major'), s('slug'), p('published')
+):
+
+    # Minor version not known
+
+    #      Name    Label     Major Text           Published
+    v2    = 2,   'RINEX 2',    2,  '2', date(year=1993, month=4, day=1)
+    v3    = 3,   'RINEX 3',    3,  '3', date(year=2007, month=11, day=28)
+    v4    = 4,   'RINEX 4',    4,  '4', date(year=2021, month=12, day=1)
+    ###############################################################
+
+    v2_11 = 211, 'RINEX 2.11', 2, '2.11', date(year=2012, month=6, day=26)
+    v3_00 = 300, 'RINEX 3.00', 3, '3.00', date(year=2007, month=11, day=28)
+    v3_01 = 301, 'RINEX 3.01', 3, '3.01', date(year=2009, month=6, day=22)
+    v3_02 = 302, 'RINEX 3.02', 3, '3.02', date(year=2013, month=4, day=13)
+    v3_03 = 303, 'RINEX 3.03', 3, '3.03', date(year=2017, month=1, day=25)
+    v3_04 = 304, 'RINEX 3.04', 3, '3.04', date(year=2018, month=11, day=23)
+    v3_05 = 305, 'RINEX 3.05', 3, '3.05', date(year=2020, month=12, day=1)
+    v4_00 = 400, 'RINEX 4.00', 4, '4.00', date(year=2021, month=12, day=1)
+
+    def major_q(self, field_name='rinex_version'):
+        from django.db.models import Q
+        return Q(**{
+            f'{field_name}__in': [
+                rv.value for rv in RinexVersion if rv.major == self.major
+            ]})
+
+    @classmethod
+    def major_versions(cls):
+        return [cls.v2, cls.v3, cls.v4]
+
+    def __str__(self):
+        return str(self.label)
+
+
+class DataRate(IntFlagProperties, s('label'), s('slug', case_fold=True)):
+
+    DAILY     =  2**1, 'Daily',     'daily'
+    HOURLY    =  2**2, 'Hourly',    'hourly'
+    HIGH_RATE =  2**3, 'High Rate', 'high'
+
+    def __str__(self):
+        return str(self.label)

igs_tools/directory.py

@@ -0,0 +1,247 @@
+import argparse
+from dateutil import parser as date_parser
+from datetime import datetime, timedelta, date
+from igs_tools.defines import RinexVersion, DataCenter, DataRate
+from igs_tools.utils import classproperty
+from typing import Optional, Generator, Union
+from pathlib import Path
+from igs_tools.connection import Connection
+from igs_tools.utils import get_file_properties
+
+
+class Listing:
+
+    station: str
+    protocol: str
+    domain: str
+    port: int
+    filename: str
+    directory: str
+    rinex_version: RinexVersion
+    data_rate: DataRate
+    date: Union[date, datetime]
+    data_center: DataCenter
+    size: Optional[int]
+    file_type: str
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @property
+    def path(self):
+        return Path(self.directory) / self.filename
+
+
+class DirectoryListing:
+
+    data_centers = [center for center in DataCenter]
+    rinex_versions = [RinexVersion.v3]
+    data_rates = [DataRate.DAILY]
+
+    username = ''
+    password = ''
+
+    @classproperty
+    def start(self):
+        return datetime.now().date()
+
+    @classproperty
+    def end(self):
+        return datetime.now().date()
+
+    def __init__(
+        self,
+        stations=None,
+        data_centers=None,
+        rinex_versions=None,
+        data_rates=None,
+        start=None,
+        end=None,
+        dates=None,
+        username=username,
+        password=password
+    ):
+        self.stations = set([stn.lower()[0:4] for stn in stations or []])
+        self.data_centers = set(data_centers or self.data_centers)
+        self.rinex_versions = set(rinex_versions or self.rinex_versions)
+        self.data_rates = set(data_rates or self.data_rates)
+
+        if dates and (start or end):
+            raise ValueError('Cannot specify dates and start/end.')
+
+        self.start = start or self.start
+        self.end = end or self.end
+        if self.start < self.end:
+            # allow any order
+            self.start, self.end = self.end, self.start
+        self.dates = dates or [
+            self.end + timedelta(days=i)
+            for i in range((self.start - self.end).days + 1)
+        ]
+        self.username = username
+        self.password = password
+
+    def __iter__(self) -> Generator[Listing, None, None]:
+        visited = set()
+        for data_center in self.data_centers:
+            connection = Connection(data_center, self.username, self.password)
+            print(data_center)
+            for rinex_version in self.rinex_versions:
+                print(rinex_version)
+                for data_rate in self.data_rates:
+                    print(data_rate)
+                    for date in self.dates:
+                        print(date)
+                        path = data_center.directory(
+                            rinex_version,
+                            data_rate,
+                            date
+                        )
+                        print(path)
+                        if not path or path in visited:
+                            continue
+                        visited.add(path)
+                        for filename in connection.list(path):
+                            properties = get_file_properties(filename)
+                            if (
+                                properties is None or
+                                properties['rinex_version']
+                                    not in self.rinex_versions or (
+                                    self.stations and
+                                    properties['station'].lower()[0:4]
+                                        not in self.stations
+                                )
+                            ):
+                                continue
+                            yield Listing(
+                                station=properties['station'],
+                                protocol=data_center.protocol,
+                                domain=data_center.domain,
+                                port=data_center.port,
+                                filename=filename,
+                                directory=path,
+                                rinex_version=properties['rinex_version'],
+                                data_rate=data_rate,
+                                date=date,
+                                file_type=properties['file_type'],
+                                size=properties.get('size', None),
+                                data_center=data_center
+                            )
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(
+        description='Fetch directory information about IGS RINEX files.'
+    )
+    parser.add_argument(
+        'stations',
+        metavar='S',
+        type=str,
+        nargs='*',
+        default=[],
+        help='The stations to fetch directory listings for. Default: all'
+    )
+
+    group = parser.add_mutually_exclusive_group()
+
+    group.add_argument(
+        '--date',
+        dest='dates',
+        action='append',
+        default=[],
+        type=lambda s: date_parser.parse(s).date(),
+        help='The date(s) to fetch directory listings for.'
+    )
+
+    group.add_argument(
+        '-s',
+        '--start',
+        dest='start',
+        type=lambda s: date_parser.parse(s).date(),
+        default=None,
+        help=f'The start date (inclusive) to fetch directory listings for. '
+             f'Default: {DirectoryListing.start}'
+    )
+
+    parser.add_argument(
+        '-e',
+        '--end',
+        dest='end',
+        type=lambda s: date_parser.parse(s).date(),
+        default=None,
+        help='The end date (inclusive) to fetch directory listings for. '
+             'Default: {DirectoryListing.start}'
+    )
+
+    parser.add_argument(
+        '-d',
+        '--data-center',
+        dest='data_centers',
+        action='append',
+        default=[],
+        type=DataCenter,
+        choices=[center.label for center in DataCenter],
+        help=f'The list of data centers to fetch directory listings from.'
+             f'Default: {[center.label for center in DataCenter]}'
+    )
+
+    parser.add_argument(
+        '-v',
+        '--version',
+        dest='rinex_versions',
+        action='append',
+        default=[],
+        type=RinexVersion,
+        choices=[rinex.slug for rinex in RinexVersion.major_versions()],
+        help=f'The rinex version of the files to list. '
+             f'Default: {DirectoryListing.rinex_versions}'
+    )
+
+    parser.add_argument(
+        '-r',
+        '--rate',
+        dest='data_rates',
+        action='append',
+        default=[],
+        type=DataRate,
+        choices=[rate.slug for rate in DataRate],
+        help=f'The data rates of the files to list. '
+             f'Default: {DirectoryListing.data_rates}'
+    )
+
+    parser.add_argument(
+        '--username',
+        dest='username',
+        type=str,
+        help='The username to use for authentication if necessary.',
+        default=''
+    )
+
+    parser.add_argument(
+        '--password',
+        dest='password',
+        type=str,
+        help='The password to use for authentication if necessary.',
+        default=''
+    )
+
+    args = parser.parse_args()
+
+    for listing in DirectoryListing(
+        stations=args.stations,
+        data_centers=args.data_centers,
+        rinex_versions=args.rinex_versions,
+        data_rates=args.data_rates,
+        start=args.start,
+        end=args.end or args.start,
+        dates=args.dates,
+        username=args.username,
+        password=args.password
+    ):
+        print(
+            f'{listing.station.upper()} {listing.rinex_version} '
+            f'{listing.data_rate} {listing.date} {listing.filename} '
+            f'{str(listing.data_center)} {listing.size}'
+        )

igs_tools/utils.py

@@ -0,0 +1,66 @@
+from datetime import date, datetime
+from typing import Union
+import re
+
+
+class classproperty:
+    """
+    Equivalent to @property but for classes not instances.
+    """
+
+    def __init__(self, method=None):
+        self.fget = method
+
+    def __get__(self, instance, cls=None):
+        return self.fget(cls)
+
+    def getter(self, method):
+        self.fget = method
+        return self
+
+
+def gps_week(date: Union[date, datetime]) -> int:
+    pass
+
+
+def day_of_year(date: Union[date, datetime]) -> int:
+    return int(date.strftime('%j'))
+
+
+def get_file_properties(filename):
+    """
+    Infer properties of a rinex file from its name.
+    :param filename:
+    :return:
+    """
+    from igs_tools.defines import RinexVersion
+    regexes = [
+        (
+            re.compile(
+                r'^(?P<station>[a-z0-9]{4})'
+                r'(?P<gps_day>\d{3})'
+                r'(?P<hour>[0a-z]{1})'
+                r'[.](?P<year>\d{2})(?P<file_type>[a-z]{1})'
+                r'[.](?P<compression>\w*)$'
+            ),
+            {'rinex_version': RinexVersion.v2}
+        ),
+        (
+            re.compile(
+                r'^(?P<station>[A-Z0-9]{9})_(\w{1})_(?P<year>\d{4})'
+                r'(?P<gps_day>\d{3})(\d{4})_(\w{3})_((\w{3})_)?'
+                r'(?P<constellation>\w{1})(?P<file_type>\w{1})[.]'
+                r'(?P<rinex_Format>(crx)|(rnx))[.](?P<compression>\w*)$'
+            ),
+            {'rinex_version': RinexVersion.v3}
+        )
+    ]
+
+    for regex in regexes:
+        match = re.match(regex[0], filename)
+        if match:
+            return {
+                **match.groupdict(),
+                **regex[1]
+            }
+    return None

slm/__init__.py

@@ -0,0 +1,21 @@
+r"""
+ .----------------.  .----------------.  .----------------.
+| .--------------. || .--------------. || .--------------. |
+| |    _______   | || |   _____      | || | ____    ____ | |
+| |   /  ___  |  | || |  |_   _|     | || ||_   \  /   _|| |
+| |  |  (__ \_|  | || |    | |       | || |  |   \/   |  | |
+| |   '.___`-.   | || |    | |   _   | || |  | |\  /| |  | |
+| |  |`\____) |  | || |   _| |__/ |  | || | _| |_\/_| |_ | |
+| |  |_______.'  | || |  |________|  | || ||_____||_____|| |
+| |              | || |              | || |              | |
+| '--------------' || '--------------' || '--------------' |
+ '----------------'  '----------------'  '----------------'
+"""
+
+VERSION = (0, 3, 0)
+
+__title__ = "IGS/Site Log Manager"
+__version__ = ".".join(str(i) for i in VERSION)
+__author__ = ["Ashley Santiago", "Brian Kohan", "Rachel Pham"]
+__license__ = "MIT"
+__copyright__ = "Copyright 2022-2024 International GNSS Service"