Function should_skip_object

qa/workunits/dencoder/test_readable.py:151–210

Determine if an object should be skipped based on backward compatibility. Args: type (str): The type of the object to check. arversion (str): The archive version of the object. current_ver (str): The current version of the decoder. Returns: bool: True i

(type, arversion, current_ver)

def should_skip_object(type, arversion, current_ver):
    """
    Determine if an object should be skipped based on backward compatibility.

    Args:
        type (str): The type of the object to check.
        arversion (str): The archive version of the object.
        current_ver (str): The current version of the decoder.

    Returns:
        bool: True if the object should be skipped, False otherwise.
    """

    # Validate global structures
    if not isinstance(backward_compat, dict) or not isinstance(fast_shouldnt_skip, list):
        raise ValueError("Global variables 'backward_compat' must be a dict and 'fast_shouldnt_skip' must be a list.")

    # Early return for cached types
    if type in fast_shouldnt_skip:
        debug_print(f"fast Type {type} is in the fast_shouldnt_skip list - don't skip.")
        return False

    # If the type doesn't exist in any backward_compat entry
    if all(type not in v for v in backward_compat.values()):
        debug_print(f"fast Type {type} does not exist in the backward compatibility structure - don't skip.")
        fast_shouldnt_skip.append(type)
        return False

    # Parse current and archive versions
    parsed_arversion = parse_version(arversion)
    parsed_current_ver = parse_version(current_ver)

    # Find the lowest version where the type exists
    compatible_versions = [
        parse_version(key) for key, types in backward_compat.items() if type in types
    ]
    if not compatible_versions:
        debug_print(f"{type} has no compatible versions - don't skip.")
        fast_shouldnt_skip.append(type)
        return False

    lowest_version = min(compatible_versions)
    debug_print(f"{type} lowest compatible version: {lowest_version}")

    # Check cascading compatibility
    if parsed_current_ver < lowest_version:
        # Current version is too old for this type
        debug_print(f"{type} current version {parsed_current_ver} is less than {lowest_version} - skip.")
        return True

    # Filter archive versions within compatibility range
    versions = [
        key for key in backward_compat
        if type in backward_compat[key]
        and parse_version(key) >= parsed_arversion
        and parse_version(key) <= parsed_current_ver
    ]