Apache Airflow Providers Jira (Deprecated)

# Deprecated imports (still work but show warnings)
from airflow.providers.jira.hooks.jira import JiraHook
from airflow.providers.jira.operators.jira import JiraOperator
from airflow.providers.jira.sensors.jira import JiraSensor, JiraTicketSensor

# Direct package import (deprecated)
import airflow.providers.jira

import warnings
from airflow.providers.jira.hooks.jira import JiraHook
from airflow.providers.jira.operators.jira import JiraOperator
from airflow.providers.jira.sensors.jira import JiraSensor

# Usage will trigger deprecation warnings
with warnings.catch_warnings():
    warnings.simplefilter("ignore", DeprecationWarning)
    
    # Create a Jira hook connection
    jira_hook = JiraHook(jira_conn_id='jira_default')
    
    # Use in a DAG operator
    jira_operator = JiraOperator(
        task_id='create_jira_ticket',
        jira_method='create_issue',
        jira_method_args={'fields': {'project': {'key': 'TEST'}, 'summary': 'Test Issue'}},
        dag=dag
    )
    
    # Use JiraSensor (generic sensor)
    jira_sensor = JiraSensor(
        task_id='check_jira_issue',
        jira_conn_id='jira_default',
        method_name='issue',
        method_params={'id': 'TEST-123', 'fields': 'status'},
        dag=dag
    )
    
    # Use JiraTicketSensor (specific ticket monitoring)
    jira_ticket_sensor = JiraTicketSensor(
        task_id='wait_for_jira_ticket',
        jira_conn_id='jira_default',
        ticket_id='TEST-123',
        field='status',
        expected_value='Done',
        dag=dag
    )

# New recommended imports
from airflow.providers.atlassian.jira.hooks.jira import JiraHook
from airflow.providers.atlassian.jira.operators.jira import JiraOperator
from airflow.providers.atlassian.jira.sensors.jira import JiraSensor, JiraTicketSensor

class JiraHook(BaseHook):
    """
    Re-exported from airflow.providers.atlassian.jira.hooks.jira.JiraHook
    
    Jira interaction hook, a wrapper around JIRA Python SDK.
    Deprecated: Use airflow.providers.atlassian.jira.hooks.jira.JiraHook instead.
    
    Args:
        jira_conn_id (str): Reference to a pre-defined Jira Connection (default: 'jira_default')
        proxies (Any | None): Proxy configuration for JIRA client
    """
    
    default_conn_name: str = 'jira_default'
    conn_type: str = "jira"
    conn_name_attr: str = "jira_conn_id"
    hook_name: str = "JIRA"
    
    def __init__(self, jira_conn_id: str = default_conn_name, proxies: Any | None = None) -> None: ...
    
    def get_conn(self) -> JIRA:
        """
        Returns connection to JIRA client.
        
        Returns:
            JIRA: Authenticated JIRA client instance
            
        Raises:
            AirflowException: If connection cannot be established
        """

class JiraOperator(BaseOperator):
    """
    Re-exported from airflow.providers.atlassian.jira.operators.jira.JiraOperator
    
    JiraOperator to interact and perform action on Jira issue tracking system.
    This operator is designed to use Jira Python SDK: http://jira.readthedocs.io
    Deprecated: Use airflow.providers.atlassian.jira.operators.jira.JiraOperator instead.
    
    Args:
        jira_conn_id (str): Reference to a pre-defined Jira Connection (default: 'jira_default')
        jira_method (str): Method name from Jira Python SDK to be called
        jira_method_args (dict | None): Required method parameters for the jira_method (templated)
        result_processor (Callable | None): Function to further process the response from Jira
        get_jira_resource_method (Callable | None): Function or operator to get jira resource
                                                   on which the provided jira_method will be executed
    """
    
    template_fields: Sequence[str] = ("jira_method_args",)
    
    def __init__(
        self,
        *,
        jira_method: str,
        jira_conn_id: str = 'jira_default',
        jira_method_args: dict | None = None,
        result_processor: Callable | None = None,
        get_jira_resource_method: Callable | None = None,
        **kwargs,
    ) -> None: ...
    
    def execute(self, context: Context) -> Any:
        """
        Execute the Jira method with provided arguments.
        
        Args:
            context: Airflow task context
            
        Returns:
            Any: Result from Jira method call, optionally processed by result_processor
            
        Raises:
            AirflowException: If Jira operation fails
        """

class JiraSensor(BaseSensorOperator):
    """
    Re-exported from airflow.providers.atlassian.jira.sensors.jira.JiraSensor
    
    Monitors a jira ticket for any change.
    Deprecated: Use airflow.providers.atlassian.jira.sensors.jira.JiraSensor instead.
    
    Args:
        jira_conn_id (str): Reference to a pre-defined Jira Connection (default: 'jira_default')
        method_name (str): Method name from jira-python-sdk to be executed
        method_params (dict | None): Parameters for the method method_name
        result_processor (Callable | None): Function that returns boolean and acts as a sensor response
    """
    
    def __init__(
        self,
        *,
        method_name: str,
        jira_conn_id: str = 'jira_default',
        method_params: dict | None = None,
        result_processor: Callable | None = None,
        **kwargs,
    ) -> None: ...
    
    def poke(self, context: Context) -> Any:
        """
        Poke method to check Jira resource state.
        
        Args:
            context: Airflow task context
            
        Returns:
            Any: Result from Jira method call, optionally processed by result_processor
        """

class JiraTicketSensor(JiraSensor):
    """
    Re-exported from airflow.providers.atlassian.jira.sensors.jira.JiraTicketSensor
    
    Monitors a jira ticket for given change in terms of function.
    Deprecated: Use airflow.providers.atlassian.jira.sensors.jira.JiraTicketSensor instead.
    
    Args:
        jira_conn_id (str): Reference to a pre-defined Jira Connection (default: 'jira_default')
        ticket_id (str | None): ID of the ticket to be monitored
        field (str | None): Field of the ticket to be monitored
        expected_value (str | None): Expected value of the field
        field_checker_func (Callable | None): Custom function to check field values
    """
    
    template_fields: Sequence[str] = ("ticket_id",)
    
    def __init__(
        self,
        *,
        jira_conn_id: str = 'jira_default',
        ticket_id: str | None = None,
        field: str | None = None,
        expected_value: str | None = None,
        field_checker_func: Callable | None = None,
        **kwargs,
    ) -> None: ...
    
    def poke(self, context: Context) -> Any:
        """
        Poke method to check specific Jira ticket field.
        
        Args:
            context: Airflow task context
            
        Returns:
            Any: Result from field checker or default issue field checker
        """
    
    def issue_field_checker(self, issue: Issue) -> bool | None:
        """
        Check issue using different conditions to prepare to evaluate sensor.
        
        Args:
            issue: Jira Issue object
            
        Returns:
            bool | None: True if field matches expected value, False/None otherwise
        """

warnings.warn(
    "This module is deprecated. Please use `airflow.providers.atlassian.jira.*`.",
    DeprecationWarning,
    stacklevel=2,
)

# Re-exported types from underlying dependencies
from typing import Any, Callable, Sequence
from jira import JIRA
from jira.resources import Issue
from airflow.hooks.base import BaseHook
from airflow.models import BaseOperator
from airflow.sensors.base import BaseSensorOperator
from airflow.utils.context import Context
from airflow.exceptions import AirflowException
from jira.exceptions import JIRAError