AVWX Engine

https://engine.avwx.rest
Admin
A global aviation weather fetching and parsing engine that sources reports from government sources...
Tokens:169,270
Snippets:1,070
Trust Score:7.5
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install all dependencies

Source: https://engine.avwx.rest/avwx.html

Installs avwx-engine with all optional dependencies.

```bash
python -m pip install avwx-engine[all]
```

--------------------------------

### Install all dependencies

Source: https://engine.avwx.rest/

Command to install avwx-engine with all optional dependencies.

```bash
python -m pip install avwx-engine[all]

```

--------------------------------

### Install avwx-engine

Source: https://engine.avwx.rest/avwx.html

Installs the avwx-engine package from PyPI.

```bash
python -m pip install avwx-engine
```

--------------------------------

### NOAA_NBM Service Example

Source: https://engine.avwx.rest/avwx/service.html

An example implementation of a FileService for NOAA NBM FTP servers, demonstrating URL iteration and data extraction.

```python
class NOAA_NBM(FileService):
    """Requests forecast data from NOAA NBM FTP servers"""

    _url = "https://nomads.ncep.noaa.gov/pub/data/nccf/com/blend/prod/blend.{}/{}/text/blend_{}tx.t{}z"
    _valid_types = ("nbh", "nbs", "nbe")

    @property
    def _urls(self) -> Iterator[str]:
        """Iterates through hourly updates no older than two days"""
        date = dt.datetime.now(tz=dt.timezone.utc)
        cutoff = date - dt.timedelta(days=1)
        while date > cutoff:
            timestamp = date.strftime(r"%Y%m%d")
            hour = str(date.hour).zfill(2)
            yield self.url.format(timestamp, hour, self.report_type, hour)
            date -= dt.timedelta(hours=1)

    def _extract(self, station: str, source: TextIO) -> Optional[str]:
        """Returns report pulled from the saved file"""
        start = station + "   "
        end = self.report_type.upper() + " GUIDANCE"
        txt = source.read()
        txt = txt[txt.find(start) :]
        txt = txt[: txt.find(end, 30)]
        lines = []
        for line in txt.split("\n"):
            if "CLIMO" not in line:
                line = line.strip()
            if not line:
                break
            lines.append(line)
        return "\n".join(lines) or None

```

--------------------------------

### Install avwx-engine

Source: https://engine.avwx.rest/

Command to install the avwx-engine package from PyPI.

```bash
python -m pip install avwx-engine

```

--------------------------------

### NBX Report Example

Source: https://engine.avwx.rest/avwx/forecast/nbm.html

Example of fetching and pulling NBX data for KJFK.

```python
>>> from avwx import Nbx
>>> kjfk = Nbx("KJFK")
>>> kjfk.station.name
'John F Kennedy International Airport'
>>> kjfk.update()
True
>>> kjfk.last_updated
datetime.datetime(2023, 10, 17, 4, 0, 0, 909939, tzinfo=datetime.timezone.utc)
>>> print(kjfk.raw)
"""
086092  NBM V4.1 NBX GUIDANCE   10/17/2023  0300 UTC
WED 25 |THU 26 |FRI 27 |SAT 28
UTC 12 |00  12 |00  12 |00
FHR 201|213 225|237 249|261
TXN  76| 81  75| 81  75| 81
XND   1|  1   1|  2   1|  0
TMP  77| 77  77| 78  76| 78
TSD   1|  2   1|  1   2|  1
DPT  67| 67  69| 68  70| 69
DSD   1|  2   1|  1   2|  1
SKY  34| 46  27| 50  26| 37
SSD  12| 22  13| 22  12|  7
WDR   7|  7   7|  6   5|  5
WSP  15| 16  15| 17  15| 17
WSD   3|  4   3|  3   4|  3
GST  22| 24  22| 25  22| 25
GSD   2|  2   2|  1   1|  1
P12   8|  8   9|  7   7|  7
Q12   0|  0   0|  3   0|  0
Q24   0|      0|      3|
DUR   0|  0   0|  0   0|  0
PZR   0|  0   0|  0   0|  0
PSN   0|  0   0|  0   0|  0
PPL   0|  0   0|  0   0|  0
PRA   7| 16  14| 10   6| 11
S12   0|  0   0|  0   0|  0
I12   0|  0   0|  0   0|  0
SOL   1| 35   1| 15   1| 38
"""
>>> len(kjfk.data.forecast)
25
>>> kjfk.data.forecast[0].wind_speed
Number(repr='15', value=150, spoken='one five zero')
>>> print(kjfk.data.forecast[1].solar_radiation.value, kjfk.units.solar_radiation)
35 W/m2
```

