os-normalizer 0.4.2__tar.gz → 0.5.0__tar.gz

{os_normalizer-0.4.2 → os_normalizer-0.5.0}/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project are documented here.
 This file adheres to Keep a Changelog and Semantic Versioning.
 
+## `v0.5.0` — [2025-10-30]
+
+- Update release docs, add 3.14 classifier, sort imports [b7e07de]
+- Add a ton more architectures and extract into constants [bd481f8]
+- Add esxi and solaris support [8c14505]
+- Set the unreleased tag for uv-ship [791361c]
+
+## `v0.4.4` — [2025-10-25]
+
+- Add uv-ship config [afd3bed]
+- Merge pull request #2 from johnscillieri/codex/refactor-family-strings-into-constants [cf84c0f]
+- Polish enum usage and update changelog [c3fb7f4]
+- Merge pull request #1 from johnscillieri/codex/add-support-for-huawei-harmonyos [45fe0f9]
+- Document HarmonyOS support addition [584ed2f]
+- Added: HarmonyOS detection for Huawei devices, including dedicated parsing and metadata.
+- Added: HarmonyOS normalization captures build identifiers (e.g., `5.0.0.107`) and propagates them into generated CPE data.
+- Changed: Replaced string literals for OS families and precision tiers with shared enums and ordering constants across the normalization pipeline.
+
+## [0.4.3] - 2025-10-20
+
+- Fixed: Windows build parsing and inconsistent strings
+
 ## [0.4.2] - 2025-10-20
 
 - Fixed: Windows product fingerprinting by build number

{os_normalizer-0.4.2 → os_normalizer-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: os-normalizer
-Version: 0.4.2
+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

os_normalizer-0.5.0/RELEASING.md

@@ -0,0 +1,20 @@
+# Releasing to PyPI
+
+This project uses a modern PEP 621 `pyproject.toml` with the Hatchling build backend. Below are the steps to build and publish to PyPI using uv-ship.
+
+## Prereqs
+
+- Python 3.11+
+- `uv` installed (https://github.com/astral-sh/uv)
+- `uv-ship` installed (via `uv tool install uv-ship`)
+- PyPI accounts and API tokens for TestPyPI and/or PyPI
+
+## Run tests and lint
+
+- `uv run pytest`
+- Optionally: `uv run nox`
+
+## Releasing
+
+- `uv-ship next <type>` where type is major|minor|patch
+- Follow the prompts and release the new version.

{os_normalizer-0.4.2 → os_normalizer-0.5.0}/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-0.4.2 → os_normalizer-0.5.0}/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-0.4.2 → os_normalizer-0.5.0}/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-0.4.2 → os_normalizer-0.5.0}/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"},
     )