625def get_service(station: str, country_code: str) -> ScrapeService:
626    """Return the preferred scrape service for a given station.
627
628    ```python
629    # Fetch Australian reports
630    station = "YWOL"
631    country = "AU"  # can source from avwx.Station.country
632    # Get the station's preferred service and initialize to fetch METARs
633    service = avwx.service.get_service(station, country)("metar")
634    # service is now avwx.service.Aubom init'd to fetch METARs
635    # Fetch the current METAR
636    report = service.fetch(station)
637    ```
638    """
639    with suppress(KeyError):
640        return PREFERRED[station[:2]]  # type: ignore
641    return BY_COUNTRY.get(country_code, Noaa)  # type: ignore

223class Amo(StationScrape):
224    """Request data from AMO KMA for Korean stations."""
225
226    _url = "http://amoapi.kma.go.kr/amoApi/{}"
227    default_timeout = 60
228
229    def _make_url(self, station: str) -> tuple[str, dict]:
230        """Return a formatted URL and parameters."""
231        return self._url.format(self.report_type), {"icao": station}
232
233    def _extract(self, raw: str, station: str) -> str:  # noqa: ARG002
234        """Extract the report message from XML response."""
235        resp = parsexml(raw)
236        try:
237            report = resp["response"]["body"]["items"]["item"][f"{self.report_type.lower()}Msg"]
238        except KeyError as key_error:
239            raise self._make_err(raw) from key_error
240        if not report:
241            msg = "The station might not exist"
242            raise self._make_err(msg)
243        # Replace line breaks
244        report = report.replace("\n", "")
245        # Remove excess leading and trailing data
246        for item in (self.report_type.upper(), "SPECI"):
247            if report.startswith(f"{item} "):
248                report = report[len(item) + 1 :]
249        report = report.rstrip("=")
250        # Make every element single-spaced and stripped
251        return " ".join(report.split())

274class Aubom(StationScrape):
275    """Request data from the Australian Bureau of Meteorology."""
276
277    _url = "http://www.bom.gov.au/aviation/php/process.php"
278    method = "POST"
279
280    @staticmethod
281    def _make_headers() -> dict:
282        """Return request headers."""
283        return {
284            "Content-Type": "application/x-www-form-urlencoded",
285            "Accept": "*/*",
286            "Accept-Language": "en-us",
287            "Accept-Encoding": "gzip, deflate",
288            "Host": "www.bom.gov.au",
289            "Origin": "http://www.bom.gov.au",
290            "User-Agent": secrets.choice(_USER_AGENTS),
291            "Connection": "keep-alive",
292        }
293
294    def _post_data(self, station: str) -> dict:
295        """Return the POST form."""
296        return {"keyword": station, "type": "search", "page": "TAF"}
297
298    def _extract(self, raw: str, station: str) -> str:  # noqa: ARG002
299        """Extract the reports from HTML response."""
300        index = 1 if self.report_type == "taf" else 2
301        try:
302            report = raw.split("<p")[index]
303            report = report[report.find(">") + 1 :]
304        except IndexError as index_error:
305            msg = "The station might not exist"
306            raise self._make_err(msg) from index_error
307        if report.startswith("<"):
308            return ""
309        report = report[: report.find("</p>")]
310        return report.replace("<br />", " ")

375class Avt(StationScrape):
376    """Request data from AVT/XiamenAir for China.
377    NOTE: This should be replaced later with a gov+https source.
378    """
379
380    _url = "http://www.avt7.com/Home/AirportMetarInfo?airport4Code="
381
382    def _make_url(self, station: str) -> tuple[str, dict]:
383        """Return a formatted URL and empty parameters."""
384        return self._url + station, {}
385
386    def _extract(self, raw: str, station: str) -> str:  # noqa: ARG002
387        """Extract the reports from HTML response."""
388        try:
389            data = json.loads(raw)
390            key = f"{self.report_type.lower()}ContentList"
391            text: str = data[key]["rows"][0]["content"]
392        except (TypeError, json.decoder.JSONDecodeError, KeyError, IndexError):
393            return ""
394        else:
395            return text

254class Mac(StationScrape):
255    """Request data from Meteorologia Aeronautica Civil for Columbian stations."""
256
257    _url = "https://meteorologia.aerocivil.gov.co/expert_text_query/parse"
258    method = "POST"
259
260    @staticmethod
261    def _make_headers() -> dict:
262        """Return request headers."""
263        return {"X-Requested-With": "XMLHttpRequest"}
264
265    def _post_data(self, station: str) -> dict:
266        """Return the POST form/data payload."""
267        return {"query": f"{self.report_type} {station}"}
268
269    def _extract(self, raw: str, station: str) -> str:
270        """Extract the report message using string finding."""
271        return self._simple_extract(raw, f"{station.upper()} ", "=")

356class Nam(StationScrape):
357    """Request data from NorthAviMet for North Atlantic and Nordic countries."""
358
359    _url = "https://www.northavimet.com/NamConWS/rest/opmet/command/0/"
360
361    def _make_url(self, station: str) -> tuple[str, dict]:
362        """Return a formatted URL and empty parameters."""
363        return self._url + station, {}
364
365    def _extract(self, raw: str, station: str) -> str:
366        """Extract the reports from HTML response."""
367        starts = [f">{self.report_type.upper()} <", f">{station.upper()}<", "top'>"]
368        report = self._simple_extract(raw, starts, "=")
369        index = report.rfind(">")
370        if index > -1:
371            report = report[index + 1 :]
372        return f"{station} {report.strip()}"