--------------------------------

### Station Dataclass Example

Source: https://engine.avwx.rest/avwx/station.html

Example of how to get station information using the Station.from_code method and access its attributes like name, city, state, coordinates, elevation, and runway details.

```python
>>> from avwx import Station
>>> klex = Station.from_code("KLEX")
>>> f"{klex.name} in {klex.city}, {klex.state}"
'Blue Grass Airport in Lexington, KY'
>>> coord = round(klex.latitude, 3), round(klex.longitude, 3)
>>> f"Located at {coord} at {klex.elevation_ft} feet ({klex.elevation_m} meters)"
'Located at (38.036, -84.606) at 979 feet (298 meters)'
>>> rw = max(klex.runways, key=lambda r: r.length_ft)
>>> f"Its longest runway is {rw.ident1}/{rw.ident2} at {rw.length_ft} feet"
'Its longest runway is 04/22 at 7003 feet'
```

--------------------------------

### AirSigManager Example

Source: https://engine.avwx.rest/avwx/current/airsigmet.html

Example usage of the AirSigManager class to fetch and interact with AIRMET and SIGMET reports.

```python
from avwx import AirSigManager
from avwx.structs import Coord
manager = AirSigManager()
manager.update()
manager.last_updated
len(manager.reports)
len(manager.contains(Coord(lat=33.12, lon=-105)))
manager.reports[0].data.bulletin.type
manager.reports[0].data.type
```

--------------------------------

### MissingExtraModule

Source: https://engine.avwx.rest/avwx/exceptions.html

Inform user that an extra install module is needed.

```python
22class MissingExtraModule(ModuleNotFoundError):
23    """Inform user that an extra install module is needed."""
24
25    def __init__(self, extra: str):
26        super().__init__(f"Install avwx-engine[{extra}] to use this feature")

```

--------------------------------

### AirSigManager Usage Example

Source: https://engine.avwx.rest/avwx/current/airsigmet.html

Demonstrates how to initialize, update, and query the AirSigManager for AIRMET and SIGMET reports.

```python
>>> from avwx import AirSigManager
>>> from avwx.structs import Coord
>>> manager = AirSigManager()
>>> manager.update()
True
>>> manager.last_updated
datetime.datetime(2022, 3, 27, 5, 54, 21, 516741, tzinfo=datetime.timezone.utc)
>>> len(manager.reports)
113
>>> len(manager.contains(Coord(lat=33.12, lon=-105)))
5
>>> manager.reports[0].data.bulletin.type
Code(repr='WA', value='airmet')
>>> manager.reports[0].data.type
'AIRMET SIERRA FOR IFR AND MTN OBSCN'
```

--------------------------------

### MissingExtraModule(extra: str)

Source: https://engine.avwx.rest/avwx/exceptions.html

Inform user that an extra install module is needed.

```python
25    def __init__(self, extra: str):
26        super().__init__(f"Install avwx-engine[{extra}] to use this feature")

```

--------------------------------

### get_service Example

Source: https://engine.avwx.rest/avwx/service.html

Example of how to use the get_service function to fetch METAR reports for an Australian station.

```python
# Fetch Australian reports
station = "YWOL"
country = "AU"  # can source from avwx.Station.country
# Get the station's preferred service and initialize to fetch METARs
service = avwx.service.get_service(station, country)("metar")
# service is now avwx.service.Aubom init'd to fetch METARs

```

--------------------------------

### ScrapeService Example: MAC Service

Source: https://engine.avwx.rest/avwx/service.html

Example implementation of a ScrapeService for the MAC service, including URL generation and data extraction.

