0
# Provider Verification
1

2
Decorators and utilities for enforcing minimum version requirements of provider packages and optional dependencies. These functions ensure that required provider versions are available before executing code that depends on them.
3

4
## Capabilities
5

6
### Provider Version Enforcement
7

8
Decorator that enforces minimum version requirements for Airflow provider packages.
9

10
```python { .api }
11
def require_provider_version(provider_name: str, provider_min_version: str):
12
    """
13
    Decorator to enforce minimum provider version requirements.
14
    
15
    Args:
16
        provider_name (str): Full provider package name (e.g., "apache-airflow-providers-openlineage")
17
        provider_min_version (str): Minimum version requirement (e.g., "1.0.1")
18
    
19
    Returns:
20
        Decorator function that checks version before execution
21
        
22
    Raises:
23
        ValueError: If provider_name or provider_min_version is invalid
24
        TypeError: If arguments are not strings
25
        AirflowOptionalProviderFeatureException: If provider version requirement not met
26
    """
27
```
28

29
### OpenLineage Version Enforcement
30

31
Specialized decorator for enforcing OpenLineage provider and client version requirements.
32

33
```python { .api }
34
def require_openlineage_version(
35
    provider_min_version: str | None = None, 
36
    client_min_version: str | None = None
37
):
38
    """
39
    Decorator to enforce minimum OpenLineage version requirements.
40
    
41
    Args:
42
        provider_min_version (str, optional): Minimum version for apache-airflow-providers-openlineage
43
        client_min_version (str, optional): Minimum version for openlineage-python client
44
    
45
    Returns:
46
        Decorator function that checks versions before execution
47
        
48
    Raises:
49
        ValueError: If version strings are invalid
50
        TypeError: If arguments are not strings or None
51
        AirflowOptionalProviderFeatureException: If version requirements not met
52
    """
53
```
54

55
## Usage Examples
56

57
```python
58
from airflow.providers.common.compat.check import require_provider_version
59
from airflow.providers.common.compat.openlineage.check import require_openlineage_version
60

61
# Require specific provider version
62
@require_provider_version("apache-airflow-providers-postgres", "5.0.0")
63
def use_postgres_features():
64
    from airflow.providers.postgres.operators.postgres import PostgresOperator
65
    # Code that requires PostgreSQL provider v5.0.0+
66
    return PostgresOperator(...)
67

68
# Require OpenLineage provider version
69
@require_openlineage_version(provider_min_version="1.2.0")
70
def use_openlineage_features():
71
    from airflow.providers.openlineage.extractors import BaseExtractor
72
    # Code that requires OpenLineage provider v1.2.0+
73
    return BaseExtractor()
74

75
# Require both provider and client versions
76
@require_openlineage_version(
77
    provider_min_version="1.2.0",
78
    client_min_version="0.28.0"
79
)
80
def use_advanced_openlineage():
81
    from openlineage.client import OpenLineageClient
82
    from airflow.providers.openlineage.plugins.listener import OpenLineageListener
83
    # Code requiring both provider and client versions
84
    pass
85

86
# Use in operator classes
87
class MyCustomOperator(BaseOperator):
88
    @require_provider_version("apache-airflow-providers-http", "4.0.0")
89
    def execute(self, context):
90
        from airflow.providers.http.operators.http import HttpOperator
91
        # Implementation using HTTP provider features
92
        pass
93

94
# Chain multiple version requirements
95
@require_provider_version("apache-airflow-providers-postgres", "5.0.0")
96
@require_openlineage_version(provider_min_version="1.0.0")
97
def complex_data_pipeline():
98
    # Code that needs both providers
99
    pass
100
```