os-normalizer 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

os_normalizer/constants.py

@@ -1,19 +1,156 @@
 """Constants and static lookup tables for the OS fingerprinting package."""
 
+from enum import StrEnum
+
+
+class OSFamily(StrEnum):
+    """Canonical OS family identifiers used throughout the project."""
+
+    ANDROID = "android"
+    BSD = "bsd"
+    ESXI = "esxi"
+    HARMONYOS = "harmonyos"
+    IOS = "ios"
+    LINUX = "linux"
+    MACOS = "macos"
+    NETWORK = "network-os"
+    SOLARIS = "solaris"
+    WINDOWS = "windows"
+
+
+class PrecisionLevel(StrEnum):
+    """Granularity levels for parsed OS version information."""
+
+    UNKNOWN = "unknown"
+    FAMILY = "family"
+    PRODUCT = "product"
+    MAJOR = "major"
+    MINOR = "minor"
+    PATCH = "patch"
+    BUILD = "build"
+
+
+PRECISION_ORDER = {
+    PrecisionLevel.BUILD: 6,
+    PrecisionLevel.PATCH: 5,
+    PrecisionLevel.MINOR: 4,
+    PrecisionLevel.MAJOR: 3,
+    PrecisionLevel.PRODUCT: 2,
+    PrecisionLevel.FAMILY: 1,
+    PrecisionLevel.UNKNOWN: 0,
+}
+
+
+# Architecture tokens recognised across parsers.
+ARCHITECTURE_TOKENS = (
+    "x86_64",
+    "amd64",
+    "x64",
+    "x86",
+    "ia32",
+    "i386",
+    "i486",
+    "i586",
+    "i686",
+    "arm64",
+    "aarch64",
+    "arm64e",
+    "armv8",
+    "armv8l",
+    "arm",
+    "armv7",
+    "armv7l",
+    "armv7hf",
+    "armv6",
+    "armhf",
+    "armel",
+    "ppc64le",
+    "powerpc64le",
+    "ppc64",
+    "powerpc64",
+    "ppc",
+    "ppc32",
+    "ppcle",
+    "powerpc",
+    "sparc",
+    "sparc64",
+    "sparcv9",
+    "sun4u",
+    "sun4v",
+    "mips",
+    "mips32",
+    "mipsel",
+    "mips64",
+    "mips64el",
+    "mips64le",
+    "s390x",
+    "s390",
+    "riscv64",
+    "riscv",
+    "loongarch64",
+    "tilegx",
+    "alpha",
+    "ia64",
+    "itanium",
+    "hppa",
+    "parisc",
+    "m68k",
+)
+
 # Architecture synonyms
 ARCH_SYNONYMS = {
-    "x64": "x86_64",
     "x86_64": "x86_64",
     "amd64": "x86_64",
+    "x64": "x86_64",
     "x86": "x86",
+    "ia32": "x86",
     "i386": "x86",
+    "i486": "x86",
+    "i586": "x86",
     "i686": "x86",
-    "aarch64": "arm64",
     "arm64": "arm64",
+    "aarch64": "arm64",
+    "arm64e": "arm64",
     "armv8": "arm64",
+    "armv8l": "arm64",
+    "arm": "arm",
     "armv7": "arm",
     "armv7l": "arm",
+    "armv7hf": "arm",
+    "armv6": "arm",
+    "armhf": "arm",
+    "armel": "arm",
     "ppc64le": "ppc64le",
+    "powerpc64le": "ppc64le",
+    "ppc64": "ppc64",
+    "powerpc64": "ppc64",
+    "ppc": "ppc",
+    "ppc32": "ppc",
+    "ppcle": "ppc",
+    "powerpc": "ppc",
+    "sparc": "sparc",
+    "sparc64": "sparc",
+    "sparcv9": "sparc",
+    "sun4u": "sparc",
+    "sun4v": "sparc",
+    "mips": "mips",
+    "mips32": "mips",
+    "mipsel": "mips",
+    "mips64": "mips64",
+    "mips64el": "mips64",
+    "mips64le": "mips64",
+    "s390x": "s390x",
+    "s390": "s390x",
+    "riscv64": "riscv64",
+    "riscv": "riscv64",
+    "loongarch64": "loongarch64",
+    "tilegx": "tilegx",
+    "alpha": "alpha",
+    "ia64": "ia64",
+    "itanium": "ia64",
+    "hppa": "parisc",
+    "parisc": "parisc",
+    "m68k": "m68k",
 }
 
 # Windows build map (build number range -> product name, marketing channel)