```python
class MAC(StationScrape):
    """Requests data from Meteorologia Aeronautica Civil for Columbian stations"""

    _url = "http://meteorologia.aerocivil.gov.co/expert_text_query/parse"
    method = "POST"

    def _make_url(self, station: str) -> tuple[str, dict]:
        """Returns a formatted URL and parameters"""
        return self._url, {"query": f"{self.report_type} {station}"}

    def _extract(self, raw: str, station: str) -> str:
        """Extracts the report message using string finding"""
        return self._simple_extract(raw, f"{station.upper()} ", "=")

```

--------------------------------

### JoinedCloud

Source: https://engine.avwx.rest/avwx/parsing/sanitization/cleaners/joined.html

For items starting with cloud list.

```python
1"""Cleaners where two items are joined."""
2
3from __future__ import annotations
4
5import re
6
7from avwx.parsing.core import is_timerange, is_timestamp
8from avwx.parsing.sanitization.base import SplitItem
9from avwx.static.core import CLOUD_LIST
10from avwx.static.taf import TAF_NEWLINE, TAF_NEWLINE_STARTSWITH
11
12_CLOUD_GROUP = "(" + "|".join(CLOUD_LIST) + ")"
13CLOUD_SPACE_PATTERNS = [
14    re.compile(pattern)
15    for pattern in (
16        f"(?=.+){_CLOUD_GROUP}" + r"\\d{3}(\\w{2,3})?$",  # SCT010BKN021
17        r"M?\d{2}\\/M?\d{2}$",  # BKN01826/25
18    )
19]
20
21
22class JoinedCloud(SplitItem):
23    """For items starting with cloud list."""
24
25    def split_at(self, item: str) -> int | None:
26        if item[:3] in CLOUD_LIST:
27            for pattern in CLOUD_SPACE_PATTERNS:
28                match = pattern.search(item)
29                if match is None:
30                    continue
31                if match.start():
32                    return match.start()
33        return None
34
35
36_TIMESTAMP_BREAKS = ((7, is_timestamp), (9, is_timerange))
37
38
39class JoinedTimestamp(SplitItem):
40    """Connected timestamp."""
41
42    def split_at(self, item: str) -> int | None:
43        return next(
44            (loc for loc, check in _TIMESTAMP_BREAKS if len(item) > loc and check(item[:loc])),
45            None,
46        )
47
48
49class JoinedWind(SplitItem):
50    """Connected to wind."""
51
52    def split_at(self, item: str) -> int | None:
53        if len(item) > 5 and "KT" in item and not item.endswith("KT"):
54            index = item.find("KT")
55            if index > 4:
56                return index + 2
57        return None
58
59
60class JoinedTafNewLine(SplitItem):
61    """TAF newline connected to previous element."""
62
63    def split_at(self, item: str) -> int | None:
64        for key in TAF_NEWLINE:
65            if key in item and not item.startswith(key):
66                return item.find(key)
67        for key in TAF_NEWLINE_STARTSWITH:
68            if key in item and not item.startswith(key):
69                index = item.find(key)
70                if item[index + len(key) :].isdigit():
71                    return index
72        return None
73
74
75class JoinedMinMaxTemperature(SplitItem):
76    """Connected TAF min/max temp."""
77
78    def split_at(self, item: str) -> int | None:
79        if "TX" in item and "TN" in item and item.endswith("Z") and "/" in item:
80            tx_index, tn_index = item.find("TX"), item.find("TN")
81            return max(tx_index, tn_index)
82        return None
83
84
85RVR_PATTERN = re.compile(r"R\d{2}[RCL]?/\S+")
86
87
88class JoinedRunwayVisibility(SplitItem):
89    """Connected RVR elements.
90    Ex: R36/1500DR18/P2000
91    """
92
93    def split_at(self, item: str) -> int | None:
94        return match.start() + 1 if (match := RVR_PATTERN.search(item[1:])) else None
```

```python
CLOUD_SPACE_PATTERNS = [re.compile('(?=.+)(FEW|SCT|BKN|OVC)\\d{3}(\\w{2,3})?$'), re.compile('M?\\\d{2}\\/M?\\\d{2}$')]
class JoinedCloud(avwx.parsing.sanitization.cleaners.base.SplitItem):
```

```python
23class JoinedCloud(SplitItem):
24    """For items starting with cloud list."""
25
26    def split_at(self, item: str) -> int | None:
27        if item[:3] in CLOUD_LIST:
28            for pattern in CLOUD_SPACE_PATTERNS:
29                match = pattern.search(item)
30                if match is None:
31                    continue
32                if match.start():
33                    return match.start()
34        return None
```

