os-normalizer 0.4.0__tar.gz → 0.4.1__tar.gz

os_normalizer-0.4.1/.uv-cache/.gitignore

@@ -0,0 +1 @@
+*

os_normalizer-0.4.1/.uv-cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project are documented here.
 This file adheres to Keep a Changelog and Semantic Versioning.
 
+## [0.4.1] - 2025-09-25
+
+- Added: Broadened Windows product aliases (e.g., Win11, Win2k) and recognized the macOS 26 codename `Tahoe`.
+- Changed: Windows normalization now always fills NT version major/minor fields and treats marketing releases (21H2/24H2/etc.) as the kernel version for richer telemetry.
+- Changed: Windows CPE generation derives release-channel tokens from build numbers so clients emit `windows_10_21h2`, `windows_11_24h2`, and similar slugs automatically.
+- Fixed: Windows 11 and Server 2025 inputs no longer fall back to Windows 10 defaults, and legacy server builds keep their correct product names.
+- Fixed: Windows `OSData` string formatting avoids duplicate fragments and skips redundant kernel numbers when printing friendly names.
+
+## [0.4.0] - 2025-09-22
+
+- Changed: Windows parser now normalizes typoed `windws` tokens, infers server editions from `Windows 2008/2012/2003` strings, and derives build numbers from generic `6.x.yyyy` patterns.
+- Fixed: Windows Server 2012 R2 and older NT-based servers are correctly identified when only kernel/build identifiers are present.
+- Fixed: OSData now always captures `kernel_version`/`version_build` for telemetry-only inputs.
+
+## [0.3.4] - 2025-09-21
+
+- Added: Extensive Windows kernel/build fixtures (e.g., `Windows 7601 6.1.7601 ...`) to lock in parsing of raw telemetry strings.
+- Added: Coverage for Windows Server kernel identifiers to ensure server products are emitted with matching CPE metadata.
+- Added: Regression tests for Redstone/Windows 10 marketing channels and mixed-case architecture tokens.
+
 ## [0.3.3] - 2025-09-21
 
 - Added: `tests/case_utils.py` to share parametrization helpers across suites.
@@ -40,8 +60,12 @@ This file adheres to Keep a Changelog and Semantic Versioning.
 
 - Initial release.
 
-[Unreleased]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.3...HEAD
+[Unreleased]: https://github.com/johnscillieri/os-normalizer/compare/v0.4.1...HEAD
+[0.4.1]: https://github.com/johnscillieri/os-normalizer/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.4...v0.4.0
+[0.3.4]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.3...v0.3.4
 [0.3.3]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/johnscillieri/os-normalizer/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/johnscillieri/os-normalizer/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/johnscillieri/os-normalizer/compare/v0.1.0...v0.2.0

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: os-normalizer
-Version: 0.4.0
+Version: 0.4.1
 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
@@ -49,7 +49,7 @@ A Python library for identifying and parsing operating system information from v
 
 ## Overview
 
-The OS Normalizer library parses raw operating system strings and JSON data to identify the OS family, version, architecture, and other details. It supports parsing of:
+The OS Normalizer library parses raw operating system strings and supplimental data to identify the OS family, version, architecture, and other details. It supports parsing of:
 
 - Windows (NT builds, versions)
 - macOS (Darwin versions, codenames)
@@ -80,17 +80,18 @@ print(result.product)  # Windows 11
 print(result.version_major)  # 11
 ```
 
-### Using Raw OS JSON Data
+### Using OS Release Data
 
 ```python
 from os_normalizer import normalize_os
 
-# Fingerprint with both raw string and JSON data
+# Fingerprint with both raw string and contents of os-release file
 raw_os_string="Linux host 5.15.0-122-generic x86_64"
-raw_os_json={
-    "os_release": 'NAME="Ubuntu"\nID=ubuntu\nVERSION_ID="22.04.4"\nVERSION_CODENAME=jammy\nPRETTY_NAME="Ubuntu 22.04.4 LTS"'}
+os_release_data={
+    "os_release": 'NAME="Ubuntu"\nID=ubuntu\nVERSION_ID="22.04.4"\nVERSION_CODENAME=jammy\nPRETTY_NAME="Ubuntu 22.04.4 LTS"'
+}
 
-result = normalize_os(raw_os_string, raw_os_json)
+result = normalize_os(raw_os_string, os_release_data)
 print(result.family)  # linux
 print(result.product)  # Ubuntu
 print(result.codename)  # Jammy

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/README.md

@@ -4,7 +4,7 @@ A Python library for identifying and parsing operating system information from v
 
 ## Overview
 
-The OS Normalizer library parses raw operating system strings and JSON data to identify the OS family, version, architecture, and other details. It supports parsing of:
+The OS Normalizer library parses raw operating system strings and supplimental data to identify the OS family, version, architecture, and other details. It supports parsing of:
 
 - Windows (NT builds, versions)
 - macOS (Darwin versions, codenames)
@@ -35,17 +35,18 @@ print(result.product)  # Windows 11
 print(result.version_major)  # 11
 ```
 
-### Using Raw OS JSON Data
+### Using OS Release Data
 
 ```python
 from os_normalizer import normalize_os
 
