souleyez 2.43.28__py3-none-any.whl → 2.43.32__py3-none-any.whl

souleyez/core/version_utils.py

@@ -13,12 +13,13 @@ from typing import List, Optional, Tuple
 
 class VersionOperator(Enum):
     """Comparison operators for version conditions."""
-    LT = '<'
-    LE = '<='
-    GT = '>'
-    GE = '>='
-    EQ = '='
-    NE = '!='
+
+    LT = "<"
+    LE = "<="
+    GT = ">"
+    GE = ">="
+    EQ = "="
+    NE = "!="
 
 
 @dataclass
@@ -31,23 +32,24 @@ class SemanticVersion:
     - 2.4.49, 8.2p1
     - 1.19.0-alpine, 7.4.3-fpm
     """
+
     major: int
     minor: int = 0
     patch: int = 0
     extra: int = 0
-    prerelease: str = ''
-    raw: str = ''
+    prerelease: str = ""
+    raw: str = ""
 
-    def __lt__(self, other: 'SemanticVersion') -> bool:
+    def __lt__(self, other: "SemanticVersion") -> bool:
         return self._compare(other) < 0
 
-    def __le__(self, other: 'SemanticVersion') -> bool:
+    def __le__(self, other: "SemanticVersion") -> bool:
         return self._compare(other) <= 0
 
-    def __gt__(self, other: 'SemanticVersion') -> bool:
+    def __gt__(self, other: "SemanticVersion") -> bool:
         return self._compare(other) > 0
 
-    def __ge__(self, other: 'SemanticVersion') -> bool:
+    def __ge__(self, other: "SemanticVersion") -> bool:
         return self._compare(other) >= 0
 
     def __eq__(self, other: object) -> bool:
@@ -58,7 +60,7 @@ class SemanticVersion:
     def __ne__(self, other: object) -> bool:
         return not self.__eq__(other)
 
-    def _compare(self, other: 'SemanticVersion') -> int:
+    def _compare(self, other: "SemanticVersion") -> int:
         """Compare two versions. Returns -1, 0, or 1."""
         # Compare major.minor.patch.extra
         for self_val, other_val in [
@@ -99,6 +101,7 @@ class SemanticVersion:
 @dataclass
 class VersionCondition:
     """Single version comparison condition."""
+
     operator: VersionOperator
     version: SemanticVersion
 
@@ -122,20 +125,20 @@ class VersionCondition:
 # Regex for parsing version strings
 # Matches: 1.0, 1.0.0, 2.4.49, 8.2p1, 1.19.0-alpine, 7.4.3.1
 VERSION_PATTERN = re.compile(
-    r'^(\d+)'                    # Major (required)
-    r'(?:\.(\d+))?'              # Minor (optional)
-    r'(?:\.(\d+))?'              # Patch (optional)
-    r'(?:\.(\d+))?'              # Extra (optional, for versions like 1.0.0.1)
-    r'(?:[p\-_]([a-zA-Z0-9\-_.]+))?'  # Prerelease (optional, after p/- or _)
+    r"^(\d+)"  # Major (required)
+    r"(?:\.(\d+))?"  # Minor (optional)
+    r"(?:\.(\d+))?"  # Patch (optional)
+    r"(?:\.(\d+))?"  # Extra (optional, for versions like 1.0.0.1)
+    r"(?:[p\-_]([a-zA-Z0-9\-_.]+))?"  # Prerelease (optional, after p/- or _)
 )
 
 # Regex for parsing version conditions
 # Matches: <1.19, >=2.4.49, =1.0.0, !=2.0
 CONDITION_PATTERN = re.compile(
-    r'^(<=?|>=?|!=|=)?'          # Operator (optional, defaults to =)
-    r'(\d+(?:\.\d+)*'            # Version numbers
-    r'(?:[p\-_][a-zA-Z0-9\-_.]+)?)'  # Optional prerelease
-    r'$'
+    r"^(<=?|>=?|!=|=)?"  # Operator (optional, defaults to =)
+    r"(\d+(?:\.\d+)*"  # Version numbers
+    r"(?:[p\-_][a-zA-Z0-9\-_.]+)?)"  # Optional prerelease
+    r"$"
 )
 
 
@@ -159,7 +162,9 @@ def parse_version(version_str: str) -> Optional[SemanticVersion]:
 
     # Handle versions like "OpenSSH 8.2p1" - extract just the version part
     # Look for first digit sequence that looks like a version
-    version_match = re.search(r'(\d+(?:\.\d+)*(?:[p\-_][a-zA-Z0-9\-_.]*)?)', version_str)
+    version_match = re.search(
+        r"(\d+(?:\.\d+)*(?:[p\-_][a-zA-Z0-9\-_.]*)?)", version_str
+    )
     if not version_match:
         return None
 
@@ -173,7 +178,7 @@ def parse_version(version_str: str) -> Optional[SemanticVersion]:
     minor = int(match.group(2)) if match.group(2) else 0
     patch = int(match.group(3)) if match.group(3) else 0
     extra = int(match.group(4)) if match.group(4) else 0
-    prerelease = match.group(5) or ''
+    prerelease = match.group(5) or ""
 
     return SemanticVersion(
         major=major,
@@ -181,7 +186,7 @@ def parse_version(version_str: str) -> Optional[SemanticVersion]:
         patch=patch,
         extra=extra,
         prerelease=prerelease,
-        raw=version_str
+        raw=version_str,
     )
 
 
@@ -202,17 +207,17 @@ def parse_condition(condition_str: str) -> Optional[VersionCondition]:
     if not match:
         return None
 
-    operator_str = match.group(1) or '='
+    operator_str = match.group(1) or "="
     version_str = match.group(2)
 
     # Map operator string to enum
     operator_map = {
-        '<': VersionOperator.LT,
-        '<=': VersionOperator.LE,
-        '>': VersionOperator.GT,
-        '>=': VersionOperator.GE,
-        '=': VersionOperator.EQ,
-        '!=': VersionOperator.NE,
+        "<": VersionOperator.LT,
+        "<=": VersionOperator.LE,
+        ">": VersionOperator.GT,
+        ">=": VersionOperator.GE,
+        "=": VersionOperator.EQ,
+        "!=": VersionOperator.NE,
     }
     operator = operator_map.get(operator_str, VersionOperator.EQ)
 
@@ -237,7 +242,7 @@ def parse_version_conditions(condition_str: str) -> List[VersionCondition]:
         return []
 
     conditions = []
-    for part in condition_str.split(','):
+    for part in condition_str.split(","):
         part = part.strip()
         if part:
             cond = parse_condition(part)
@@ -259,10 +264,10 @@ def parse_version_spec(spec: str) -> Tuple[str, List[VersionCondition]]:
 
     Returns (product_name, conditions_list).
     """