```python
26    def split_at(self, item: str) -> int | None:
27        if item[:3] in CLOUD_LIST:
28            for pattern in CLOUD_SPACE_PATTERNS:
29                match = pattern.search(item)
30                if match is None:
31                    continue
32                if match.start():
33                    return match.start()
34        return None
```

```python
40class JoinedTimestamp(SplitItem):
41    """Connected timestamp."""
42
43    def split_at(self, item: str) -> int | None:
44        return next(
45            (loc for loc, check in _TIMESTAMP_BREAKS if len(item) > loc and check(item[:loc])),
46            None,
47        )
```

```python
43    def split_at(self, item: str) -> int | None:
44        return next(
45            (loc for loc, check in _TIMESTAMP_BREAKS if len(item) > loc and check(item[:loc])),
46            None,
47        )
```

--------------------------------

### Basic Module Use

Source: https://engine.avwx.rest/avwx/service.html

Example of using the get_service function to fetch Australian METAR reports.

```python
# Fetch Australian reports
station = 'YWOL'
country = 'AU' # can source from avwx.Station.country
# Get the station's preferred service and initialize to fetch METARs
service = avwx.service.get_service(station, country)('metar')
# service is now avwx.service.AUBOM init'd to fetch METARs
# Fetch the current METAR
report = service.fetch(station)

```

--------------------------------

### NBX Forecast Data

Source: https://engine.avwx.rest/avwx/forecast/nbm.html

Example of fetching and accessing NBX forecast data.

```python
>>> from avwx import Kjfk
>>> kjfk = Kjfk("KJFK")
>>> kjfk.station.name
'John F Kennedy International Airport'
>>> kjfk.update()
True
>>> kjfk.last_updated
datetime.datetime(2020, 7, 28, 1, 3, 46, 447635, tzinfo=datetime.timezone.utc)
>>> print(kjfk.raw)
"""
260    MHT  26 26 20 19  8  7  6  4  4  5  5  5  6  4  5  6  6 11 20 27 37 39 43 39 31
261    TWD  24 26 26 27 26 26 24 23 24 26 26 26 27 27 28 27 27 27 27 26 26 26 25 25 24
262    TWS  15 14 14 13 11 11 11 10 11 11 10 11 10  8  8  7  8  9 12 13 14 15 17 17 16
263    HID                                 6                 5                 6
264    SOL 710500430250110  0 30  0  0  0  0  0  0  0 30160330500650760830870870850720
265    """
>>> len(kjfk.data.forecast)
25
>>> kjfk.data.forecast[0].snow_level
Number(repr='99', value=9900, spoken='nine nine hundred')
>>> print(kjfk.data.forecast[0].solar_radiation.value, kjfk.units.solar_radiation)
710 W/m2
```

--------------------------------

### Parse a NOTAM report string directly

Source: https://engine.avwx.rest/avwx/current/notam.html

Example of using the `from_report` class method to parse a raw NOTAM string and access its attributes like type and start time.

```python
from avwx import Notams

report = """
05/295 NOTAMR
Q) ZNY/QMNHW/IV/NBO/A/000/999/4038N07346W005
A) KJFK
B) 2205201527
C) 2205271100

E) APRON TERMINAL 4 RAMP CONST WIP S SIDE TAXILANE G LGTD AND BARRICADED
"""
kjfk = Notams.from_report(report)
print(kjfk.data[0].type)
print(kjfk.data[0].start_time)
```

--------------------------------

### METAR and TAF Tutorial

Source: https://engine.avwx.rest/

Example of fetching and parsing a METAR report, accessing raw data, flight rules, summary, and station information.

```python
>>> import avwx
>>> jfk_metar = avwx.Metar('KJFK')
>>> jfk_metar.update()
True
>>> jfk_metar.raw
'KJFK 281651Z 33021G25KT 10SM FEW060 M08/M23 A3054 RMK AO2 SLP339 T10831228'
>>> jfk_metar.data.flight_rules
'VFR'
>>> jfk_metar.summary
'Winds NNW-330 at 21kt gusting to 25kt, Vis 10sm, Temp -08C, Dew -23C, Alt 30.54inHg, Few clouds at 6000ft'
>>> jfk_metar.station.name
'John F Kennedy International Airport'

```