-# Fingerprint with both raw string and JSON data
+# Fingerprint with both raw string and contents of os-release file
 raw_os_string="Linux host 5.15.0-122-generic x86_64"
-raw_os_json={
-    "os_release": 'NAME="Ubuntu"\nID=ubuntu\nVERSION_ID="22.04.4"\nVERSION_CODENAME=jammy\nPRETTY_NAME="Ubuntu 22.04.4 LTS"'}
+os_release_data={
+    "os_release": 'NAME="Ubuntu"\nID=ubuntu\nVERSION_ID="22.04.4"\nVERSION_CODENAME=jammy\nPRETTY_NAME="Ubuntu 22.04.4 LTS"'
+}
 
-result = normalize_os(raw_os_string, raw_os_json)
+result = normalize_os(raw_os_string, os_release_data)
 print(result.family)  # linux
 print(result.product)  # Ubuntu
 print(result.codename)  # Jammy

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/os_normalizer/constants.py

@@ -25,10 +25,11 @@ ARCH_SYNONYMS = {
 WINDOWS_BUILD_MAP = [
     # NT era (pre-Windows 10)
     (1381, 1381, "Windows NT 4.0", "RTM"),
+    (1998, 1998, "Windows 98", "RTM"),
     (2195, 2195, "Windows 2000", "RTM"),
     (2600, 2600, "Windows XP", "RTM"),
-    # NT 5.2 builds are ambiguous (XP x64 vs Server 2003); keep consistent label
-    (3790, 3790, "Windows XP x64/Server 2003", "RTM"),
+    (3000, 3000, "Windows Me", "RTM"),
+    (3790, 3790, "Windows XP x64", "RTM"),
     # Vista/7/8/8.1
     (6000, 6000, "Windows Vista", "RTM"),
     (6001, 6001, "Windows Vista", "SP1"),
@@ -45,8 +46,13 @@ WINDOWS_BUILD_MAP = [
     (16299, 16299, "Windows 10", "1709"),
     (17134, 17134, "Windows 10", "1803"),
     (17763, 17763, "Windows 10", "1809"),
-    (18362, 18363, "Windows 10", "1903/1909"),
-    (19041, 19045, "Windows 10", "2004/20H2/21H1/21H2/22H2"),
+    (18362, 18362, "Windows 10", "1903"),
+    (18363, 18363, "Windows 10", "1909"),
+    (19041, 19041, "Windows 10", "2004"),
+    (19042, 19042, "Windows 10", "20H2"),
+    (19043, 19043, "Windows 10", "21H1"),
+    (19044, 19044, "Windows 10", "21H2"),
+    (19045, 19045, "Windows 10", "22H2"),
     # Windows 11
     (22000, 22000, "Windows 11", "21H2"),
     (22621, 22621, "Windows 11", "22H2"),
@@ -54,12 +60,35 @@ WINDOWS_BUILD_MAP = [
     (26100, 26199, "Windows 11", "24H2"),
 ]
 
+# Windows Server build map (build number range -> product name, marketing channel)
+# This is consulted only when the input looks server-like or when an explicit
+# Windows Server product is already detected. Client mapping will not override
+# explicit server detections.
+WINDOWS_SERVER_BUILD_MAP = [
+    # Legacy server releases aligned with Vista/7/8/8.1
+    (3790, 3790, "Windows Server 2003", "RTM"),
+    (6001, 6001, "Windows Server 2008", "RTM"),  # 6001 corresponds to 2008 RTM
+    (6002, 6002, "Windows Server 2008", "SP2"),
+    (7600, 7600, "Windows Server 2008 R2", "RTM"),
+    (7601, 7601, "Windows Server 2008 R2", "SP1"),
+    (9200, 9200, "Windows Server 2012", "RTM"),
+    (9600, 9600, "Windows Server 2012 R2", "RTM"),
+    # NT 10.0 based server releases
+    (14393, 14393, "Windows Server 2016", "1607"),
+    (17763, 17763, "Windows Server 2019", "1809"),
+    (20348, 20348, "Windows Server 2022", "21H2"),
+    # Windows Server 2025 (vNext) uses the 26100 train alongside client 24H2
+    (26100, 26199, "Windows Server 2025", "24H2"),
+]
+
 # Windows NT version tuple -> client product (ambiguous NT 6.x split out)
 WINDOWS_NT_CLIENT_MAP = {
     (4, 0): "Windows NT 4.0",
+    (4, 10): "Windows 98",
+    (4, 90): "Windows Me",
     (5, 0): "Windows 2000",
     (5, 1): "Windows XP",
-    (5, 2): "Windows XP x64/Server 2003",  # NT 5.2 often maps to XP x64 on client
+    (5, 2): "Windows XP x64",
     (6, 0): "Windows Vista",
     (6, 1): "Windows 7",
     (6, 2): "Windows 8",
@@ -71,7 +100,6 @@ WINDOWS_NT_CLIENT_MAP = {
 WINDOWS_NT_SERVER_MAP = {
     (4, 0): "Windows NT 4.0 Server",
     (5, 0): "Windows 2000 Server",
-    (5, 1): "Windows XP/Server 2003",  # rarely used for server detection
     (5, 2): "Windows Server 2003",
     (6, 0): "Windows Server 2008",
     (6, 1): "Windows Server 2008 R2",
@@ -80,10 +108,32 @@ WINDOWS_NT_SERVER_MAP = {
     # NT 10.0: Server 2016/2019/2022 detected via explicit names, not NT mapping
 }
 
+
+WINDOWS_PRODUCT_PATTERNS: list[tuple[str, tuple[str, ...]]] = [
+    ("Windows 11", ("windows 11", "win11")),
+    ("Windows 10", ("windows 10", "win10")),
+    ("Windows 8.1", ("windows 8.1", "win81")),
+    ("Windows 8", ("windows 8", "win8")),
+    ("Windows 7", ("windows 7", "win7")),
+    ("Windows ME", ("windows me", "windows millenium")),
+    ("Windows 98", ("windows 98", "win98")),
+    ("Windows Server 2022", ("windows server 2022", "windows 2022", "win2k22", "win2022")),
+    ("Windows Server 2019", ("windows server 2019", "windows 2019", "win2k19", "win2019")),
+    ("Windows Server 2016", ("windows server 2016", "windows 2016", "win2k16", "win2016")),
+    ("Windows Server 2012 R2", ("windows server 2012 r2", "windows 2012 r2", "win2k12r2", "win2012r2")),
+    ("Windows Server 2012", ("windows server 2012", "windows 2012", "win2k12", "win2012")),
+    ("Windows Server 2008 R2", ("windows server 2008 r2", "windows 2008 r2", "win2k8r2", "win2008r2")),
+    ("Windows Server 2008", ("windows server 2008", "windows 2008", "win2k8", "win2008")),
+    ("Windows Server 2003", ("windows server 2003", "windows 2003", "win2k3", "win2003")),
+    ("Windows Server 2000", ("windows server 2000", "windows 2000", "win2k", "win2000")),
+]
+
+
 # Human readable aliases (macOS codenames)
 MACOS_ALIASES = {
-    "sonoma": "macOS 14",
+    "tahoe": "macOS 26",
     "sequoia": "macOS 15",
+    "sonoma": "macOS 14",
     "ventura": "macOS 13",
     "monterey": "macOS 12",
     "big sur": "macOS 11",
@@ -102,26 +152,5 @@ MACOS_DARWIN_MAP = {
     25: ("macOS", "26", "Tahoe"),
 }
 
-# Windows Server build map (build number range -> product name, marketing channel)
-# This is consulted only when the input looks server-like or when an explicit
-# Windows Server product is already detected. Client mapping will not override
-# explicit server detections.
-WINDOWS_SERVER_BUILD_MAP = [
-    # Legacy server releases aligned with Vista/7/8/8.1
-    (3790, 3790, "Windows Server 2003", "RTM"),
-    (6001, 6001, "Windows Server 2008", "RTM"),  # 6001 corresponds to 2008 RTM
-    (6002, 6002, "Windows Server 2008", "SP2"),
-    (7600, 7600, "Windows Server 2008 R2", "RTM"),
-    (7601, 7601, "Windows Server 2008 R2", "SP1"),
-    (9200, 9200, "Windows Server 2012", "RTM"),
-    (9600, 9600, "Windows Server 2012 R2", "RTM"),
-    # NT 10.0 based server releases
-    (14393, 14393, "Windows Server 2016", "1607"),
-    (17763, 17763, "Windows Server 2019", "1809"),
-    (20348, 20348, "Windows Server 2022", "21H2"),
-    # Windows Server 2025 (vNext) uses the 26100 train alongside client 24H2
-    (26100, 26199, "Windows Server 2025", "24H2"),
-]
-
 # Cisco train names (used for codename detection)
 CISCO_TRAIN_NAMES = {"Everest", "Fuji", "Gibraltar", "Amsterdam", "Denali"}

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/os_normalizer/cpe.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from os_normalizer.constants import WINDOWS_BUILD_MAP
+
 if TYPE_CHECKING:
     from .models import OSData
 
@@ -39,7 +41,7 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
     """
     fam = (p.family or "").lower()
     vendor = (p.vendor or "").lower() if p.vendor else None
-    product = (p.product or "").lower() if p.product else None
+    product = (p.product or "").lower() if p.product else ""
 
     # Windows
     if fam == "windows":
@@ -59,9 +61,10 @@ def _map_vendor_product(p: OSData) -> tuple[str, str, str]:
             "windows server 2022": "windows_server_2022",
         }
         base = prod_map.get(product, "windows")
-        # For Windows 10/11, append channel (e.g., _23h2) when available
-        if base in ("windows_10", "windows_11") and p.channel:
-            base = f"{base}_{p.channel.lower()}"
+        if base in ("windows_10", "windows_11"):
+            token = _windows_channel_token(p)
+            if token:
+                base = f"{base}_{token}"
         return vtok, base, "windows"
 
     # macOS
@@ -130,18 +133,26 @@ def _fmt_version(p: OSData, strategy: str) -> tuple[str, str, str]:
     """Return (version, update, edition) strings per strategy."""
     maj, minr, pat = p.version_major, p.version_minor, p.version_patch
     build = p.version_build
-    channel = (p.channel or "").lower() if p.channel else None
     edition = (p.edition or "").lower() if p.edition else None
 
     if strategy == "windows":
-        # Product may include channel; version should reflect NT kernel + build when known
-        if p.kernel_version:
-            ver = p.kernel_version
+        patch = p.version_patch
+        if p.version_major is not None and p.version_minor is not None:
+            base = f"{p.version_major}.{p.version_minor}"
+            if p.version_build:
+                ver = f"{base}.{p.version_build}"
+                if patch not in (None, 0):
+                    ver = f"{ver}.{patch}"
+            else:
+                ver = base
+                if patch not in (None, 0):
+                    ver = f"{ver}.{patch}"
         elif p.version_build:
-            nt = p.evidence.get("nt_version") if isinstance(p.evidence, dict) else None
-            ver = f"{nt}.{p.version_build}" if nt else p.version_build
+            ver = p.version_build
+            if patch not in (None, 0):
+                ver = f"{ver}.{patch}"
         else:
-            ver = "*"
+            ver = p.kernel_version or "*"
         return ver, "*", "*"
 
     if strategy == "ubuntu":
@@ -220,6 +231,42 @@ def _fmt_version(p: OSData, strategy: str) -> tuple[str, str, str]:
     return ver, "*", "*"
 
 
+def _windows_channel_token(p: OSData) -> str | None:
+    known_tokens = {
+        "24h2",
+        "23h2",
+        "22h2",
+        "21h2",
+        "21h1",
+        "20h2",
+        "2004",
+        "1909",
+        "1903",
+        "1809",
+        "1803",
+        "1709",
+        "1703",
+        "1607",
+        "1511",
+        "1507",
+    }
+
+    kv = (p.kernel_version or "").lower()
+    if kv in known_tokens:
+        return kv
+
+    vb = p.version_build
+    if vb and vb.isdigit():
+        build = int(vb)
+        for lo, hi, _product, marketing in WINDOWS_BUILD_MAP:
+            if lo <= build <= hi and marketing:
+                token = marketing.split('/')[-1].lower()
+                if token:
+                    return token
+
+    return None
+
+
 def _cpe_target_hw(arch: str | None) -> str:
     if not arch:
         return "*"

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/os_normalizer/models.py

@@ -47,6 +47,9 @@ class OSData:
     def __str__(self) -> str:  # pragma: no cover - formatting helper
         parts: list[str] = []
 
+        if self.family == "windows":
+            return _format_windows(self)
+
         # Prefer vendor + product; fallback to pretty_name; then family
         name_bits = [x for x in (self.vendor, self.product) if x]
         if name_bits:
@@ -141,6 +144,19 @@ class OSData:
         return "\n".join(lines)
 
 
+def _format_windows(p: OSData) -> str:
+    parts = [
+        p.vendor,
+        p.product,
+        p.edition,
+        p.codename,
+        f"({p.kernel_version})" if p.kernel_version != f"{p.version_major}.{p.version_minor}" else "",
+        f"{p.version_major}.{p.version_minor}.{p.version_build}",
+        p.arch,
+    ]
+    return " ".join(part for part in parts if part)
+
+
 if __name__ == "__main__":
     x = OSData(
         family="linux",

os_normalizer-0.4.1/os_normalizer/parsers/windows.py

@@ -0,0 +1,274 @@
+"""Windows specific parsing logic."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from os_normalizer.constants import (
+    WINDOWS_BUILD_MAP,
+    WINDOWS_NT_CLIENT_MAP,
+    WINDOWS_NT_SERVER_MAP,
+    WINDOWS_PRODUCT_PATTERNS,
+    WINDOWS_SERVER_BUILD_MAP,
+)
+from os_normalizer.helpers import extract_arch_from_text, update_confidence
+
+if TYPE_CHECKING:
+    from os_normalizer.models import OSData
+
+VERSION_PATTERN = re.compile(r"\b(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?\b")
+NT_PATTERN = re.compile(r"\bnt\s*(\d+)(?:\.(\d+))?", re.IGNORECASE)
+BUILD_PATTERN = re.compile(r"\bbuild\s*(?:number\s*)?(\d{3,5})\b", re.IGNORECASE)
+SP_PATTERN = re.compile(r"\bsp(\d)\b", re.IGNORECASE)
+
+EDITION_KEYWORDS: list[tuple[str, str]] = [
+    ("iot enterprise", "Enterprise"),
+    ("enterprise", "Enterprise"),
+    ("education", "Education"),
+    ("datacenter", "Datacenter"),
+    ("standard", "Standard"),
+    ("professional", "Professional"),
+    (" pro ", "Professional"),
+    (" home ", "Home"),
+]
+
+
+@dataclass(frozen=True)
+class ProductDefaults:
+    version_major: int | None = None
+    version_minor: int | None = None
+    version_patch: int | None = None
+    version_build: str | None = None
+    kernel_version: str | None = None
+
+
+PRODUCT_DEFAULTS: dict[str, ProductDefaults] = {
+    "Windows NT 4.0": ProductDefaults(4, 0, None, "1381", "4.0"),
+    "Windows 98": ProductDefaults(4, 10, None, "1998", "4.10"),
+    "Windows ME": ProductDefaults(4, 90, None, "3000", "4.9"),
+    "Windows 2000": ProductDefaults(5, 0, None, "2195", "5.0"),
+    "Windows XP": ProductDefaults(5, 1, None, "2600", "5.1"),
+    "Windows Vista": ProductDefaults(6, 0, None, "6000", "6.0"),
+    "Windows Vista SP1": ProductDefaults(6, 0, None, "6001", "6.0"),
+    "Windows Vista SP2": ProductDefaults(6, 0, None, "6002", "6.0"),
+    "Windows 7": ProductDefaults(6, 1, None, "7601", "6.1"),
+    "Windows 7 SP1": ProductDefaults(6, 1, None, "7601", "6.1"),
+    "Windows 7 SP2": ProductDefaults(6, 1, None, "7601", "6.1"),
+    "Windows 8": ProductDefaults(6, 2, None, "9200", "6.2"),
+    "Windows 8.1": ProductDefaults(6, 3, None, "9600", "6.3"),
+    "Windows 10": ProductDefaults(10, 0, None, None, None),
+    "Windows 11": ProductDefaults(10, 0, None, None, None),
+    "Windows Server 2003": ProductDefaults(5, 2, None, "3790", "5.2"),
+    "Windows Server 2008": ProductDefaults(6, 0, None, "6002", "6.0"),
+    "Windows Server 2008 R2": ProductDefaults(6, 1, None, "7600", "6.1"),
+    "Windows Server 2008 R2 SP1": ProductDefaults(6, 1, None, "7601", "6.1"),
+    "Windows Server 2012": ProductDefaults(6, 2, None, "9200", "6.2"),
+    "Windows Server 2012 R2": ProductDefaults(6, 3, None, "9600", "6.3"),
+    "Windows Server 2016": ProductDefaults(10, 0, None, None, None),
+    "Windows Server 2019": ProductDefaults(10, 0, None, None, None),
+    "Windows Server 2022": ProductDefaults(10, 0, None, None, None),
+    "Windows Server 2025": ProductDefaults(10, 0, None, None, None),
+}
+
+
+@dataclass
+class VersionState:
+    """Intermediate container for NT/build details discovered in the banner."""
+
+    nt_major: int | None = None
+    nt_minor: int | None = None
+    build: str | None = None
+    patch: int | None = None
+    channel: str | None = None
+    explicit: bool = False
+
+
+def parse_windows(text: str, data: dict[str, Any], p: OSData) -> OSData:
+    """Populate an OSData instance with Windows-specific details."""
+    tl = text.lower()
+
+    p.vendor = "Microsoft"
+    p.kernel_name = "nt"
+    p.arch = extract_arch_from_text(tl)
+    p.edition = _detect_edition(tl)
+
+    product = _detect_product(tl)
+    server_hint = _initial_server_hint(tl, product)
+    state = _extract_version_state(tl)
+    product, server_hint = _apply_build_context(state, product, server_hint)
+    p.product = _finalize_product_label(tl, product, state, server_hint)
+
+    defaults = PRODUCT_DEFAULTS.get(p.product or "")
+    _apply_version_numbers(p, defaults, state)
+    _set_kernel_version(p, defaults, state)
+    _finalize_precision_and_confidence(p, state)
+
+    return p
+
+
+def _detect_product(text: str) -> str | None:
+    for product, patterns in WINDOWS_PRODUCT_PATTERNS:
+        for token in patterns:
+            if token in text:
+                return product
+    return None
+
+
+def _initial_server_hint(tl: str, product: str | None) -> bool:
+    """Return True when the banner or product implies a Windows Server build."""
+    return "server" in tl or (product is not None and "server" in product.lower())
+
+
+def _extract_version_state(text: str) -> VersionState:
+    """Collect NT version, build, and patch information from the banner."""
+    state = VersionState()
+
+    best = _select_best_version(text)
+    if best:
+        state.nt_major, state.nt_minor, state.build, state.patch = best
+        state.explicit = True
+
+    nt_match = NT_PATTERN.search(text)
+    if nt_match:
+        maj = int(nt_match.group(1))
+        minr = int(nt_match.group(2)) if nt_match.group(2) else 0
+        if state.nt_major is None:
+            state.nt_major = maj
+            state.nt_minor = minr
+        else:
+            state.nt_minor = state.nt_minor if state.nt_minor is not None else minr
+        state.explicit = True
+
+    if state.build is None:
+        build_match = BUILD_PATTERN.search(text)
+        if build_match:
+            state.build = str(int(build_match.group(1)))
+            state.explicit = True
+
+    return state
+
+
+def _apply_build_context(state: VersionState, product: str | None, server_hint: bool) -> tuple[str | None, bool]:
+    """Use build numbers to infer product/channel metadata and refine server hint."""
+    build_num = int(state.build) if state.build and state.build.isdigit() else None
+    if build_num is None:
+        return product, server_hint
+
+    product_from_build, channel, is_server_build = _lookup_build(build_num, server_hint)
+    if product_from_build and not product:
+        product = product_from_build
+    if is_server_build:
+        server_hint = True
+    state.channel = channel
+    return product, server_hint
+
+
+def _finalize_product_label(tl: str, product: str | None, state: VersionState, server_hint: bool) -> str | None:
+    """Resolve the most precise product name available for the banner."""
+    if product is None and state.nt_major is not None and state.nt_minor is not None:
+        product = _product_from_nt(state.nt_major, state.nt_minor, server_hint)
+
+    if product:
+        sp_match = SP_PATTERN.search(tl)
+        if sp_match and "windows 7" in product.lower():
+            product = f"Windows 7 SP{sp_match.group(1)}"
+
+    return product
+
+
+def _apply_version_numbers(p: OSData, defaults: ProductDefaults, state: VersionState) -> None:
+    """Move version components from the parse state into the OSData payload."""
+    p.version_major = state.nt_major if state.nt_major is not None else defaults.version_major
+    p.version_minor = state.nt_minor if state.nt_minor is not None else defaults.version_minor
+    p.version_patch = state.patch if state.patch is not None else defaults.version_patch
+    p.version_build = state.build if state.build is not None else defaults.version_build
+
+
+def _set_kernel_version(p: OSData, defaults: ProductDefaults | None, state: VersionState) -> None:
+    """Populate kernel_version using explicit tokens, build channel, or defaults."""
+    kernel_version: str | None = None
+    if state.explicit and state.nt_major is not None:
+        if state.nt_major >= 10 and state.channel:
+            kernel_version = state.channel
+        elif state.nt_minor is not None:
+            kernel_version = f"{state.nt_major}.{state.nt_minor}"
+    if kernel_version is None and defaults and defaults.kernel_version:
+        kernel_version = defaults.kernel_version
+    if kernel_version:
+        p.kernel_version = kernel_version
+
+
+def _finalize_precision_and_confidence(p: OSData, state: VersionState) -> None:
+    """Derive precision/confidence and record evidence for explicit NT versions."""
+    p.precision = _derive_precision(p.version_major, p.version_minor, p.version_patch, p.version_build)
+
+    if state.explicit and state.nt_major is not None:
+        norm_major = min(10, state.nt_major)
+        norm_minor = state.nt_minor if state.nt_minor is not None else 0
+        p.evidence["nt_version"] = f"{norm_major}.{norm_minor}"
+
+    update_confidence(p, p.precision)
+
+
+def _detect_edition(tl: str) -> str | None:
+    for token, label in EDITION_KEYWORDS:
+        if token.strip() in {"pro", "home"}:
+            pattern = rf"\b{token.strip()}\b"
+            if re.search(pattern, tl):
+                return label
+        elif token in tl:
+            return label
+    return None
+
+
+def _select_best_version(text: str) -> tuple[int, int, str | None, int | None] | None:
+    best: tuple[int, int, str | None, int | None] | None = None
+    best_score = -1
+    for match in VERSION_PATTERN.finditer(text):
+        major, minor, build, patch = match.groups()
+        score = 2 if patch is not None else 1
+        if score > best_score:
+            best_score = score
+            bpatch = int(patch) if patch is not None else None
+            best = (int(major), int(minor), str(int(build)), bpatch)
+    return best
+
+
+def _lookup_build(build_num: int, server_hint: bool) -> tuple[str | None, str | None, bool]:
+    candidate: tuple[str | None, str | None, bool] = (None, None, False)
+    tables_to_try: list[tuple[int, int, str, str]] = []
+    if server_hint:
+        tables_to_try.extend(WINDOWS_SERVER_BUILD_MAP)
+    tables_to_try.extend(WINDOWS_BUILD_MAP)
+    for start, end, prod, channel in tables_to_try:
+        if start <= build_num <= end:
+            is_server = prod.lower().startswith("windows server")
+            candidate = (prod, channel, is_server)
+            break
+    return candidate
+
+
+def _product_from_nt(major: int, minor: int, server_hint: bool) -> str | None:
+    key = (major, minor)
+    if server_hint and key in WINDOWS_NT_SERVER_MAP:
+        return WINDOWS_NT_SERVER_MAP[key]
+    return WINDOWS_NT_CLIENT_MAP.get(key)
+
+
+def _derive_precision(
+    major: int | None,
+    minor: int | None,
+    patch: int | None,
+    build: str | None,
+) -> str:
+    if build:
+        return "build"
+    if patch is not None and patch != 0:
+        return "patch"
+    if minor is not None:
+        return "minor"
+    if major is not None:
+        return "major"
+    return "product"

{os_normalizer-0.4.0 → os_normalizer-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "os-normalizer"
-version = "0.4.0"
+version = "0.4.1"
 description = "Normalize raw OS strings/metadata into structured data (family, product, version, arch)."
 readme = "README.md"
 requires-python = ">=3.11"

os_normalizer-0.4.0/os_normalizer/parsers/windows.py

@@ -1,246 +0,0 @@
-"""Windows specific parsing logic.
-
-Refactored for clarity: vendor/edition detection, NT mapping, and build
-mapping are handled by focused helpers. Behavior is preserved while
-avoiding ambiguous NT mappings when server signals are present.
-"""
-
-import re
-from typing import Any, Optional
-
-from os_normalizer.constants import (
-    WINDOWS_BUILD_MAP,
-    WINDOWS_SERVER_BUILD_MAP,
-    WINDOWS_NT_CLIENT_MAP,
-    WINDOWS_NT_SERVER_MAP,
-)
-from os_normalizer.helpers import update_confidence
-from os_normalizer.models import OSData
-
-# Regex patterns used only by the Windows parser
-WIN_EDITION_RE = re.compile(
-    r"\b(professional|pro|enterprise|home|education|ltsc|datacenter|standard)\b",
-    re.IGNORECASE,
-)
-WIN_SP_RE = re.compile(r"\bSP\s?([0-9]+)\b", re.IGNORECASE)
-WIN_BUILD_RE = re.compile(r"\bbuild\s?(\d{4,6})\b", re.IGNORECASE)
-WIN_NT_RE = re.compile(r"\bnt\s?(\d+)\.(\d+)\b", re.IGNORECASE)
-WIN_FULL_NT_BUILD_RE = re.compile(r"\b(10)\.(0)\.(\d+)(?:\.(\d+))?\b")
-WIN_GENERIC_VERSION_RE = re.compile(r"\b(\d+)\.(\d+)\.(\d{3,6})(?:\.(\d+))?\b")
-WIN_CHANNEL_RE = re.compile(
-    r"\b(24H2|23H2|22H2|21H2|21H1|20H2|2004|1909|1903|1809|1803|1709|1703|1607|1511|1507)\b",
-    re.IGNORECASE,
-)
-
-
-def parse_windows(text: str, data: dict[str, Any], p: OSData) -> OSData:
-    """Populate an OSData instance with Windows-specific details."""
-    p.kernel_name = "nt"
-
-    # 1) Product and edition from free text
-    p.product = p.product or _detect_product_from_text(text.lower())
-    p.edition = p.edition or _detect_edition(text)
-
-    # 2) Service Pack
-    _parse_service_pack(text, p)
-
-    # 3) NT version mapping (client vs server)
-    server_like = _is_server_like(text.lower())
-    _apply_nt_mapping(text, p, server_like)
-
-    # 4) Full kernel version (e.g., 10.0.22621.2715) + channel token if present
-    _apply_full_kernel_and_channel(text, p)
-
-    # 5) Build number + marketing channel (fallback when only 'build 22631' is present)
-    _apply_build_mapping(text, p, server_like)
-
-    # 6) Precision and version_major if applicable
-    _finalize_precision_and_version(p)
-
-    # 7) Vendor + confidence
-    p.vendor = "Microsoft"
-    update_confidence(p, p.precision)
-    return p
-
-
-def _detect_product_from_text(t: str) -> str:
-    # Normalize common typos before matching
-    t = t.replace("windws", "windows")
-
-    if "windows 11" in t or "win11" in t:
-        return "Windows 11"
-    if "windows 10" in t or "win10" in t:
-        return "Windows 10"
-    if "windows 8.1" in t or "win81" in t:
-        return "Windows 8.1"
-    if "windows 8" in t or "win8" in t:
-        return "Windows 8"
-    if "windows 7" in t or "win7" in t:
-        return "Windows 7"
-    if "windows me" in t or "windows millenium" in t:
-        return "Windows ME"
-    if "windows 98" in t or "win98" in t:
-        return "Windows 98"
-
-    # Server explicit names
-    if "windows server 2012 r2" in t or "windows 2012 r2" in t or "win2k12r2" in t or "win2012r2" in t:
-        return "Windows Server 2012 R2"
-    if "windows server 2022" in t or "windows 2022" in t or "win2k22" in t or "win2022" in t:
-        return "Windows Server 2022"
-    if "windows server 2019" in t or "windows 2019" in t or "win2k19" in t or "win2019" in t:
-        return "Windows Server 2019"
-    if "windows server 2016" in t or "windows 2016" in t or "win2k16" in t or "win2016" in t:
-        return "Windows Server 2016"
-    if "windows server 2012" in t or "windows 2012" in t or "win2k12" in t or "win2012" in t:
-        return "Windows Server 2012"
-    if "windows server 2008 r2" in t or "windows 2008 r2" in t or "win2k8r2" in t or "win2008r2" in t:
-        return "Windows Server 2008 R2"
-    if "windows server 2008" in t or "windows 2008" in t or "win2k8" in t or "win2008" in t:
-        return "Windows Server 2008"
-    if "windows server 2003" in t or "windows 2003" in t or "win2k3" in t or "win2003" in t:
-        return "Windows Server 2003"
-    if "windows server 2000" in t or "windows 2000" in t or "win2k" in t or "win2000" in t:
-        return "Windows Server 2000"
-
-    if "windows" in t:
-        return "Windows"
-    return "Unknown"
-
-
-def _detect_edition(text: str) -> str | None:
-    m = WIN_EDITION_RE.search(text)
-    if not m:
-        return None
-    token = m.group(1).lower()
-    norm = {
-        "pro": "Professional",
-        "professional": "Professional",
-        "enterprise": "Enterprise",
-        "home": "Home",
-        "education": "Education",
-        "ltsc": "LTSC",
-        "datacenter": "Datacenter",
-        "standard": "Standard",
-    }
-    return norm.get(token, token.title())
-
-
-def _parse_service_pack(text: str, p: OSData) -> None:
-    sp = WIN_SP_RE.search(text)
-    if sp:
-        p.version_patch = int(sp.group(1))
-        p.evidence["service_pack"] = sp.group(0)
-
-
-def _is_server_like(t: str) -> bool:
-    return any(
-        kw in t
-        for kw in (
-            "server",
-            "datacenter",
-            "standard",
-            "essentials",
-            "foundation",
-            "core",  # server core often appears
-            "hyper-v",
-        )
-    )
-
-
-def _apply_nt_mapping(text: str, p: OSData, server_like: bool) -> None:
-    nt = WIN_NT_RE.search(text)
-    if not nt:
-        return
-    major, minor = int(nt.group(1)), int(nt.group(2))
-    p.evidence["nt_version"] = f"{major}.{minor}"
-
-    # If product already explicitly set (e.g., "Windows Server 2019"), keep it
-    if p.product and p.product not in ("Windows", "Windows 10/11"):
-        return
-
-    product = WINDOWS_NT_SERVER_MAP.get((major, minor)) if server_like else WINDOWS_NT_CLIENT_MAP.get((major, minor))
-    if product:
-        p.product = product
-
-
-def _apply_build_mapping(text: str, p: OSData, server_like: bool) -> None:
-    m = WIN_BUILD_RE.search(text)
-    if not m:
-        return
-    build_num = int(m.group(1))
-    p.version_build = str(build_num)
-
-    # Kernel version string
-    if not p.kernel_version:
-        if (p.product == "Windows 10/11") or ("10.0" in text):
-            p.kernel_version = f"10.0.{build_num}"
-        else:
-            nt_mm = WIN_NT_RE.search(text)
-            if nt_mm:
-                maj, minr = int(nt_mm.group(1)), int(nt_mm.group(2))
-                p.kernel_version = f"{maj}.{minr}.{build_num}"
-
-    is_server_product = isinstance(p.product, str) and "server" in p.product.lower()
-    if is_server_product or server_like:
-        # Apply server build mapping; do not override explicit server product names
-        for lo, hi, product_name, marketing in WINDOWS_SERVER_BUILD_MAP:
-            if lo <= build_num <= hi:
-                if not p.product or p.product in ("Windows", "Windows 10/11"):
-                    p.product = product_name
-                # Only set channel for modern Server (2016+)
-                if build_num >= 14393:
-                    p.channel = p.channel or marketing
-                break
-    else:
-        # Apply client build mapping
-        for lo, hi, product_name, marketing in WINDOWS_BUILD_MAP:
-            if lo <= build_num <= hi:
-                # Only use build map to set product for Windows 10/11 trains
-                if build_num >= 10240:
-                    p.product = product_name
-                    p.channel = p.channel or marketing
-                break
-
-
-def _apply_full_kernel_and_channel(text: str, p: OSData) -> None:
-    # Full NT kernel version, e.g., 10.0.22621.2715
-    m = WIN_FULL_NT_BUILD_RE.search(text)
-    if m:
-        build = m.group(3)
-        suffix = m.group(4)
-        p.version_build = p.version_build or build
-        p.kernel_version = f"10.0.{build}{('.' + suffix) if suffix else ''}"
-        # Record evidence for NT 10.0 if not set via NT mapping
-        p.evidence.setdefault("nt_version", "10.0")
-
-    # Marketing channel token in free text, e.g., 22H2 (case-insensitive)
-    ch = WIN_CHANNEL_RE.search(text)
-    if ch and not p.channel:
-        p.channel = ch.group(1).upper()
-
-    if not p.kernel_version:
-        m2 = WIN_GENERIC_VERSION_RE.search(text)
-        if m2:
-            major, minor, build, suffix = m2.groups()
-            p.kernel_version = f"{major}.{minor}.{build}{('.' + suffix) if suffix else ''}"
-            p.version_build = p.version_build or build
-            p.evidence.setdefault("nt_version", f"{major}.{minor}")
-
-
-def _finalize_precision_and_version(p: OSData) -> None:
-    if p.version_build:
-        p.precision = "build"
-        return
-    if p.version_patch is not None:
-        p.precision = "patch"
-        return
-    if p.product and any(x in p.product for x in ("7", "8", "10", "11")):
-        digits = re.findall(r"\d+", p.product)
-        if digits:
-            p.version_major = int(digits[0])
-        p.precision = "major"
-        return
-    if p.product:
-        p.precision = "product"
-    else:
-        p.precision = "family"