igs-slm 0.1.4b0__py3-none-any.whl → 0.1.5b1__py3-none-any.whl

slm/management/commands/generate_sinex.py

@@ -22,7 +22,7 @@ from typing_extensions import Annotated
 
 from slm.defines import ISOCountry
 from slm.models import Network, Site, SiteAntenna, SiteReceiver
-from slm.utils import dddmmss_ss_parts, xyz2llh
+from slm.utils import dddmmss_ss_parts, transliterate, xyz2llh
 
 DEFAULT_ANTEX = "https://files.igs.org/pub/station/general/igs20.atx.gz"
 
@@ -35,7 +35,7 @@ def sinex_time(time):
     if time is None:
         return "00:000:00000"
     return (
-        f'{time.strftime("%y:%j")}:'
+        f"{time.strftime('%y:%j')}:"
         f"{time.hour * 60 * 60 + time.minute * 60 + time.second:05.0f}"
     )
 
@@ -78,6 +78,7 @@ class Command(TyperCommand):
     siteAnt: dict
     atx: dict
     sat_phase_center: dict
+    utf8: bool = False
 
     suppressed_base_arguments = {
         *TyperCommand.suppressed_base_arguments,
@@ -117,11 +118,18 @@ class Command(TyperCommand):
             bool,
             Option("--include-former", help=_("Include former sites in the list.")),
         ] = False,
+        utf8: Annotated[
+            bool,
+            Option(
+                "--utf8", help=_("Allow multi-byte UTF-8 characters in the output.")
+            ),
+        ] = False,
     ):
         self.sinex_code = ""
         self.siteAnt = rec_dd()
         self.atx = rec_dd()
         self.sat_phase_center = rec_dd()
+        self.utf8 = utf8
 
         sites = Site.objects.all().order_by("name")
         sites = sites.public() if include_former else sites.active()
@@ -144,52 +152,65 @@ class Command(TyperCommand):
 
         output = self.stdout
         if destination:
-            output = open(destination, "w")
+            output = open(
+                destination, "wt", encoding="ascii" if not self.utf8 else "utf8"
+            )
 
         # write header
-        for line in self.header(antex_file):
+        for line in self.transliterate(self.header(antex_file)):
             output.write(f"{line}\n")
 
         # write SITE/ID section
-        for line in self.site_ids(sites):
+        for line in self.transliterate(self.site_ids(sites)):
             output.write(f"{line}\n")
 
         # write SITE/RECEIVER section
-        for line in self.site_receivers(sites):
+        for line in self.transliterate(self.site_receivers(sites)):
             output.write(f"{line}\n")
 
         # write SITE/ANTENNA section
-        for line in self.site_antennas(sites):
+        for line in self.transliterate(self.site_antennas(sites)):
             output.write(f"{line}\n")
 
         # write GPS/PHASECENTER section
-        for line in self.gps_phase_center():
+        for line in self.transliterate(self.gps_phase_center()):
             output.write(f"{line}\n")
 
         # write GAL/PHASECENTER section
-        for line in self.gal_phase_center():
+        for line in self.transliterate(self.gal_phase_center()):
             output.write(f"{line}\n")
 
         # write SITE/ECCENTRICITY
-        for line in self.site_eccentricity(sites):
+        for line in self.transliterate(self.site_eccentricity(sites)):
             output.write(f"{line}\n")
 
         # write SATELLITE/ID
-        for line in self.satellite_ids():
+        for line in self.transliterate(self.satellite_ids()):
             output.write(f"{line}\n")
 
         # write +SATELLITE/PHASE_CENTER
-        for line in self.satellite_phase_centers():
+        for line in self.transliterate(self.satellite_phase_centers()):
             output.write(f"{line}\n")
 
         # close out the file
-        for line in self.footer():
+        for line in self.transliterate(self.footer()):
             output.write(f"{line}\n")
 
         if destination:
             output.close()
 