--------------------------------

### BadStation

Source: https://engine.avwx.rest/avwx/exceptions.html

Station does not exist.

```python
10class BadStation(Exception):
11    """Station does not exist."""

```

--------------------------------

### Full module

Source: https://engine.avwx.rest/avwx/parsing/sanitization/cleaners/base.html

Full module code.

```python
1"""Cleaning base classes."""

from __future__ import annotations


class Cleaner:
    """Base Cleaner type."""

    # Set to True if no more cleaners should check this item
    should_break: bool = False


class SingleItem(Cleaner):
    """Cleaner looks at a single item."""

    def can_handle(self, item: str) -> bool:
        """Return True if the element can and needs to be cleaned."""
        raise NotImplementedError


class DoubleItem(Cleaner):
    """Cleaner that looks at two neighboring items."""

    def can_handle(self, first: str, second: str) -> bool:
        """Return True if neighboring pairs need to be cleaned."""
        raise NotImplementedError


class RemoveItem(SingleItem):
    """Sanitization should remove item if handled."""

    should_break = True


class CleanItem(SingleItem):
    """Sanitization should clean/replace item if handled."""

    def clean(self, item: str) -> str:
        """Clean the raw string."""
        raise NotImplementedError


class CleanPair(DoubleItem):
    """Sanitization should clean both paired items."""

    def clean(self, first: str, second: str) -> tuple[str, str]:
        """Clean both raw strings."""
        raise NotImplementedError


class SplitItem(Cleaner):
    """Sanitization should split the item in two at an index if handled"

    def split_at(self, item: str) -> int | None:
        """Return the string index where the item should be split."""
        raise NotImplementedError


class CombineItems(Cleaner):
    """Sanitization should combine two different items if handled."""

    def can_handle(self, first: str, second: str) -> bool:
        """Return True if both elements can and need to be combined."""
        raise NotImplementedError


CleanerListType = list[type[CleanItem] | type[CleanPair] | type[RemoveItem] | type[SplitItem] | type[CombineItems]]

```

--------------------------------

### NBM NBH Report Example

Source: https://engine.avwx.rest/avwx/forecast/nbm.html

Example of a typical NBM NBH report for KJFK.

```text
KJFK   NBM V3.2 NBH GUIDANCE    7/26/2020  1900 UTC
UTC  20 21 22 23 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20
TMP  90 89 88 87 85 84 82 81 81 80 79 78 77 76 76 78 81 84 87 89 90 91 92 92 93
DPT  69 68 66 66 65 65 65 66 66 66 66 67 67 66 67 67 67 67 67 68 67 67 67 67 67
SKY   9 14 41 58 61 71 66 55 39 37 39 43 40 38 29 21 19 26 24 27 22 14 22 26 26
WDR  22 22 23 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 25 24 24 23 23 22 23
WSP  10  9  9  8  7  6  5  5  5  6  5  5  5  5  4  4  5  5  7  8  8  9 10 10 10
GST  17 16 16 15 14 12 11 12 12 12 12 11 11  9  9  9  9 10 11 13 14 15 16 17 17
P01   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
P06                                 0                 0                 0
Q01   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
DUR                                                   0
T01   1  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
PZR   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
PSN   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
PPL   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
PRA 100100100100100100100100100100100100100100100100100100100100100100100100100
S01   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
SLV  99101102103105105105106105104106104104104104103102100 99 98 98 99100101102
I01   0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
CIG 888888888360360350340888888888888888888888888888888888888888888888888888888
VIS 110120120140140130120120120120110110110110110120130140150150150150150150150
LCB  80 60999999999999999999999999999999999999999999999999999999999999999999999
```

--------------------------------

### NBX Report Example

Source: https://engine.avwx.rest/avwx/forecast/nbm.html

This is an example of the NBX report structure, which is a continuation of the NBE forecast.

