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

os_normalizer/parsers/bsd.py

@@ -3,6 +3,7 @@
 import re
 from typing import Any
 
+from os_normalizer.constants import PrecisionLevel
 from os_normalizer.helpers import (
     parse_semver_like,
     precision_from_parts,
@@ -48,7 +49,7 @@ def parse_bsd(text: str, data: dict[str, Any], p: OSData) -> OSData:
     # Prefer variant-anchored version pattern; fall back to generic semver
     x, y, z = _extract_version(text)
     p.version_major, p.version_minor, p.version_patch = x, y, z
-    p.precision = precision_from_parts(x, y, z, None) if x else "product"
+    p.precision = precision_from_parts(x, y, z, None) if x else PrecisionLevel.PRODUCT
 
     # Channel from explicit markers/suffixes
     ch = BSD_CHANNEL_RE.search(text)

os_normalizer/parsers/esxi.py

@@ -0,0 +1,83 @@
+"""VMware ESXi specific parsing logic."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from os_normalizer.constants import PrecisionLevel
+from os_normalizer.helpers import parse_semver_like, precision_from_parts, update_confidence
+from os_normalizer.models import OSData
+
+ESXI_PRODUCT_RE = re.compile(
+    r"VMware\s+ESXi\s+(\d+(?:\.\d+){1,3})(?:\s+(?:build|Build)\s*[-#]?(\d+))?",
+    re.IGNORECASE,
+)
+VMKERNEL_RE = re.compile(
+    r"VMkernel\s+\S+\s+(\d+(?:\.\d+){1,3})(?:\s+#(\d+))?",
+    re.IGNORECASE,
+)
+ESXCLI_VERSION_RE = re.compile(r"^Version:\s*(\d+(?:\.\d+){1,3})\s*$", re.IGNORECASE | re.MULTILINE)
+ESXCLI_BUILD_RE = re.compile(r"^Build:\s*(\d+)\s*$", re.IGNORECASE | re.MULTILINE)
+ESXCLI_UPDATE_RE = re.compile(r"^Update:\s*(.+?)\s*$", re.IGNORECASE | re.MULTILINE)
+
+
+def parse_esxi(text: str, data: dict[str, Any], p: OSData) -> OSData:
+    """Populate an OSData instance with ESXi-specific details."""
+    p.vendor = p.vendor or "VMware"
+    p.product = p.product or "VMware ESXi"
+    p.kernel_name = "vmkernel"
+
+    version: str | None = None
+    build: str | None = None
+    channel: str | None = None
+
+    prod_match = ESXI_PRODUCT_RE.search(text)
+    if prod_match:
+        version = prod_match.group(1)
+        build = prod_match.group(2) or build
+
+    kernel_match = VMKERNEL_RE.search(text)
+    if kernel_match:
+        version = version or kernel_match.group(1)
+        build = build or kernel_match.group(2)
+
+    version_line = ESXCLI_VERSION_RE.search(text)
+    if version_line and not version:
+        version = version_line.group(1)
+
+    build_line = ESXCLI_BUILD_RE.search(text)
+    if build_line and not build:
+        build = build_line.group(1)
+
+    update_line = ESXCLI_UPDATE_RE.search(text)
+    if update_line:
+        channel = update_line.group(1).strip()
+
+    if build:
+        p.version_build = build
+
+    if channel:
+        # Normalise "3" -> "Update 3", but keep existing text if already descriptive
+        if channel.isdigit():
+            p.channel = f"Update {channel}"
+        elif channel.lower().startswith("update"):
+            p.channel = channel
+        else:
+            p.channel = channel
+
+    if version:
+        p.kernel_version = version
+        major, minor, patch = parse_semver_like(version)
+        if major is not None:
+            p.version_major = major
+        if minor is not None:
+            p.version_minor = minor
+        if patch is not None:
+            p.version_patch = patch
+        p.precision = precision_from_parts(p.version_major, p.version_minor, p.version_patch, p.version_build)
+    else:
+        p.precision = PrecisionLevel.PRODUCT
+
+    update_confidence(p, p.precision)
+    return p

os_normalizer/parsers/linux.py

@@ -3,6 +3,7 @@
 import re
 from typing import Any, Optional
 
+from os_normalizer.constants import PrecisionLevel
 from os_normalizer.helpers import parse_os_release, update_confidence
 from os_normalizer.models import OSData
 
@@ -31,7 +32,7 @@ def parse_linux(text: str, data: dict[str, Any], p: OSData) -> OSData:
         _apply_os_release(osrel, p)
     else:
         p.product = p.product or "Linux"
-        p.precision = "family"
+        p.precision = PrecisionLevel.FAMILY
 
     update_confidence(p, p.precision)
     return p
@@ -92,13 +93,13 @@ def _apply_os_release(osrel: dict[str, Any], p: OSData) -> None:
 
     # Precision from version parts
     if p.version_patch is not None:
-        p.precision = "patch"
+        p.precision = PrecisionLevel.PATCH
     elif p.version_minor is not None:
-        p.precision = "minor"
+        p.precision = PrecisionLevel.MINOR
     elif p.version_major is not None:
-        p.precision = "major"
+        p.precision = PrecisionLevel.MAJOR
     else:
-        p.precision = "family"
+        p.precision = PrecisionLevel.FAMILY
 
 
 def _apply_version_id(vid: Any, p: OSData) -> None:

os_normalizer/parsers/macos.py

@@ -3,7 +3,7 @@
 import re
 from typing import Any
 
-from os_normalizer.constants import MACOS_ALIASES, MACOS_DARWIN_MAP
+from os_normalizer.constants import MACOS_ALIASES, MACOS_DARWIN_MAP, PRECISION_ORDER, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -14,10 +14,6 @@ DARWIN_RE = re.compile(
 )
 MACOS_VER_FALLBACK_RE = re.compile(r"\bmacos\s?(\d+)(?:\.(\d+))?", re.IGNORECASE)
 
-# Local precision order for simple comparisons
-_PRECISION_ORDER = {"family": 0, "product": 1, "major": 2, "minor": 3, "patch": 4, "build": 5}
-
-
 def parse_macos(text: str, data: dict[str, Any], p: OSData) -> OSData:
     """Populate an OSData instance with macOS-specific details."""
     t = text
@@ -50,7 +46,7 @@ def _apply_alias_hint(tl: str, p: OSData) -> None:
             parts = normalized.split()
             if len(parts) == 2 and parts[1].isdigit():
                 p.version_major = int(parts[1])
-                p.precision = _max_precision(p.precision, "major")
+                p.precision = _max_precision(p.precision, PrecisionLevel.MAJOR)
 
 
 def _apply_darwin_mapping(t: str, p: OSData) -> None:
@@ -66,12 +62,12 @@ def _apply_darwin_mapping(t: str, p: OSData) -> None:
         p.product = prod
         if ver.isdigit():
             p.version_major = int(ver)
-            p.precision = _max_precision(p.precision, "major")
+            p.precision = _max_precision(p.precision, PrecisionLevel.MAJOR)
         else:
             x, y, *_ = ver.split(".")
             p.version_major = int(x)
             p.version_minor = int(y)
-            p.precision = _max_precision(p.precision, "minor")
+            p.precision = _max_precision(p.precision, PrecisionLevel.MINOR)
         p.codename = code
 
 
@@ -84,9 +80,9 @@ def _apply_version_fallback(t: str, p: OSData) -> None:
     p.version_major = int(mm.group(1))
     if mm.group(2):
         p.version_minor = int(mm.group(2))
-        p.precision = _max_precision(p.precision, "minor")
+        p.precision = _max_precision(p.precision, PrecisionLevel.MINOR)
     else:
-        p.precision = _max_precision(p.precision, "major")
+        p.precision = _max_precision(p.precision, PrecisionLevel.MAJOR)
 
 
 def _apply_codename_fallback(tl: str, p: OSData) -> None:
@@ -98,14 +94,16 @@ def _apply_codename_fallback(tl: str, p: OSData) -> None:
             # Provide at least major version from the map
             if isinstance(ver, str) and ver.isdigit():
                 p.version_major = int(ver)
-                p.precision = _max_precision(p.precision, "major")
+                p.precision = _max_precision(p.precision, PrecisionLevel.MAJOR)
             elif isinstance(ver, str) and "." in ver:
                 x, *_ = ver.split(".")
                 if x.isdigit():
                     p.version_major = int(x)
-                    p.precision = _max_precision(p.precision, "major")
+                    p.precision = _max_precision(p.precision, PrecisionLevel.MAJOR)
             break
 
 
-def _max_precision(current: str, new_label: str) -> str:
-    return new_label if _PRECISION_ORDER.get(new_label, 0) > _PRECISION_ORDER.get(current, 0) else current
+def _max_precision(current: PrecisionLevel, new_label: PrecisionLevel) -> PrecisionLevel:
+    if not isinstance(current, PrecisionLevel):
+        current = PrecisionLevel(current)
+    return new_label if PRECISION_ORDER.get(new_label, 0) > PRECISION_ORDER.get(current, 0) else current

os_normalizer/parsers/mobile.py

@@ -1,7 +1,9 @@
 """Mobile device specific parsing logic."""
 
+import re
 from typing import Any
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.helpers import (
     parse_semver_like,
     precision_from_parts,
@@ -14,11 +16,21 @@ def parse_mobile(text: str, data: dict[str, Any], p: OSData) -> OSData:
     """Populate an OSData instance with mobile device-specific details."""
     t = text.lower()
 
+    # Detect if it's HarmonyOS before other mobile platforms to avoid vendor overlaps
+    if OSFamily.HARMONYOS.value in t:
+        p.product = "HarmonyOS"
+        p.vendor = "Huawei"
+        m = re.search(r"\b(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?\b", text)
+        if m:
+            p.version_major = int(m.group(1))
+            p.version_minor = int(m.group(2)) if m.group(2) else None
+            p.version_patch = int(m.group(3)) if m.group(3) else None
+            p.version_build = m.group(4) if m.group(4) else None
     # Detect if it's iOS or Android
-    if "ios" in t or "ipados" in t:
+    elif OSFamily.IOS.value in t or "ipados" in t:
         p.product = "iOS/iPadOS"
         p.vendor = "Apple"
-    elif "android" in t:
+    elif OSFamily.ANDROID.value in t:
         p.product = "Android"
         p.vendor = "Google"
     else:
@@ -27,9 +39,15 @@ def parse_mobile(text: str, data: dict[str, Any], p: OSData) -> OSData:
         p.vendor = None
 
     # Extract version info using semver-like parsing
-    x, y, z = parse_semver_like(t)
-    p.version_major, p.version_minor, p.version_patch = x, y, z
-    p.precision = precision_from_parts(x, y, z, None) if x else "product"
+    if p.version_major is None:
+        x, y, z = parse_semver_like(t)
+        p.version_major, p.version_minor, p.version_patch = x, y, z
+
+    p.precision = (
+        precision_from_parts(p.version_major, p.version_minor, p.version_patch, p.version_build)
+        if p.version_major is not None
+        else PrecisionLevel.PRODUCT
+    )
 
     # Boost confidence based on precision
     update_confidence(p, p.precision)

os_normalizer/parsers/network/__init__.py

@@ -15,6 +15,7 @@ from .fortinet import FORTI_RE, parse_fortinet
 from .huawei import HUAWEI_RE, parse_huawei
 from .netgear import NETGEAR_RE, parse_netgear
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.models import OSData
 
 __all__ = [
@@ -57,5 +58,8 @@ def parse_network(text: str, data: dict | None, p: OSData) -> OSData:
     # Unknown network vendor; keep coarse
     p.vendor = p.vendor or "Unknown-Network"
     p.product = p.product or "Network OS"
-    p.precision = "family"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
+    p.precision = PrecisionLevel.FAMILY
     return p

os_normalizer/parsers/network/cisco.py

@@ -2,6 +2,7 @@
 
 import re
 
+from os_normalizer.constants import CISCO_TRAIN_NAMES, OSFamily, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -26,7 +27,9 @@ CISCO_EDITION_RE = re.compile(
 
 def parse_cisco(text: str, p: OSData) -> OSData:
     p.vendor = "Cisco"
-    p.family = p.family or "network-os"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
 
     # Detect product line
     if CISCO_IOS_XE_RE.search(text):
@@ -53,14 +56,16 @@ def parse_cisco(text: str, p: OSData) -> OSData:
                 p.version_patch = int(num[2])
             p.version_build = ver
             p.precision = (
-                "patch" if p.version_patch is not None else ("minor" if p.version_minor is not None else "major")
+                PrecisionLevel.PATCH
+                if p.version_patch is not None
+                else (PrecisionLevel.MINOR if p.version_minor is not None else PrecisionLevel.MAJOR)
             )
 
     # Image filename
     img = CISCO_IMAGE_RE.search(text)
     if img:
         p.build_id = img.group(1)
-        p.precision = "build"
+        p.precision = PrecisionLevel.BUILD
 
     # If NX-OS and only got version via filename, parse nxos.A.B.C.bin
     if not p.version_major and p.build_id:
@@ -70,7 +75,7 @@ def parse_cisco(text: str, p: OSData) -> OSData:
             p.version_minor = int(m.group(2))
             p.version_patch = int(m.group(3))
             p.version_build = f"{p.version_major}.{p.version_minor}.{p.version_patch}"
-            p.precision = "patch"
+            p.precision = PrecisionLevel.PATCH
 
     # Model
     mm = CISCO_MODEL_RE.search(text)
@@ -83,8 +88,6 @@ def parse_cisco(text: str, p: OSData) -> OSData:
         p.edition = fl.group(1).lower()
 
     # Train codename
-    from os_normalizer.constants import CISCO_TRAIN_NAMES
-
     tl = text.lower()
     for train in CISCO_TRAIN_NAMES:
         if train.lower() in tl:
@@ -92,5 +95,8 @@ def parse_cisco(text: str, p: OSData) -> OSData:
             break
 
     # Boost confidence based on precision
-    update_confidence(p, p.precision if p.precision in ("build", "patch") else "minor")
+    update_confidence(
+        p,
+        p.precision if p.precision in (PrecisionLevel.BUILD, PrecisionLevel.PATCH) else PrecisionLevel.MINOR,
+    )
     return p

os_normalizer/parsers/network/fortinet.py

@@ -2,6 +2,7 @@
 
 import re
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -16,7 +17,9 @@ FORTI_CHANNEL_RE = re.compile(r"\((GA|Patch|Beta)\)", re.IGNORECASE)
 def parse_fortinet(text: str, p: OSData) -> OSData:
     p.vendor = "Fortinet"
     p.product = "FortiOS"
-    p.family = p.family or "network-os"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
     p.kernel_name = "fortios"
 
     ver = FORTI_VER_RE.search(text)
@@ -30,17 +33,21 @@ def parse_fortinet(text: str, p: OSData) -> OSData:
         if len(nums) >= 3:
             p.version_patch = int(nums[2])
         p.version_build = v
-        p.precision = "patch" if p.version_patch is not None else ("minor" if p.version_minor is not None else "major")
+        p.precision = (
+            PrecisionLevel.PATCH
+            if p.version_patch is not None
+            else (PrecisionLevel.MINOR if p.version_minor is not None else PrecisionLevel.MAJOR)
+        )
 
     bld = FORTI_BUILD_RE.search(text)
     if bld:
         p.version_build = (p.version_build or "") + f"+build.{bld.group(1)}"
-        p.precision = "build"
+        p.precision = PrecisionLevel.BUILD
 
     img = FORTI_IMG_RE.search(text)
     if img:
         p.build_id = img.group(1)
-        p.precision = "build"
+        p.precision = PrecisionLevel.BUILD
 
     mdl = FORTI_MODEL_RE.search(text)
     if mdl:
@@ -50,5 +57,8 @@ def parse_fortinet(text: str, p: OSData) -> OSData:
     if ch:
         p.channel = ch.group(1).upper()
 
-    update_confidence(p, p.precision if p.precision in ("build", "patch") else "minor")
+    update_confidence(
+        p,
+        p.precision if p.precision in (PrecisionLevel.BUILD, PrecisionLevel.PATCH) else PrecisionLevel.MINOR,
+    )
     return p

os_normalizer/parsers/network/huawei.py

@@ -2,6 +2,7 @@
 
 import re
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -14,7 +15,9 @@ HUAWEI_MODEL_RE = re.compile(r"\b(S\d{4}-\d{2}[A-Z-]+|CE\d{4}[A-Z-]*|AR\d{3,4}[A
 def parse_huawei(text: str, p: OSData) -> OSData:
     p.vendor = "Huawei"
     p.product = "VRP"
-    p.family = p.family or "network-os"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
     p.kernel_name = "vrp"
 
     raw = HUAWEI_RAWVER_RE.search(text)
@@ -26,7 +29,7 @@ def parse_huawei(text: str, p: OSData) -> OSData:
         maj, r, _c = vm.group(1), vm.group(2), vm.group(3)
         p.version_major = int(maj)
         p.version_minor = int(r)
-        p.precision = "minor"
+        p.precision = PrecisionLevel.MINOR
 
     mdl = HUAWEI_MODEL_RE.search(text)
     if mdl:
@@ -34,5 +37,8 @@ def parse_huawei(text: str, p: OSData) -> OSData:
 
     p.build_id = p.version_build or p.build_id
 
-    update_confidence(p, p.precision if p.precision in ("minor", "build") else "major")
+    update_confidence(
+        p,
+        p.precision if p.precision in (PrecisionLevel.MINOR, PrecisionLevel.BUILD) else PrecisionLevel.MAJOR,
+    )
     return p

os_normalizer/parsers/network/juniper.py

@@ -2,6 +2,7 @@
 
 import re
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -14,7 +15,9 @@ JUNOS_MODEL_RE = re.compile(r"\b(EX\d{3,4}-\d{2}[A-Z]?|QFX\d{3,4}\w*|SRX\d{3,4}\
 def parse_juniper(text: str, p: OSData) -> OSData:
     p.vendor = "Juniper"
     p.product = "Junos"
-    p.family = p.family or "network-os"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
     p.kernel_name = "junos"
 
     vm = JUNOS_VER_RE.search(text)
@@ -27,16 +30,19 @@ def parse_juniper(text: str, p: OSData) -> OSData:
         if len(nums) >= 2:
             p.version_minor = int(nums[1])
         p.version_build = ver
-        p.precision = "minor"
+        p.precision = PrecisionLevel.MINOR
 
     pkg = JUNOS_PKG_RE.search(text)
     if pkg:
         p.build_id = pkg.group(1)
-        p.precision = "build"
+        p.precision = PrecisionLevel.BUILD
 
     mdl = JUNOS_MODEL_RE.search(text)
     if mdl:
         p.hw_model = mdl.group(1)
 
-    update_confidence(p, p.precision if p.precision in ("build", "minor") else "major")
+    update_confidence(
+        p,
+        p.precision if p.precision in (PrecisionLevel.BUILD, PrecisionLevel.MINOR) else PrecisionLevel.MAJOR,
+    )
     return p

os_normalizer/parsers/network/netgear.py

@@ -2,6 +2,7 @@
 
 import re
 
+from os_normalizer.constants import OSFamily, PrecisionLevel
 from os_normalizer.helpers import update_confidence
 from os_normalizer.models import OSData
 
@@ -13,7 +14,9 @@ NETGEAR_MODEL_RE = re.compile(r"\b([RN][0-9]{3,4}[A-Z]?)\b", re.IGNORECASE)
 def parse_netgear(text: str, p: OSData) -> OSData:
     p.vendor = "Netgear"
     p.product = "Firmware"
-    p.family = p.family or "network-os"
+    if not isinstance(p.family, OSFamily):
+        p.family = OSFamily(p.family) if p.family in OSFamily._value2member_map_ else None
+    p.family = p.family or OSFamily.NETWORK
     p.kernel_name = "firmware"
 
     vm = NETGEAR_VER_RE.search(text)
@@ -27,11 +30,15 @@ def parse_netgear(text: str, p: OSData) -> OSData:
         if len(nums) >= 3:
             p.version_patch = int(nums[2])
         p.version_build = v
-        p.precision = "patch" if p.version_patch is not None else ("minor" if p.version_minor is not None else "major")
+        p.precision = (
+            PrecisionLevel.PATCH
+            if p.version_patch is not None
+            else (PrecisionLevel.MINOR if p.version_minor is not None else PrecisionLevel.MAJOR)
+        )
 
     mdl = NETGEAR_MODEL_RE.search(text)
     if mdl:
         p.hw_model = mdl.group(1)
 
-    update_confidence(p, "minor" if p.precision == "major" else p.precision)
+    update_confidence(p, PrecisionLevel.MINOR if p.precision == PrecisionLevel.MAJOR else p.precision)
     return p

os_normalizer/parsers/solaris.py

@@ -0,0 +1,100 @@
+"""Solaris specific parsing logic."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from os_normalizer.constants import PrecisionLevel
+from os_normalizer.helpers import precision_from_parts, update_confidence
+from os_normalizer.models import OSData
+
+SUNOS_UNAME_RE = re.compile(
+    r"SunOS\s+\S+\s+(\d+(?:\.\d+)+)(?:\s+(\d+(?:\.\d+){1,4}))?",
+    re.IGNORECASE,
+)
+SOLARIS_RELEASE_RE = re.compile(
+    r"(?:Oracle\s+)?Solaris\s+(\d+(?:\.\d+){0,4})",
+    re.IGNORECASE,
+)
+GENERIC_BUILD_RE = re.compile(r"\bGeneric_(\S+)", re.IGNORECASE)
+
+
+def parse_solaris(text: str, data: dict[str, Any], p: OSData) -> OSData:
+    """Populate an OSData instance with Solaris-specific details."""
+    # Baseline identity
+    p.vendor = p.vendor or "Oracle"
+    p.product = p.product or "Oracle Solaris"
+    p.kernel_name = "sunos"
+
+    kernel_version: str | None = None
+    release_version: str | None = None
+
+    # Extract version information from uname-style lines
+    uname_match = SUNOS_UNAME_RE.search(text)
+    if uname_match:
+        kernel_version = uname_match.group(1)
+        release_version = uname_match.group(2) or release_version
+
+    # /etc/release style information
+    release_match = SOLARIS_RELEASE_RE.search(text)
+    if release_match:
+        release_version = release_match.group(1)
+
+    # Normalise kernel version token if present
+    if kernel_version:
+        p.kernel_version = kernel_version
+
+    # Use the release token if available; fall back to kernel version
+    version_source = release_version or kernel_version
+
+    version_build: str | None = None
+    major: int | None = None
+    minor: int | None = None
+    patch: int | None = None
+
+    if version_source:
+        major, minor, patch, version_build = _split_solaris_version(version_source)
+
+    # Collect Generic_ build tags and prefer non-empty value
+    build_match = GENERIC_BUILD_RE.search(text)
+    if build_match:
+        version_build = version_build or build_match.group(1)
+
+    if major is not None:
+        p.version_major = major
+    if minor is not None:
+        p.version_minor = minor
+    if patch is not None:
+        p.version_patch = patch
+    if version_build:
+        p.version_build = version_build
+
+    if version_source:
+        p.precision = precision_from_parts(p.version_major, p.version_minor, p.version_patch, p.version_build)
+    else:
+        p.precision = PrecisionLevel.PRODUCT
+
+    update_confidence(p, p.precision)
+    return p
+
+
+def _split_solaris_version(version: str) -> tuple[int | None, int | None, int | None, str | None]:
+    """Convert Solaris version tokens into (major, minor, patch, build)."""
+    parts = [int(token) for token in re.findall(r"\d+", version)]
+    if not parts:
+        return None, None, None, None
+
+    if parts[0] == 5 and len(parts) >= 2:
+        # SunOS 5.x maps to Solaris x
+        major = parts[1]
+        remainder = parts[2:]
+    else:
+        major = parts[0]
+        remainder = parts[1:]
+
+    minor = remainder[0] if len(remainder) >= 1 else None
+    patch = remainder[1] if len(remainder) >= 2 else None
+    extra = remainder[2:] if len(remainder) >= 3 else []
+    build = ".".join(str(x) for x in extra) if extra else None
+    return major, minor, patch, build

os_normalizer/parsers/windows.py

@@ -12,6 +12,7 @@ from os_normalizer.constants import (
     WINDOWS_NT_SERVER_MAP,
     WINDOWS_PRODUCT_PATTERNS,
     WINDOWS_SERVER_BUILD_MAP,
+    PrecisionLevel,
 )
 from os_normalizer.helpers import extract_arch_from_text, update_confidence
 
@@ -289,13 +290,13 @@ def _derive_precision(
     minor: int | None,
     patch: int | None,
     build: str | None,
-) -> str:
+) -> PrecisionLevel:
     if build:
-        return "build"
+        return PrecisionLevel.BUILD
     if patch is not None and patch != 0:
-        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

{os_normalizer-0.4.3.dist-info → os_normalizer-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: os-normalizer
-Version: 0.4.3
+Version: 0.5.0
 Summary: Normalize raw OS strings/metadata into structured data (family, product, version, arch).
 Project-URL: Homepage, https://github.com/johnscillieri/os-normalizer
 Project-URL: Repository, https://github.com/johnscillieri/os-normalizer
@@ -38,6 +38,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: System :: Operating System
 Requires-Python: >=3.11