313class Olbs(StationScrape):
314    """Request data from India OLBS flight briefing."""
315
316    # _url = "https://olbs.amsschennai.gov.in/nsweb/FlightBriefing/showopmetquery.php"
317    # method = "POST"
318
319    # Temp redirect
320    _url = "https://avbrief3.el.r.appspot.com/"
321
322    def _make_url(self, station: str) -> tuple[str, dict]:
323        """Return a formatted URL and empty parameters."""
324        return self._url, {"icao": station}
325
326    def _post_data(self, station: str) -> dict:
327        """Return the POST form."""
328        # Can set icaos to "V*" to return all results
329        return {"icaos": station, "type": self.report_type}
330
331    @staticmethod
332    def _make_headers() -> dict:
333        """Return request headers."""
334        return {
335            # "Content-Type": "application/x-www-form-urlencoded",
336            # "Accept": "text/html, */*; q=0.01",
337            # "Accept-Language": "en-us",
338            "Accept-Encoding": "gzip, deflate, br",
339            # "Host": "olbs.amsschennai.gov.in",
340            "User-Agent": secrets.choice(_USER_AGENTS),
341            "Connection": "keep-alive",
342            # "Referer": "https://olbs.amsschennai.gov.in/nsweb/FlightBriefing/",
343            # "X-Requested-With": "XMLHttpRequest",
344            "Accept-Language": "en-US,en;q=0.9",
345            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
346            "Referer": "https://avbrief3.el.r.appspot.com/",
347            "Host": "avbrief3.el.r.appspot.com",
348        }
349
350    def _extract(self, raw: str, station: str) -> str:
351        """Extract the reports from HTML response."""
352        # start = raw.find(f"{self.report_type.upper()} {station} ")
353        return self._simple_extract(raw, [f">{self.report_type.upper()}</div>", station], ["=", "<"])

241class NoaaGfs(NoaaForecast):
242    """Request forecast data from NOAA GFS FTP servers."""
243
244    _url = "https://nomads.ncep.noaa.gov/pub/data/nccf/com/gfs/prod/gfsmos.{}/mdl_gfs{}.t{}z"
245    _valid_types = ("mav", "mex")
246
247    _cycles: ClassVar[dict[str, tuple[int, ...]]] = {"mav": (0, 6, 12, 18), "mex": (0, 12)}
248
249    @property
250    def _urls(self) -> Iterator[str]:
251        """Iterate through update cycles no older than two days."""
252        warnings.warn(
253            "GFS fetch has been deprecated due to NOAA retiring the format. Migrate to NBM for similar data",
254            DeprecationWarning,
255            stacklevel=2,
256        )
257        now = dt.datetime.now(tz=dt.timezone.utc)
258        date = dt.datetime.now(tz=dt.timezone.utc)
259        cutoff = date - dt.timedelta(days=1)
260        while date > cutoff:
261            for cycle in reversed(self._cycles[self.report_type]):
262                date = date.replace(hour=cycle)
263                if date > now:
264                    continue
265                timestamp = date.strftime(r"%Y%m%d")
266                hour = str(date.hour).zfill(2)
267                yield self._url.format(timestamp, self.report_type, hour)
268            date -= dt.timedelta(hours=1)
269
270    def _index_target(self, station: str) -> tuple[str, str]:
271        return f"{station}   GFS", f"{self.report_type.upper()} GUIDANCE"

220class NoaaNbm(NoaaForecast):
221    """Request forecast data from NOAA NBM FTP servers."""
222
223    _url = "https://nomads.ncep.noaa.gov/pub/data/nccf/com/blend/prod/blend.{}/{}/text/blend_{}tx.t{}z"
224    _valid_types = ("nbh", "nbs", "nbe", "nbx")
225
226    @property
227    def _urls(self) -> Iterator[str]:
228        """Iterate through hourly updates no older than two days."""
229        date = dt.datetime.now(tz=dt.timezone.utc)
230        cutoff = date - dt.timedelta(days=1)
231        while date > cutoff:
232            timestamp = date.strftime(r"%Y%m%d")
233            hour = str(date.hour).zfill(2)
234            yield self._url.format(timestamp, hour, self.report_type, hour)
235            date -= dt.timedelta(hours=1)
236
237    def _index_target(self, station: str) -> tuple[str, str]:
238        return f"{station}   ", f"{self.report_type.upper()} GUIDANCE"

38class Service:
39    """Base Service class for fetching reports."""
40
41    report_type: str
42    _url: ClassVar[str] = ""
43    _valid_types: ClassVar[tuple[str, ...]] = ()
44
45    def __init__(self, report_type: str):
46        if self._valid_types and report_type not in self._valid_types:
47            msg = f"'{report_type}' is not a valid report type for {self.__class__.__name__}. Expected {self._valid_types}"
48            raise ValueError(msg)
49        self.report_type = report_type
50
51    @property
52    def root(self) -> str | None:
53        """Return the service's root URL."""
54        if self._url is None:
55            return None
56        url = self._url[self._url.find("//") + 2 :]
57        return url[: url.find("/")]