```python
"""
  1"""
  2# NBH
  3
  4The NBH report is a 25-hour forecast based on the
  5[National Blend of Models](https://vlab.noaa.gov/web/mdl/nbm) and is only valid
  6for ICAO stations in the United States and Puerto Rico, and US Virgin Islands.
  7Reports are in 1-hour increments and are published near the top of every hour.
  8
  9# NBS
 10
 11The NBS report is a
 12short-range forecast (6-72 hours) based on the
 13[National Blend of Models](https://vlab.noaa.gov/web/mdl/nbm) and is only valid
 14for ICAO stations in the United States and Puerto Rico, and US Virgin Islands.
 15Reports are in 3-hour increments and published near the top of every hour.
 16
 17# NBE
 18
 19The NBE report is an extended-range forecast (24-192 hours) based on the
 20[National Blend of Models](https://vlab.noaa.gov/web/mdl/nbm) and is only valid
 21for ICAO stations in the United States and Puerto Rico, and US Virgin Islands.
 22Reports are in 12-hour increments and published near the top of every hour.
 23
 24# NBX
 25
 26The NBX report is a continuation of the NBE forecast (204-264 hours) based on the
 27[National Blend of Models](https://vlab.noaa.gov/web/mdl/nbm) and is only valid
 28for ICAO stations in the United States and Puerto Rico, and US Virgin Islands.
 29Reports are in 12-hour increments and published near the top of every hour.
 30"""
 31
 32# Reference: https://www.weather.gov/mdl/nbm_textcard_v32
 33
 34# stdlib
 35from __future__ import annotations
 36
 37from contextlib import suppress
 38from typing import TYPE_CHECKING
 39
 40if TYPE_CHECKING:
 41    from collections.abc import Callable
 42
 43try:
 44    from typing import TypeAlias
 45except ImportError:
 46    from typing import TypeAlias
 47
 48# module
 49from avwx import structs
 50from avwx.forecast.base import (
 51    Forecast,
 52    _decimal_10,
 53    _decimal_100,
 54    _direction,
 55    _find_time_periods,
 56    _init_parse,
 57    _number_100,
 58    _numbers,
 59    _parse_lines,
 60    _split_line,
 61    _trim_lines,
 62)
 63from avwx.service.files import NoaaNbm
 64from avwx.static.gfs import UNITS
 65
 66DataT: TypeAlias = type[structs.NbhData | structs.NbsData | structs.NbeData | structs.NbxData]
 67PeriodT: TypeAlias = type[structs.NbhPeriod | structs.NbsPeriod | structs.NbePeriod | structs.NbxPeriod]
 68
 69_UNITS = {
 70    **UNITS,
 71    "accumulation": "in",
 72    "duration": "hour",
 73    "solar_radiation": "W/m2",
 74    "wave_height": "ft",
 75}
 76
 77
 78_CEILING = {
 79    # 888 is code but processed as 88800 due to postfix
 80    "88800": (None, "unlimited")
 81}
 82_WIND = {"NG": (0, "zero")}
 83
 84
 85def _ceiling(line: str, size: int = 3) -> list[structs.Number | None]:
 86    """Parse line into Number objects handling ceiling special units."""
 87    return _numbers(line, size, postfix="00", special=_CEILING)
 88
 89
 90def _wind(line: str, size: int = 3) -> list[structs.Number | None]:
 91    """Parse line into Number objects handling wind special units."""
 92    return _numbers(line, size, special=_WIND)
 93
 94
 95_HANDLERS: dict[str, tuple[str, Callable]] = {
 96    "X/N": ("temperature_minmax", _numbers),
 97    "TMP": ("temperature", _numbers),
 98    "DPT": ("dewpoint", _numbers),
 99    "SKY": ("sky_cover", _numbers),
100    "WDR": ("wind_direction", _direction),
101    "WSP": ("wind_speed", _wind),
102    "GST": ("wind_gust", _wind),
103    "DUR": ("precip_duration", _numbers),
104    "PZR": ("freezing_precip", _numbers),
105    "PSN": ("snow", _numbers),
106    "PPL": ("sleet", _numbers),
107    "PRA": ("rain", _numbers),
108    "SLV": ("snow_level", _number_100),
109    "SOL": ("solar_radiation", _numbers),
110    "SWH": ("wave_height", _numbers),
111}
112
113_HOUR_HANDLERS: dict[str, tuple[str, Callable]] = {
114    "P": ("precip_chance", _numbers),
115    "Q": ("precip_amount", _decimal_100),
116    "T": ("thunderstorm", _numbers),
117    "S": ("snow_amount", _decimal_10),
118    "I": ("icing_amount", _decimal_100),
119}
120
121_NBHS_HANDLERS: dict[str, tuple[str, Callable]] = {
122    "CIG": ("ceiling", _ceiling),
123    "VIS": ("visibility", _decimal_10),
124    "LCB": ("cloud_base", _number_100),
125    "MHT": ("mixing_height", _number_100),
126    "TWD": ("transport_wind_direction", _direction),
127    "TWS": ("transport_wind_speed", _numbers),
128    "HID": ("haines", _numbers),
129}
130
131
def _parse_factory(
132    data_class: DataT,
133    period_class: PeriodT,
134    handlers: dict[str, tuple[str, Callable]],
135    hours: int = 2,
136    size: int = 3,
137    prefix: int = 4,
138) -> Callable:
139    """Create handler function for static and computed keys."""
140
```