-    def header(self, antex_file):
+    def transliterate(
+        self, utf8_str: t.Generator[str, None, None]
+    ) -> t.Generator[str, None, None]:
+        """
+        Transliterate utf8 -> ascii if we were told to.
+        """
+        if self.utf8:
+            yield from utf8_str
+        for ustr in utf8_str:
+            yield transliterate(ustr)
+
+    def header(self, antex_file) -> t.Generator[str, None, None]:
         now = datetime.now()
         now_date = "%04d-%02d-%02dT%02d:%02d:%02d" % (
             now.year,
@@ -217,19 +238,18 @@ class Command(TyperCommand):
         yield " This file is generated daily from all current IGS site logs in"
         yield "    https://files.igs.org/pub/station/log/"
         yield (
-            " Phase center offsets are a function of antenna type, using as "
-            "reference"
+            " Phase center offsets are a function of antenna type, using as reference"
         )
-        yield f'    {antex_file.rstrip(".gz")}'
+        yield f"    {antex_file.rstrip('.gz')}"
         yield "-FILE/COMMENT"
         yield "+INPUT/ACKNOWLEDGMENTS"
         yield " IGS International GNSS Service"
         yield "-INPUT/ACKNOWLEDGMENTS"
 
-    def footer(self):
+    def footer(self) -> t.Generator[str, None, None]:
         yield "%ENDSNX"
 
-    def site_ids(self, sites):
+    def site_ids(self, sites) -> t.Generator[str, None, None]:
         sites = sites.with_location_fields().with_identification_fields()
         yield "+SITE/ID"
         yield (
@@ -247,7 +267,7 @@ class Command(TyperCommand):
             llh = xyz2llh(site.xyz.coords)
             location = html.unescape(
                 f"{site.city or site.state}"
-                f'{"," if site.city or site.state else ""}{ctry}'
+                f"{',' if site.city or site.state else ''}{ctry}"
             )[:21]
             lat_deg, lat_min, lat_sec = dddmmss_ss_parts(llh[0])
 
@@ -268,7 +288,7 @@ class Command(TyperCommand):
             )
         yield "-SITE/ID"
 
-    def site_receivers(self, sites):
+    def site_receivers(self, sites) -> t.Generator[str, None, None]:
         yield "+SITE/RECEIVER"
         yield (
             "*CODE PT SOLN T _DATA START_ __DATA_END__ ___RECEIVER_TYPE____ "
@@ -293,11 +313,10 @@ class Command(TyperCommand):
                 )
         yield "-SITE/RECEIVER"
 
-    def site_antennas(self, sites):
+    def site_antennas(self, sites) -> t.Generator[str, None, None]:
         yield "+SITE/ANTENNA"
         yield (
-            "*CODE PT SOLN T _DATA START_ __DATA_END__ ____ANTENNA_TYPE____ "
-            "_S/N_ _DAZ"
+            "*CODE PT SOLN T _DATA START_ __DATA_END__ ____ANTENNA_TYPE____ _S/N_ _DAZ"
         )
         for site in sites.prefetch_related(
             Prefetch(
@@ -321,7 +340,7 @@ class Command(TyperCommand):
                 #  seems wrong
         yield "-SITE/ANTENNA"
 
-    def gps_phase_center(self):
+    def gps_phase_center(self) -> t.Generator[str, None, None]:
         yield "+SITE/GPS_PHASE_CENTER"
         yield (
             "*ANTENNA_NAME____DOME S_NO_ __UP__ NORTH_ _EAST_ __UP__ NORTH_ "
@@ -330,23 +349,23 @@ class Command(TyperCommand):
         for ant in sorted(self.siteAnt):
             if "G02" in self.siteAnt[ant]:
                 yield (
-                    f' {ant:20} ----- {self.siteAnt[ant]["G01"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["G01"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["G01"]["east"]:6.6} '
-                    f'{self.siteAnt[ant]["G02"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["G02"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["G02"]["east"]:6.6} {self.sinex_code:10.10}'
+                    f" {ant:20} ----- {self.siteAnt[ant]['G01']['up']:6.6} "
+                    f"{self.siteAnt[ant]['G01']['north']:6.6} "
+                    f"{self.siteAnt[ant]['G01']['east']:6.6} "
+                    f"{self.siteAnt[ant]['G02']['up']:6.6} "
+                    f"{self.siteAnt[ant]['G02']['north']:6.6} "
+                    f"{self.siteAnt[ant]['G02']['east']:6.6} {self.sinex_code:10.10}"
                 )
             else:
                 yield (
-                    f' {ant:20} ----- {self.siteAnt[ant]["G01"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["G01"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["G01"]["east"]:6.6} ------ ------ ------ '
+                    f" {ant:20} ----- {self.siteAnt[ant]['G01']['up']:6.6} "
+                    f"{self.siteAnt[ant]['G01']['north']:6.6} "
+                    f"{self.siteAnt[ant]['G01']['east']:6.6} ------ ------ ------ "
                     f"{self.sinex_code:10.10}"
                 )
         yield "-SITE/GPS_PHASE_CENTER"
 
-    def gal_phase_center(self):
+    def gal_phase_center(self) -> t.Generator[str, None, None]:
         yield "+SITE/GAL_PHASE_CENTER"
         yield (
             "*ANTENNA_NAME____DOME S_NO_ __UP__ NORTH_ _EAST_ __UP__ NORTH_ "
@@ -355,17 +374,17 @@ class Command(TyperCommand):
         for ant in sorted(self.siteAnt):
             if "E01" in self.siteAnt[ant]:
                 _e01 = (
-                    f'{self.siteAnt[ant]["E01"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["E01"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["E01"]["east"]:6.6}'
+                    f"{self.siteAnt[ant]['E01']['up']:6.6} "
+                    f"{self.siteAnt[ant]['E01']['north']:6.6} "
+                    f"{self.siteAnt[ant]['E01']['east']:6.6}"
                 )
             else:
                 _e01 = "------ ------ ------"
             if "E05" in self.siteAnt[ant]:
                 _e05 = (
-                    f'{self.siteAnt[ant]["E05"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["E05"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["E05"]["east"]:6.6}'
+                    f"{self.siteAnt[ant]['E05']['up']:6.6} "
+                    f"{self.siteAnt[ant]['E05']['north']:6.6} "
+                    f"{self.siteAnt[ant]['E05']['east']:6.6}"
                 )
             else:
                 _e05 = "------ ------ ------"
@@ -373,17 +392,17 @@ class Command(TyperCommand):
 
             if "E06" in self.siteAnt[ant]:
                 _e06 = (
-                    f'{self.siteAnt[ant]["E06"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["E06"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["E06"]["east"]:6.6}'
+                    f"{self.siteAnt[ant]['E06']['up']:6.6} "
+                    f"{self.siteAnt[ant]['E06']['north']:6.6} "
+                    f"{self.siteAnt[ant]['E06']['east']:6.6}"
                 )
             else:
                 _e06 = "------ ------ ------"
             if "E07" in self.siteAnt[ant]:
                 _e07 = (
-                    f'{self.siteAnt[ant]["E07"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["E07"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["E07"]["east"]:6.6}'
+                    f"{self.siteAnt[ant]['E07']['up']:6.6} "
+                    f"{self.siteAnt[ant]['E07']['north']:6.6} "
+                    f"{self.siteAnt[ant]['E07']['east']:6.6}"
                 )
             else:
                 _e07 = "------ ------ ------"
@@ -391,9 +410,9 @@ class Command(TyperCommand):
 
             if "E08" in self.siteAnt[ant]:
                 _e08 = (
-                    f'{self.siteAnt[ant]["E08"]["up"]:6.6} '
-                    f'{self.siteAnt[ant]["E08"]["north"]:6.6} '
-                    f'{self.siteAnt[ant]["E08"]["east"]:6.6}'
+                    f"{self.siteAnt[ant]['E08']['up']:6.6} "
+                    f"{self.siteAnt[ant]['E08']['north']:6.6} "
+                    f"{self.siteAnt[ant]['E08']['east']:6.6}"
                 )
             else:
                 _e08 = "------ ------ ------"
@@ -401,11 +420,10 @@ class Command(TyperCommand):
             yield f" {ant} ----  {_e08} ------ ------ ------ {self.sinex_code:10s}"
         yield "-SITE/GAL_PHASE_CENTER"
 
-    def site_eccentricity(self, sites):
+    def site_eccentricity(self, sites) -> t.Generator[str, None, None]:
         yield "+SITE/ECCENTRICITY"
         yield (
-            "*CODE PT SOLN T _DATA START_ __DATA_END__ REF __DX_U__ __DX_N__ "
-            "__DX_E__"
+            "*CODE PT SOLN T _DATA START_ __DATA_END__ REF __DX_U__ __DX_N__ __DX_E__"
         )
         for site in sites.prefetch_related(
             Prefetch(
@@ -424,39 +442,39 @@ class Command(TyperCommand):
                 )
         yield "-SITE/ECCENTRICITY"
 
-    def satellite_ids(self):
+    def satellite_ids(self) -> t.Generator[str, None, None]:
         yield "+SATELLITE/ID"
-        yield ("*CNNN PN COSPARID_ T _START_DATE_ __END_DATE__ " "____ANTENNA_TYPE____")
+        yield ("*CNNN PN COSPARID_ T _START_DATE_ __END_DATE__ ____ANTENNA_TYPE____")
         for sat in sorted(self.atx):
             for startDate in self.atx[sat]:
                 yield (
-                    f' {sat:.4s} {self.atx[sat][startDate]["prn"]:.2s} '
-                    f'{self.atx[sat][startDate]["cospar_id"]:.9s} P '
-                    f'{startDate:.12s} {self.atx[sat][startDate]["endDate"]:.12s} '
-                    f'{self.atx[sat][startDate]["name"]:.20s}'
+                    f" {sat:.4s} {self.atx[sat][startDate]['prn']:.2s} "
+                    f"{self.atx[sat][startDate]['cospar_id']:.9s} P "
+                    f"{startDate:.12s} {self.atx[sat][startDate]['endDate']:.12s} "
+                    f"{self.atx[sat][startDate]['name']:.20s}"
                 )
         yield "-SATELLITE/ID"
 
-    def satellite_phase_centers(self):
+    def satellite_phase_centers(self) -> t.Generator[str, None, None]:
         yield "+SATELLITE/PHASE_CENTER"
-        yield ("*CNNN F __UP__ NORTH_ _EAST_ F __UP__ NORTH_ _EAST_ " "SINEXCODE_ V M")
+        yield ("*CNNN F __UP__ NORTH_ _EAST_ F __UP__ NORTH_ _EAST_ SINEXCODE_ V M")
         for sat in sorted(self.sat_phase_center):
             if sat.startswith("G"):
                 yield (
-                    f' {sat:4.4} 1 {self.sat_phase_center[sat]["G01"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["G01"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["G01"]["east"]:6.6} 2 '
-                    f'{self.sat_phase_center[sat]["G02"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["G02"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["G02"]["east"]:6.6} '
+                    f" {sat:4.4} 1 {self.sat_phase_center[sat]['G01']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['G01']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['G01']['east']:6.6} 2 "
+                    f"{self.sat_phase_center[sat]['G02']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['G02']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['G02']['east']:6.6} "
                     f"{self.sinex_code:10.10} A E"
                 )
                 try:
                     yield (
                         f" {sat:4.4} 5 "
-                        f'{self.sat_phase_center[sat]["G05"]["up"]:6.6} '
-                        f'{self.sat_phase_center[sat]["G05"]["north"]:6.6} '
-                        f'{self.sat_phase_center[sat]["G05"]["east"]:6.6} - ------ '
+                        f"{self.sat_phase_center[sat]['G05']['up']:6.6} "
+                        f"{self.sat_phase_center[sat]['G05']['north']:6.6} "
+                        f"{self.sat_phase_center[sat]['G05']['east']:6.6} - ------ "
                         f"------ ------ {self.sinex_code:10.10} A E"
                     )
                 except Exception:
@@ -464,44 +482,44 @@ class Command(TyperCommand):
 
             if sat.startswith("R"):
                 yield (
-                    f' {sat:4.4} 1 {self.sat_phase_center[sat]["R01"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["R01"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["R01"]["east"]:6.6} 2 '
-                    f'{self.sat_phase_center[sat]["R02"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["R02"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["R02"]["east"]:6.6} '
+                    f" {sat:4.4} 1 {self.sat_phase_center[sat]['R01']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['R01']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['R01']['east']:6.6} 2 "
+                    f"{self.sat_phase_center[sat]['R02']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['R02']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['R02']['east']:6.6} "
                     f"{self.sinex_code:10.10} A E"
                 )
 
             if sat.startswith("E"):
                 yield (
-                    f' {sat:4.4} 1 {self.sat_phase_center[sat]["E01"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E01"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E01"]["east"]:6.6} 5 '
-                    f'{self.sat_phase_center[sat]["E05"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E05"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E05"]["east"]:6.6} '
+                    f" {sat:4.4} 1 {self.sat_phase_center[sat]['E01']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['E01']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['E01']['east']:6.6} 5 "
+                    f"{self.sat_phase_center[sat]['E05']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['E05']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['E05']['east']:6.6} "
                     f"{self.sinex_code:10.10} A E"
                 )
                 yield (
-                    f' {sat:4.4} 6 {self.sat_phase_center[sat]["E06"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E06"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E06"]["east"]:6.6} 7 '
-                    f'{self.sat_phase_center[sat]["E07"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E07"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E07"]["east"]:6.6} '
+                    f" {sat:4.4} 6 {self.sat_phase_center[sat]['E06']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['E06']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['E06']['east']:6.6} 7 "
+                    f"{self.sat_phase_center[sat]['E07']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['E07']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['E07']['east']:6.6} "
                     f"{self.sinex_code:10.10} A E"
                 )
                 yield (
                     f" {sat:4.4} 8 "
-                    f'{self.sat_phase_center[sat]["E08"]["up"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E08"]["north"]:6.6} '
-                    f'{self.sat_phase_center[sat]["E08"]["east"]:6.6} - ------ '
+                    f"{self.sat_phase_center[sat]['E08']['up']:6.6} "
+                    f"{self.sat_phase_center[sat]['E08']['north']:6.6} "
+                    f"{self.sat_phase_center[sat]['E08']['east']:6.6} - ------ "
                     f"------ ------ {self.sinex_code:10.10} A E"
                 )
         yield "-SATELLITE/PHASE_CENTER"
 
-    def build_antex_index(self, antex_file):
+    def build_antex_index(self, antex_file: str):
         """
         Streams the antex file from files.igs.org and builds an index off of
         it.

slm/management/commands/head_from_index.py

@@ -1,13 +1,13 @@
 """
 If your site log file index is more current than the database state
-(i.e. you've run :ref:`command_import_archive`), you may run this command to pull data
+(i.e. you've run :django-admin:`import_archive`), you may run this command to pull data
 from the most recent indexed files into the database.
 
 .. tip::
 
     By default, rich HTML logs of the import process will be written to:
 
-        ``settings.LOG_DIR / head_from_index.TIMESTAMP``
+        ``settings.SLM_LOG_DIR / head_from_index.TIMESTAMP``
 
     ImportAlerts will also be issued for any errors flagged during import. When,
     appropriate validation flags will be attached to site log fields. This allows you
@@ -85,7 +85,7 @@ class Command(TyperCommand):
     sites: t.Sequence[Site]
     clean: bool = True
     prompt: bool = True
-    logs: Path = Path("{LOG_DIR}") / "head_from_index.{TIMESTAMP}"
+    logs: Path = Path("{SLM_LOG_DIR}") / "head_from_index.{TIMESTAMP}"
     verbosity = 1
 
     indexes: t.Sequence[ArchiveIndex]
@@ -184,7 +184,7 @@ class Command(TyperCommand):
 
         self.logs = Path(
             str(logs).format(
-                LOG_DIR=getattr(settings, "LOG_DIR", "./"),
+                SLM_LOG_DIR=getattr(settings, "SLM_LOG_DIR", "./"),
                 TIMESTAMP=datetime.now().strftime("%Y-%m-%d_%H-%M-%S"),
             )
         )
@@ -214,8 +214,10 @@ class Command(TyperCommand):
         self.failed_imports = []
 
         self.indexes = (
-            ArchiveIndex.objects.filter(site__in=self.sites, end__isnull=True)
-            .order_by("site", "-begin")
+            ArchiveIndex.objects.filter(
+                site__in=self.sites, valid_range__upper_inf=True
+            )
+            .order_by("site", "-valid_range")
             .distinct("site")
         )
 
@@ -465,9 +467,10 @@ class Command(TyperCommand):
                             setattr(form, field, value)
                         form.previous = (
                             ArchiveIndex.objects.filter(
-                                site=index.site, end__lte=index.begin
+                                site=index.site,
+                                valid_range__startswith__lte=index.begin,
                             )
-                            .order_by("-end")
+                            .order_by("-valid_range")
                             .first()
                         )
                         form.save(skip_update=True, set_previous=False)

slm/management/commands/import_archive.py

@@ -3,17 +3,17 @@ When transitioning site log management into an SLM you will have to import all o
 existing data. There are two primary steps involved in doing this:
 
 1. Import the index of existing serialized point in time site logs.
-2. Populate the sitelog fields in the database from the most recent site logs for each
+2. Populate the site log fields in the database from the most recent site logs for each
    station.
 
-This command will perform #1 and optionally call :ref:`command_head_from_index` on the
+This command will perform #1 and optionally call :django-admin:`head_from_index` on the
 imported stations to also perform #2.
 
 .. tip::
 
     Rich HTML logs of the import process will be written to:
 
-        ``settings.LOG_DIR / import_archive.TIMESTAMP``
+        ``settings.SLM_LOG_DIR / import_archive.TIMESTAMP``
 
 Logs will be parsed and errors reported, but parsing errors will not prevent logs from
 being indexed.
@@ -185,7 +185,7 @@ class Command(TyperCommand):
     agencies: t.List[Agency] = []
     owner: t.Optional[User] = None
 
-    logs: Path = Path("{LOG_DIR}") / "import_archive.{TIMESTAMP}"
+    logs: Path = Path("{SLM_LOG_DIR}") / "import_archive.{TIMESTAMP}"
     verbosity: int = 1
     traceback: bool = False
 
@@ -194,9 +194,9 @@ class Command(TyperCommand):
 
     # this matches fourYYMM.log and four_YYYYMMDD.log styles
     FILE_NAME_REGEX = re.compile(
-        r"^((?P<four_id>[a-zA-Z\d]{4})(?P<yymm>\d{4})|"
-        r"((?P<site>[a-zA-Z\d]{4,9})?\D*(?P<date_part>\d{8})(?P<extra>.*)))"
-        r"[.](?P<ext>(log)|(txt)|(xml))$"
+        r"^((?P<four_id>[a-zA-Z\d]{4})(?P<yymm>\d{4})?|"
+        r"((?P<site>[a-zA-Z\d]{4,})?\D*(?P<date_part>\d{8})?(?P<extra>.*)?))"
+        r"[.](?P<ext>(log)|(sitelog)|(txt)|(xml)|(gml)|(json))$"
     )
 
     def process_filename(
@@ -381,7 +381,9 @@ class Command(TyperCommand):
         traceback: Traceback = traceback,
     ):
         if not archive:
-            archive = Path(input(_("Where is the archive? (directory or tar/zip): ")))
+            archive = Path(
+                input(_("Where is the archive? (directory or tar/zip): ")).strip()
+            )
         self.archive = archive.expanduser()
         if not self.archive.exists():
             raise CommandError(
@@ -394,7 +396,7 @@ class Command(TyperCommand):
         self.owner = owner
         self.logs = Path(
             str(logs).format(
-                LOG_DIR=getattr(settings, "LOG_DIR", "./"),
+                SLM_LOG_DIR=getattr(settings, "SLM_LOG_DIR", "./"),
                 TIMESTAMP=datetime.now().strftime("%Y-%m-%d_%H-%M-%S"),
             )
         )
@@ -414,10 +416,11 @@ class Command(TyperCommand):
         if not self.archive.exists():
             raise CommandError(_("{file} does not exist.").format(file=self.archive))
 
-        if SiteLogFormat.GEODESY_ML in self.formats:
-            from slm.parsing.xsd import load_schemas
+        # if SiteLogFormat.GEODESY_ML in self.formats:
+        #     # TODO - only do this if necessary
+        #     from slm.parsing.xsd import load_schemas
 
-            load_schemas()
+        #     load_schemas()
 
         if self.archive.is_file() and tarfile.is_tarfile(self.archive):
             with tarfile.open(self.archive, "r") as archive:
@@ -451,7 +454,7 @@ class Command(TyperCommand):
                             if self.verbosity > 1:
                                 self.secho(
                                     _(
-                                        "Unable to interpret {filename} as a sitelog."
+                                        "Unable to interpret {filename} as a site log."
                                     ).format(filename=archive_name),
                                     fg="red",
                                 )
@@ -503,7 +506,7 @@ class Command(TyperCommand):
                         if self.verbosity > 1:
                             self.secho(
                                 _(
-                                    "Unable to interpret {filename} as a sitelog."
+                                    "Unable to interpret {filename} as a site log."
                                 ).format(filename=file.name),
                                 fg="red",
                             )
@@ -537,7 +540,7 @@ class Command(TyperCommand):
             if not file_meta:
                 raise CommandError(
                     _(
-                        "Unable to interpret {file} as either an tar archive or a sitelog."
+                        "Unable to interpret {file} as either an tar archive or a site log."
                     ).format(file=self.archive)
                 )
             file_meta.contents = self.archive.read_bytes()
@@ -582,7 +585,9 @@ class Command(TyperCommand):
                         _("Updating {site} state.").format(site=site.name), fg="blue"
                     )
                 save = False
-                recent_first = ArchiveIndex.objects.filter(site=site).order_by("-begin")
+                recent_first = ArchiveIndex.objects.filter(site=site).order_by(
+                    "-valid_range"
+                )
                 latest = recent_first.first()
                 oldest = recent_first.last()
                 if site.last_publish is None or site.last_publish < latest.begin:
@@ -684,8 +689,12 @@ class Command(TyperCommand):
             with open(log, "wt") as log_f:
                 log_f.write(log_index)
 
-        if log and self.verbosity > 0:
-            return log.absolute()
+        if log:
+            import webbrowser
+
+            webbrowser.open(log.resolve().as_uri())
+            if self.verbosity > 0:
+                return log.absolute()
 
     def process_file(self, file_meta: FileMeta):
         with transaction.atomic():

slm/management/commands/import_equipment.py

@@ -2,7 +2,7 @@
 Station equipment including Antennas, Radomes and Receivers are coded by IGS and
 those standard codes are used to uniquely identify equipment in site log files.
 
-The full IGS changelog for equipment codes is recorded in rcvr_ant.tab_.
+The full IGS change log for equipment codes is recorded in rcvr_ant.tab_.
 
 The SLM stores these codes in database tables, so it is possible to instantiate an
 SLM with a different set of equipment codes. This command can be used to load codes

slm/management/commands/sitelog.py

@@ -118,9 +118,7 @@ class Command(TyperCommand):
         if self.archive:
             index = ArchiveIndex.objects.filter(site=self.site).first()
             qry = Q(log_format=SiteLogFormat.GEODESY_ML)
-            qry &= Q(index__begin__lte=self.archive) & (
-                Q(index__end__gt=self.archive) | Q(index__end__isnull=True)
-            )
+            qry &= Q(index__valid_range__contains=self.archive)
             if gml_version:
                 qry &= Q(gml_version=gml_version)
             log_file = index.files.filter(qry).first()

slm/management/commands/synchronize.py

@@ -9,7 +9,7 @@ Some examples of denormalized state in the SLM include:
 
     * Counts of validation flags
     * Maximum alert levels for stations
-    * Sitelog status indicators (PUBLISHED/UNPUBLISHED) for stations.
+    * Site log status indicators (PUBLISHED/UNPUBLISHED) for stations.
 """
 
 import typing as t