-    if ':' not in spec:
-        return ('', [])
+    if ":" not in spec:
+        return ("", [])
 
-    parts = spec.split(':', 1)
+    parts = spec.split(":", 1)
     product = parts[0].strip().lower()
     conditions = parse_version_conditions(parts[1]) if len(parts) > 1 else []
 
@@ -294,73 +299,57 @@ def matches_version(detected_version: str, conditions: List[VersionCondition]) -
 # Product name normalization mapping
 PRODUCT_ALIASES = {
     # Apache
-    'apache httpd': 'apache',
-    'apache http server': 'apache',
-    'apache/': 'apache',
-    'httpd': 'apache',
-
+    "apache httpd": "apache",
+    "apache http server": "apache",
+    "apache/": "apache",
+    "httpd": "apache",
     # nginx
-    'nginx/': 'nginx',
-
+    "nginx/": "nginx",
     # OpenSSH
-    'openssh': 'ssh',
-    'openssh_': 'ssh',
-    'ssh': 'ssh',
-
+    "openssh": "ssh",
+    "openssh_": "ssh",
+    "ssh": "ssh",
     # PHP
-    'php/': 'php',
-    'php-fpm': 'php',
-
+    "php/": "php",
+    "php-fpm": "php",
     # MySQL
-    'mysql': 'mysql',
-    'mariadb': 'mysql',
-
+    "mysql": "mysql",
+    "mariadb": "mysql",
     # PostgreSQL
-    'postgresql': 'postgres',
-    'postgres': 'postgres',
-
+    "postgresql": "postgres",
+    "postgres": "postgres",
     # vsftpd
-    'vsftpd': 'vsftpd',
-    'vsftp': 'vsftpd',
-
+    "vsftpd": "vsftpd",
+    "vsftp": "vsftpd",
     # ProFTPD
-    'proftpd': 'proftpd',
-
+    "proftpd": "proftpd",
     # Samba
-    'samba': 'samba',
-    'smbd': 'samba',
-
+    "samba": "samba",
+    "smbd": "samba",
     # Tomcat
-    'apache tomcat': 'tomcat',
-    'tomcat': 'tomcat',
-    'coyote': 'tomcat',
-
+    "apache tomcat": "tomcat",
+    "tomcat": "tomcat",
+    "coyote": "tomcat",
     # WordPress
-    'wordpress': 'wordpress',
-    'wp': 'wordpress',
-
+    "wordpress": "wordpress",
+    "wp": "wordpress",
     # Drupal
-    'drupal': 'drupal',
-
+    "drupal": "drupal",
     # IIS
-    'microsoft-iis': 'iis',
-    'iis': 'iis',
-
+    "microsoft-iis": "iis",
+    "iis": "iis",
     # Node.js/Express
-    'node': 'nodejs',
-    'nodejs': 'nodejs',
-    'express': 'express',
-
+    "node": "nodejs",
+    "nodejs": "nodejs",
+    "express": "express",
     # Redis
-    'redis': 'redis',
-
+    "redis": "redis",
     # MongoDB
-    'mongodb': 'mongodb',
-    'mongo': 'mongodb',
-
+    "mongodb": "mongodb",
+    "mongo": "mongodb",
     # Elasticsearch
-    'elasticsearch': 'elasticsearch',
-    'elastic': 'elasticsearch',
+    "elasticsearch": "elasticsearch",
+    "elastic": "elasticsearch",
 }
 
 
@@ -374,7 +363,7 @@ def normalize_product_name(product: str) -> str:
         normalize_product_name('OpenSSH') -> 'ssh'
     """
     if not product:
-        return ''
+        return ""
 
     product_lower = product.lower().strip()
 
@@ -388,14 +377,10 @@ def normalize_product_name(product: str) -> str:
             return normalized
 
     # Return lowercase if no alias found
-    return product_lower.split('/')[0].split(' ')[0]
+    return product_lower.split("/")[0].split(" ")[0]
 
 
-def check_version_condition(
-    product: str,
-    version: str,
-    condition_spec: str
-) -> bool:
+def check_version_condition(product: str, version: str, condition_spec: str) -> bool:
     """
     Main entry point: check if a product/version matches a condition spec.