--------------------------------

### LazyLoad keys method

Source: https://engine.avwx.rest/avwx/load_utils.html

The keys method for LazyLoad, yielding all keys.

```python
def keys(self) -> Iterator[str]:
    self._check()
    yield from self.data.keys()
```

--------------------------------

### make_cloud

Source: https://engine.avwx.rest/avwx/parsing/core.html

Returns a Cloud dataclass for a cloud string.

```python
def make_cloud(cloud: str) -> Cloud:
    """Return a Cloud dataclass for a cloud string.

    This function assumes the input is potentially valid.
    """
    raw_cloud = cloud
    cloud_type = ""
    base: str | None = None
    top: str | None = None
    cloud = sanitize_cloud(cloud).replace("/", "")
    # Separate top
    for target in _TOP_OFFSETS:
        topi = cloud.find(target)
        if topi > -1:
            top, cloud = cloud[topi + len(target) :], cloud[:topi]
```

--------------------------------

### AirSigmet Class Example

Source: https://engine.avwx.rest/avwx/current/airsigmet.html

Example of how to use the AirSigmet class to parse a report and access its data.

```python
>>> from avwx import AirSigmet
>>> report = 'WSPR31 SPJC 270529 SPIM SIGMET 3 VALID 270530/270830 SPJC- SPIM LIMA FIR EMBD TS OBS AT 0510Z NE OF LINE S0406 W07103 - S0358 W07225 - S0235 W07432 - S0114 W07503 TOP FL410 MOV SW NC='
>>> sigmet = AirSigmet.from_report(report)
True
>>> sigmet.last_updated
datetime.datetime(2022, 3, 27, 6, 29, 33, 300935, tzinfo=datetime.timezone.utc)
>>> sigmet.data.observation.coords
[Coord(lat=-4.06, lon=-71.03, repr='S0406 W07103'),
Coord(lat=-3.58, lon=-72.25, repr='S0358 W07225'),
Coord(lat=-2.35, lon=-74.32, repr='S0235 W07432'),
Coord(lat=-1.14, lon=-75.03, repr='S0114 W07503')]
>>> sigmet.data.observation.intensity
Code(repr='NC', value='No change')
>>> sigmet.data.observation.ceiling
Number(repr='FL410', value=410, spoken='flight level four one zero')
```

--------------------------------

### NBM Report Raw Data Example

Source: https://engine.avwx.rest/avwx/forecast/nbm.html

Example of accessing the raw NBM report data for KJFK.