os_normalizer/cpe.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from os_normalizer.constants import WINDOWS_BUILD_MAP
+from os_normalizer.constants import OSFamily, WINDOWS_BUILD_MAP
 
 if TYPE_CHECKING:
     from .models import OSData
@@ -39,12 +39,19 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
 
     strategy controls version/update selection rules.
     """
-    fam = (p.family or "").lower()
+    raw_family = p.family
+    family = (
+        raw_family
+        if isinstance(raw_family, OSFamily)
+        else OSFamily._value2member_map_.get(str(raw_family).lower())
+        if raw_family
+        else None
+    )
     vendor = (p.vendor or "").lower() if p.vendor else None
     product = (p.product or "").lower() if p.product else ""
 
     # Windows
-    if fam == "windows":
+    if family == OSFamily.WINDOWS:
         vtok = "microsoft"
         prod_map = {
             "windows 7": "windows_7",
@@ -68,11 +75,11 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
         return vtok, base, "windows"
 
     # macOS
-    if fam == "macos":
+    if family == OSFamily.MACOS:
         return "apple", "macos", "macos"
 
     # Linux distros (use distro when present)
-    if fam == "linux":
+    if family == OSFamily.LINUX:
         d = (p.distro or "").lower()
         if d == "ubuntu":
             return "canonical", "ubuntu_linux", "ubuntu"
@@ -93,7 +100,7 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
         return vendor or "linux", product or "linux", "linux"
 
     # BSDs
-    if fam == "bsd":
+    if family == OSFamily.BSD:
         if product and "freebsd" in product:
             return "freebsd", "freebsd", "freebsd"
         if product and "openbsd" in product:
@@ -102,8 +109,14 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
             return "netbsd", "netbsd", "netbsd"
         return vendor or "bsd", product or "bsd", "bsd"
 
+    if family == OSFamily.SOLARIS:
+        return "oracle", "solaris", "solaris"
+
+    if family == OSFamily.ESXI:
+        return "vmware", "esxi", "esxi"
+
     # Network OS
-    if fam == "network-os":
+    if family == OSFamily.NETWORK:
         if vendor == "cisco":
             if product and ("ios xe" in product or "ios-xe" in product):
                 return "cisco", "ios_xe", "ios_xe"
@@ -120,13 +133,20 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
         return vendor or "network", (product or "firmware").replace(" ", "_"), "firmware"
 
     # Mobile
-    if fam == "android":
-        return "google", "android", "android"
-    if fam == "ios":
-        return "apple", "iphone_os", "ios"
+    if family == OSFamily.ANDROID:
+        return "google", "android", OSFamily.ANDROID.value
+    if family == OSFamily.IOS:
+        return "apple", "iphone_os", OSFamily.IOS.value
+    if family == OSFamily.HARMONYOS:
+        return "huawei", "harmonyos", OSFamily.HARMONYOS.value
 
     # Fallback
-    return (vendor or fam or "unknown"), (product or (fam or "unknown")).replace(" ", "_"), fam or "unknown"
+    family_value = family.value if family else (str(raw_family).lower() if raw_family else "unknown")
+    return (
+        vendor or family_value or "unknown",
+        (product or family_value).replace(" ", "_"),
+        family_value,
+    )
 
 
 def _fmt_version(p: OSData, strategy: str) -> tuple[str, str, str]:
@@ -192,6 +212,18 @@ def _fmt_version(p: OSData, strategy: str) -> tuple[str, str, str]:
             ver = "*"
         return ver, "*", (edition or "*")
 
+    if strategy in ("solaris", "esxi"):
+        if maj is not None:
+            ver = str(maj)
+            if minr is not None:
+                ver = f"{ver}.{minr}"
+                if pat is not None:
+                    ver = f"{ver}.{pat}"
+        else:
+            ver = "*"
+        update = build or "*"
+        return ver, update, "*"
+
     if strategy == "fortios":
         if maj is not None and minr is not None and pat is not None:
             ver = f"{maj}.{minr}.{pat}"
@@ -216,6 +248,19 @@ def _fmt_version(p: OSData, strategy: str) -> tuple[str, str, str]:
             ver = "*"
         return ver, "*", "*"
 
+    if strategy == "harmonyos":
+        if maj is not None:
+            if minr is not None and pat is not None:
+                ver = f"{maj}.{minr}.{pat}"
+            elif minr is not None:
+                ver = f"{maj}.{minr}"
+            else:
+                ver = f"{maj}"
+        else:
+            ver = "*"
+        update = build or "*"
+        return ver, update, "*"
+
     # Generic fallback
     if build:
         ver = build

os_normalizer/helpers.py

@@ -3,7 +3,7 @@
 import re
 from typing import Any
 
-from .constants import ARCH_SYNONYMS
+from .constants import ARCH_SYNONYMS, ARCHITECTURE_TOKENS, PrecisionLevel
 from .models import OSData
 
 
@@ -34,17 +34,17 @@ def precision_from_parts(
     minor: int | None,
     patch: int | None,
     build: str | None,
-) -> str:
+) -> PrecisionLevel:
     """Derive a precision label from version components."""
     if build:
-        return "build"
+        return PrecisionLevel.BUILD
     if patch is not None:
-        return "patch"
+        return PrecisionLevel.PATCH
     if minor is not None:
-        return "minor"
+        return PrecisionLevel.MINOR
     if major is not None:
-        return "major"
-    return "product"
+        return PrecisionLevel.MAJOR
+    return PrecisionLevel.PRODUCT
 
 
 def canonical_key(p: OSData) -> str:
@@ -61,7 +61,10 @@ def canonical_key(p: OSData) -> str:
 
 
 # Regex for extracting an architecture token from free-form text
-ARCH_TEXT_RE = re.compile(r"\b(x86_64|amd64|x64|x86|i386|i686|arm64|aarch64|armv8|armv7l?|ppc64le)\b", re.IGNORECASE)
+_ARCH_PATTERN = "|".join(
+    sorted((re.escape(token) for token in ARCHITECTURE_TOKENS), key=len, reverse=True)
+)
+ARCH_TEXT_RE = re.compile(rf"\b({_ARCH_PATTERN})\b", re.IGNORECASE)
 
 
 def extract_arch_from_text(text: str) -> str | None:
@@ -92,16 +95,24 @@ def parse_os_release(blob_text: str) -> dict[str, Any]:
     return out
 
 
-def update_confidence(p: OSData, precision: str) -> None:
+def update_confidence(p: OSData, precision: PrecisionLevel | str) -> None:
     """Boost confidence based on the determined precision level.
 
     The mapping mirrors the original ad-hoc values used throughout the monolithic file.
     """
+    if isinstance(precision, PrecisionLevel):
+        level = precision
+    else:
+        try:
+            level = PrecisionLevel(str(precision))
+        except ValueError:
+            level = PrecisionLevel.UNKNOWN
+
     boost_map = {
-        "build": 0.85,
-        "patch": 0.80,
-        "minor": 0.75,
-        "major": 0.70,
-        "product": 0.60,
+        PrecisionLevel.BUILD: 0.85,
+        PrecisionLevel.PATCH: 0.80,
+        PrecisionLevel.MINOR: 0.75,
+        PrecisionLevel.MAJOR: 0.70,
+        PrecisionLevel.PRODUCT: 0.60,
     }
-    p.confidence = max(p.confidence, boost_map.get(precision, 0.5))
+    p.confidence = max(p.confidence, boost_map.get(level, 0.5))

os_normalizer/models.py

@@ -2,16 +2,20 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field, fields as dataclass_fields
+from dataclasses import dataclass, field
+from dataclasses import fields as dataclass_fields
+from enum import Enum
 from typing import Any
 
+from .constants import OSFamily, PrecisionLevel
+
 
 @dataclass
 class OSData:
     """Structured representation of a parsed operating system."""
 
     # Core identity
-    family: str | None = None  # windows, linux, macos, ios, android, bsd, network-os
+    family: OSFamily | None = None  # windows, linux, macos, ios, android, bsd, solaris, esxi, network-os
     vendor: str | None = None  # Microsoft, Apple, Canonical, Cisco, Juniper, Fortinet, Huawei, Netgear…
     product: str | None = None  # Windows 11, Ubuntu, macOS, IOS XE, Junos, FortiOS, VRP, Firmware
     edition: str | None = None  # Pro/Enterprise/LTSC; universalk9/ipbase; etc.
@@ -37,7 +41,7 @@ class OSData:
     build_id: str | None = None
 
     # Meta information
-    precision: str = "unknown"  # family|product|major|minor|patch|build
+    precision: PrecisionLevel = PrecisionLevel.UNKNOWN  # family|product|major|minor|patch|build
     confidence: float = 0.0
     evidence: dict[str, Any] = field(default_factory=dict)
 
@@ -47,7 +51,7 @@ class OSData:
     def __str__(self) -> str:  # pragma: no cover - formatting helper
         parts: list[str] = []
 
-        if self.family == "windows":
+        if self.family == OSFamily.WINDOWS:
             return _format_windows(self)
 
         # Prefer vendor + product; fallback to pretty_name; then family
@@ -57,7 +61,10 @@ class OSData:
         elif self.pretty_name:
             parts.append(self.pretty_name)
         else:
-            parts.append(self.family or "Unknown OS")
+            if isinstance(self.family, OSFamily):
+                parts.append(self.family.value)
+            else:
+                parts.append(self.family or "Unknown OS")
 
         # Version string (major[.minor[.patch]]) and optional build
         ver_chunks: list[str] = []
@@ -100,8 +107,9 @@ class OSData:
             parts.append(f"[build: {self.build_id}]")
 
         # Precision/confidence summary
-        if self.precision and self.precision != "unknown":
-            parts.append(f"{{{self.precision}:{self.confidence:.2f}}}")
+        if self.precision and self.precision != PrecisionLevel.UNKNOWN:
+            label = self.precision.value if isinstance(self.precision, PrecisionLevel) else str(self.precision)
+            parts.append(f"{{{label}:{self.confidence:.2f}}}")
         elif self.confidence:
             parts.append(f"{{{self.confidence:.2f}}}")
 
@@ -129,6 +137,8 @@ class OSData:
                 sval = none_str
             elif name == "confidence" and isinstance(val, (int, float)):
                 sval = f"{float(val):.2f}"
+            elif isinstance(val, Enum):
+                sval = val.value
             elif isinstance(val, list):
                 sval = ", ".join(str(x) for x in val)
             elif isinstance(val, dict):
@@ -159,7 +169,7 @@ def _format_windows(p: OSData) -> str:
 
 if __name__ == "__main__":
     x = OSData(
-        family="linux",
+        family=OSFamily.LINUX,
         vendor="Fedora Project",
         product="Fedora Linux",
         version_major=33,
@@ -168,7 +178,7 @@ if __name__ == "__main__":
         distro="fedora",
         like_distros=[],
         pretty_name="Fedora Linux",
-        precision="major",
+        precision=PrecisionLevel.MAJOR,
         confidence=0.7,
         evidence={"hit": "linux"},
     )

os_normalizer/os_normalizer.py

@@ -1,35 +1,32 @@
-from datetime import UTC, datetime
-from typing import Any, Iterable
-from dataclasses import replace, fields
 import copy
+from collections.abc import Iterable
+from dataclasses import fields, replace
+from datetime import UTC, datetime
+from typing import Any
 
-from os_normalizer.helpers import extract_arch_from_text, precision_from_parts, update_confidence
+from os_normalizer.constants import PRECISION_ORDER, OSFamily, PrecisionLevel
 from os_normalizer.cpe import build_cpe23
+from os_normalizer.helpers import extract_arch_from_text, precision_from_parts, update_confidence
 from os_normalizer.models import OSData
 from os_normalizer.parsers.bsd import parse_bsd
+from os_normalizer.parsers.esxi import parse_esxi
 from os_normalizer.parsers.linux import parse_linux
 from os_normalizer.parsers.macos import parse_macos
 from os_normalizer.parsers.mobile import parse_mobile
 from os_normalizer.parsers.network import parse_network
+from os_normalizer.parsers.solaris import parse_solaris
 from os_normalizer.parsers.windows import parse_windows
 
-PRECISION_ORDER = {
-    "build": 6,
-    "patch": 5,
-    "minor": 4,
-    "major": 3,
-    "product": 2,
-    "family": 1,
-    "unknown": 0,
-}
-
 
 # ============================================================
 # Family detection (orchestrator logic)
 # ============================================================
-def detect_family(text: str, data: dict[str, Any]) -> tuple[str | None, float, dict[str, Any]]:
+def detect_family(text: str, data: dict[str, Any]) -> tuple[OSFamily | None, float, dict[str, Any]]:
     t = text.lower()
     ev = {}
+    if OSFamily.HARMONYOS.value in t:
+        ev["hit"] = OSFamily.HARMONYOS
+        return OSFamily.HARMONYOS, 0.6, ev
     # Obvious network signals first
     if any(
         x in t
@@ -48,35 +45,50 @@ def detect_family(text: str, data: dict[str, Any]) -> tuple[str | None, float, d
         ]
     ):
         # Special handling for 'ios' - if it's just 'ios' without 'cisco', treat as mobile, not network
-        if "ios " in t and "cisco" not in t:
-            ev["hit"] = "ios"
-            return "ios", 0.6, ev
-
-        ev["hit"] = "network-os"
-        return "network-os", 0.7, ev
+        if f"{OSFamily.IOS.value} " in t and "cisco" not in t:
+            ev["hit"] = OSFamily.IOS
+            return OSFamily.IOS, 0.6, ev
+
+        ev["hit"] = OSFamily.NETWORK
+        return OSFamily.NETWORK, 0.7, ev
+    # VMware ESXi
+    if "vmkernel" in t or "vmware esxi" in t or " esxi" in t or t.startswith("esxi"):
+        ev["hit"] = OSFamily.ESXI
+        return OSFamily.ESXI, 0.65, ev
+    # Solaris / SunOS
+    if "sunos" in t or "solaris" in t:
+        ev["hit"] = OSFamily.SOLARIS
+        return OSFamily.SOLARIS, 0.65, ev
     # Linux
-    if "linux" in t or any(k in data for k in ("ID", "ID_LIKE", "PRETTY_NAME", "VERSION_ID", "VERSION_CODENAME")):
-        ev["hit"] = "linux"
-        return "linux", 0.6, ev
+    if OSFamily.LINUX.value in t or any(
+        k in data for k in ("ID", "ID_LIKE", "PRETTY_NAME", "VERSION_ID", "VERSION_CODENAME")
+    ):
+        ev["hit"] = OSFamily.LINUX
+        return OSFamily.LINUX, 0.6, ev
     # Windows
-    if "windows" in t or "nt " in t or t.startswith("win") or data.get("os", "").lower() == "windows":
-        ev["hit"] = "windows"
-        return "windows", 0.6, ev
+    if (
+        OSFamily.WINDOWS.value in t
+        or "nt " in t
+        or t.startswith("win")
+        or data.get("os", "").lower() == OSFamily.WINDOWS.value
+    ):
+        ev["hit"] = OSFamily.WINDOWS
+        return OSFamily.WINDOWS, 0.6, ev
     # Apple
-    if "macos" in t or "os x" in t or "darwin" in t:
-        ev["hit"] = "macos"
-        return "macos", 0.6, ev
-    if "ios" in t or "ipados" in t:
-        ev["hit"] = "ios"
-        return "ios", 0.6, ev
+    if OSFamily.MACOS.value in t or "os x" in t or "darwin" in t:
+        ev["hit"] = OSFamily.MACOS
+        return OSFamily.MACOS, 0.6, ev
+    if OSFamily.IOS.value in t or "ipados" in t:
+        ev["hit"] = OSFamily.IOS
+        return OSFamily.IOS, 0.6, ev
     # Android
-    if "android" in t:
-        ev["hit"] = "android"
-        return "android", 0.6, ev
+    if OSFamily.ANDROID.value in t:
+        ev["hit"] = OSFamily.ANDROID
+        return OSFamily.ANDROID, 0.6, ev
     # BSD
     if "freebsd" in t or "openbsd" in t or "netbsd" in t:
-        ev["hit"] = "bsd"
-        return "bsd", 0.6, ev
+        ev["hit"] = OSFamily.BSD
+        return OSFamily.BSD, 0.6, ev
     return None, 0.0, ev
 
 
@@ -93,20 +105,24 @@ def normalize_os(text: str, data: dict | None = None) -> OSData:
     p.confidence = max(p.confidence, base_conf)
     p.evidence.update(ev)
 
-    if fam == "network-os":
+    if fam == OSFamily.NETWORK:
         p = parse_network(text, data, p)
-    elif fam == "windows":
+    elif fam == OSFamily.WINDOWS:
         p = parse_windows(text, data, p)
-    elif fam == "macos":
+    elif fam == OSFamily.MACOS:
         p = parse_macos(text, data, p)
-    elif fam == "linux":
+    elif fam == OSFamily.LINUX:
         p = parse_linux(text, data, p)
-    elif fam in ("android", "ios"):
+    elif fam == OSFamily.SOLARIS:
+        p = parse_solaris(text, data, p)
+    elif fam == OSFamily.ESXI:
+        p = parse_esxi(text, data, p)
+    elif fam in (OSFamily.ANDROID, OSFamily.IOS, OSFamily.HARMONYOS):
         p = parse_mobile(text, data, p)
-    elif fam == "bsd":
+    elif fam == OSFamily.BSD:
         p = parse_bsd(text, data, p)
     else:
-        p.precision = "unknown"
+        p.precision = PrecisionLevel.UNKNOWN
 
     # Fallback arch from text if not already set elsewhere
     if not p.arch:
@@ -127,7 +143,7 @@ def choose_best_fact(candidates: list[OSData]) -> OSData:
         raise ValueError("No candidates")
     return sorted(
         candidates,
-        key=lambda c: (PRECISION_ORDER.get(c.precision, 0), c.confidence),
+        key=lambda c: (PRECISION_ORDER.get(_ensure_precision_enum(c.precision), 0), c.confidence),
         reverse=True,
     )[0]
 
@@ -138,7 +154,18 @@ def choose_best_fact(candidates: list[OSData]) -> OSData:
 
 
 def _score(p: OSData) -> tuple[int, float]:
-    return (PRECISION_ORDER.get(p.precision, 0), p.confidence)
+    return (PRECISION_ORDER.get(_ensure_precision_enum(p.precision), 0), p.confidence)
+
+
+def _ensure_precision_enum(value: PrecisionLevel | str | None) -> PrecisionLevel:
+    if isinstance(value, PrecisionLevel):
+        return value
+    if value is None:
+        return PrecisionLevel.UNKNOWN
+    try:
+        return PrecisionLevel(str(value))
+    except ValueError:
+        return PrecisionLevel.UNKNOWN
 
 
 def _union_unique(values: Iterable[str]) -> list[str]:
@@ -227,8 +254,8 @@ def merge_os(a: OSData, b: OSData, policy: str = "auto") -> OSData:
 
     # Precision & confidence: recompute based on version parts
     new_prec = precision_from_parts(r.version_major, r.version_minor, r.version_patch, r.version_build)
-    if new_prec == "product" and not r.product:
-        new_prec = "family" if r.family else "unknown"
+    if new_prec == PrecisionLevel.PRODUCT and not r.product:
+        new_prec = PrecisionLevel.FAMILY if r.family else PrecisionLevel.UNKNOWN
     r.precision = new_prec
     r.confidence = max(a.confidence, b.confidence)
     update_confidence(r, r.precision)

os_normalizer/parsers/__init__.py

@@ -1,15 +1,19 @@
-from .windows import parse_windows
-from .macos import parse_macos
+from .bsd import parse_bsd
+from .esxi import parse_esxi
 from .linux import parse_linux
+from .macos import parse_macos
 from .mobile import parse_mobile
-from .bsd import parse_bsd
 from .network import parse_network
+from .solaris import parse_solaris
+from .windows import parse_windows
 
 __all__ = [
     "parse_bsd",
+    "parse_esxi",
     "parse_linux",
     "parse_macos",
     "parse_mobile",
     "parse_network",
+    "parse_solaris",
     "parse_windows",
 ]