```python
>>> print(kjfk.raw)
"""
KJFK    NBM V3.2 NBE GUIDANCE    7/28/2020  0000 UTC
       WED 29| THU 30| FRI 31| SAT 01| SUN 02| MON 03| TUE 04|WED CLIMO
UTC    00  12| 00  12| 00  12| 00  12| 00  12| 00  12| 00  12| 00
FHR    24  36| 48  60| 72  84| 96 108|120 132|144 156|168 180|192
X/N    93  76| 91  76| 90  74| 86  72| 87  73| 85  74| 86  72| 84 68 83
TMP    84  80| 83  80| 81  78| 78  76| 78  78| 78  78| 78  76| 76
DPT    72  69| 68  69| 71  68| 67  66| 68  69| 70  71| 70  68| 69
SKY    61  21| 23  47| 80  73| 47  31| 30  54| 68  65| 66  59| 32
WDR    25  35| 20  26| 20   2| 16   1| 16   7| 16  24| 22  34| 18
WSP     5   2|  6   3|  5   4|  3   5|  7   4|  6   4|  5   4|  4
GST    11   4| 13   6| 13  10|  9  10| 13   7| 13   9| 16   9| 12
P12    48  23|  8   1| 23  28| 28  16| 18  17| 30  41| 46  31| 32 19 18
Q12    10   0|  0   0|  0   0|  0   0|  0   0|  0  64| 77  81| 83
Q24          |  0    |  0    |  0    |  0    |  0    |141    |164
DUR     2   1|  0   0|  0   0|  0   0|  0   0|  2  12| 12  12| 12
T12    46  32|  6   8| 21  22| 17   5|  6   5| 25  23| 19  18| 18
PZR     0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0
PSN     0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0
PPL     0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0
PRA   100 100|100 100|100 100|100 100|100 100|100 100|100 100|100
S12     0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0
SLV   138 114|111 119|119 121|113 101|108 117|134 132|124 123|121
I12     0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0   0|  0
S24          |  0    |  0    |  0    |  0    |  0    |  0    |  0
SOL   100 320|190 230|270 250|360 290|370  30|190 260|250 230|450
"""
>>> len(kjfk.data.forecast)
25
>>> kjfk.data.forecast[0].wind_direction
Number(repr='25', value=250, spoken='two five zero')
>>> print(kjfk.data.forecast[1].precip_duration.value, kjfk.units.duration)
1 hour
```

--------------------------------

### Report constructor

Source: https://engine.avwx.rest/avwx/current/base.html

Add doc string to show constructor.

```python
def __init__(self, code: str):
    """Add doc string to show constructor."""
    super().__init__(code)
    if self.station is not None:
        service = get_service(code, self.station.country)
        self.service = service(self.__class__.__name__.lower())  # type: ignore
```

--------------------------------

### Station Initialization and Usage

Source: https://engine.avwx.rest/avwx/station.html

Demonstrates how to initialize a Station object using `from_code` and access its attributes.

```python
>>> from avwx import Station
>>> klex = Station.from_code("KLEX")
>>> f"{klex.name} in {klex.city}, {klex.state}"
'Blue Grass Airport in Lexington, KY'
>>> coord = round(klex.latitude, 3), round(klex.longitude, 3)
>>> f"Located at {coord} at {klex.elevation_ft} feet ({klex.elevation_m} meters)"
'Located at (38.036, -84.606) at 979 feet (298 meters)'
>>> rw = max(klex.runways, key=lambda r: r.length_ft)
```

--------------------------------

### TAF Forecast Example

Source: https://engine.avwx.rest/

Example of fetching a TAF report and iterating through its forecast periods to display flight rules and time ranges.

```python
>>> hnl_taf = avwx.Taf('PHNL')
>>> hnl_taf.update()
True
>>> hnl_taf.raw
'PHNL 312058Z 3121/0124 07012G19KT P6SM FEW030 SCT050 FM010500 06007KT P6SM FEW025 SCT045 FM012000 07012G19KT P6SM OVC030 SCT050'
>>> len(hnl_taf.data.forecast)
3
>>> for line in hnl_taf.data.forecast:
...   print(f"{line.flight_rules} from {line.start_time.dt.strftime('%d-%H:%M')} to {line.end_time.dt.strftime('%d-%H:%M')}")
... 
VFR from 31-21:00 to 01-05:00
VFR from 01-05:00 to 01-20:00
MVFR from 01-20:00 to 01-24:00

```

--------------------------------

### SourceError

Source: https://engine.avwx.rest/avwx/exceptions.html

Source servers returned an error code.

```python
18class SourceError(Exception):
19    """Source servers returned an error code."""

```

--------------------------------

### Mex Class Usage Example

Source: https://engine.avwx.rest/avwx/forecast/gfs.html

Example of how to instantiate the Mex class to fetch and pull MAV data for a station.

```python
>>> from avwx import Mex
>>> kjfk = Mex("KJFK")
>>> kjfk.station.name
```
Tokens:
Raw