apache-flink 2.1.0__tar.gz → 2.2.0__tar.gz

{apache_flink-2.1.0/apache_flink.egg-info → apache_flink-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-flink
-Version: 2.1.0
+Version: 2.2.0
 Summary: Apache Flink Python API
 Home-page: https://flink.apache.org
 Author: Apache Software Foundation
@@ -25,12 +25,12 @@ Requires-Dist: fastavro!=1.8.0,>=1.1.0
 Requires-Dist: requests>=2.26.0
 Requires-Dist: protobuf>=3.19.0
 Requires-Dist: numpy>=1.22.4
-Requires-Dist: pandas>=1.3.0
+Requires-Dist: pandas<2.3,>=1.3.0
 Requires-Dist: pyarrow<21.0.0,>=5.0.0
-Requires-Dist: pemja<0.5.4,>=0.5.0; platform_system != "Windows"
+Requires-Dist: pemja<0.5.6,>=0.5.5; platform_system != "Windows"
 Requires-Dist: httplib2>=0.19.0
 Requires-Dist: ruamel.yaml>=0.18.4
-Requires-Dist: apache-flink-libraries<2.1.1,>=2.1.0
+Requires-Dist: apache-flink-libraries<2.2.1,>=2.2.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -112,6 +112,6 @@ Then you can activate your environment and run tests, for example:
 
 ```shell
 source pyflink_39/bin/activate
-uv pip install -r ./dev/dev-requirements.txt
+uv pip install --group dev
 ./dev/lint-python.sh
 ```

{apache_flink-2.1.0 → apache_flink-2.2.0}/README.md

@@ -67,6 +67,6 @@ Then you can activate your environment and run tests, for example:
 
 ```shell
 source pyflink_39/bin/activate
-uv pip install -r ./dev/dev-requirements.txt
+uv pip install --group dev
 ./dev/lint-python.sh
 ```

{apache_flink-2.1.0 → apache_flink-2.2.0/apache_flink.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-flink
-Version: 2.1.0
+Version: 2.2.0
 Summary: Apache Flink Python API
 Home-page: https://flink.apache.org
 Author: Apache Software Foundation
@@ -25,12 +25,12 @@ Requires-Dist: fastavro!=1.8.0,>=1.1.0
 Requires-Dist: requests>=2.26.0
 Requires-Dist: protobuf>=3.19.0
 Requires-Dist: numpy>=1.22.4
-Requires-Dist: pandas>=1.3.0
+Requires-Dist: pandas<2.3,>=1.3.0
 Requires-Dist: pyarrow<21.0.0,>=5.0.0
-Requires-Dist: pemja<0.5.4,>=0.5.0; platform_system != "Windows"
+Requires-Dist: pemja<0.5.6,>=0.5.5; platform_system != "Windows"
 Requires-Dist: httplib2>=0.19.0
 Requires-Dist: ruamel.yaml>=0.18.4
-Requires-Dist: apache-flink-libraries<2.1.1,>=2.1.0
+Requires-Dist: apache-flink-libraries<2.2.1,>=2.2.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -112,6 +112,6 @@ Then you can activate your environment and run tests, for example:
 
 ```shell
 source pyflink_39/bin/activate
-uv pip install -r ./dev/dev-requirements.txt
+uv pip install --group dev
 ./dev/lint-python.sh
 ```

{apache_flink-2.1.0 → apache_flink-2.2.0}/apache_flink.egg-info/SOURCES.txt

@@ -53,8 +53,10 @@ deps/examples/datastream/process_json_data.py
 deps/examples/datastream/state_access.py
 deps/examples/datastream/streaming_word_count.py
 deps/examples/datastream/word_count.py
+deps/examples/datastream/asyncio/remote_model_inference.py
 deps/examples/datastream/connectors/elasticsearch.py
 deps/examples/datastream/connectors/kafka_avro_format.py
+deps/examples/datastream/connectors/kafka_bytearray_format.py
 deps/examples/datastream/connectors/kafka_csv_format.py
 deps/examples/datastream/connectors/kafka_json_format.py
 deps/examples/datastream/connectors/pulsar.py
@@ -108,6 +110,9 @@ pyflink/common/types.py
 pyflink/common/utils.py
 pyflink/common/watermark_strategy.py
 pyflink/datastream/__init__.py
+pyflink/datastream/async_data_stream.py
+pyflink/datastream/async_retry_predicates.py
+pyflink/datastream/async_retry_strategies.py
 pyflink/datastream/checkpoint_config.py
 pyflink/datastream/checkpoint_storage.py
 pyflink/datastream/checkpointing_mode.py
@@ -193,6 +198,9 @@ pyflink/fn_execution/datastream/process/operations.py
 pyflink/fn_execution/datastream/process/process_function.py
 pyflink/fn_execution/datastream/process/runtime_context.py
 pyflink/fn_execution/datastream/process/timerservice_impl.py
+pyflink/fn_execution/datastream/process/async_function/__init__.py
+pyflink/fn_execution/datastream/process/async_function/operation.py
+pyflink/fn_execution/datastream/process/async_function/queue.py
 pyflink/fn_execution/datastream/window/__init__.py
 pyflink/fn_execution/datastream/window/merging_window_set.py
 pyflink/fn_execution/datastream/window/window_operator.py

{apache_flink-2.1.0 → apache_flink-2.2.0}/apache_flink.egg-info/requires.txt

@@ -8,11 +8,11 @@ fastavro!=1.8.0,>=1.1.0
 requests>=2.26.0
 protobuf>=3.19.0
 numpy>=1.22.4
-pandas>=1.3.0
+pandas<2.3,>=1.3.0
 pyarrow<21.0.0,>=5.0.0
 httplib2>=0.19.0
 ruamel.yaml>=0.18.4
-apache-flink-libraries<2.1.1,>=2.1.0
+apache-flink-libraries<2.2.1,>=2.2.0
 
 [:platform_system != "Windows"]
-pemja<0.5.4,>=0.5.0
+pemja<0.5.6,>=0.5.5

{apache_flink-2.1.0 → apache_flink-2.2.0}/deps/bin/config.sh

@@ -240,6 +240,8 @@ fi
 
 if [ -z "${MAX_LOG_FILE_NUMBER}" ]; then
     MAX_LOG_FILE_NUMBER=$(readFromConfig ${KEY_ENV_LOG_MAX} ${DEFAULT_ENV_LOG_MAX} "${YAML_CONF}")
+    # Remove leading and ending single quotes (if present) of value
+    MAX_LOG_FILE_NUMBER="$( echo "${MAX_LOG_FILE_NUMBER}" | sed -e "s/^'//"  -e "s/'$//" )"
     export MAX_LOG_FILE_NUMBER
 fi
 

apache_flink-2.2.0/deps/examples/datastream/asyncio/remote_model_inference.py

@@ -0,0 +1,150 @@
+################################################################################
+#  Licensed to the Apache Software Foundation (ASF) under one
+#  or more contributor license agreements.  See the NOTICE file
+#  distributed with this work for additional information
+#  regarding copyright ownership.  The ASF licenses this file
+#  to you under the Apache License, Version 2.0 (the
+#  "License"); you may not use this file except in compliance
+#  with the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+import argparse
+import asyncio
+import functools
+import json
+import logging
+import random
+import sys
+from typing import List
+
+from pyflink.common import Encoder, Types, Time, Row
+from pyflink.datastream import StreamExecutionEnvironment, AsyncDataStream, AsyncFunction, \
+    RuntimeContext, AsyncRetryStrategy, async_retry_predicates, CheckpointingMode
+from pyflink.datastream.connectors.file_system import (FileSink, OutputFileConfig, RollingPolicy)
+from pyflink.table import StreamTableEnvironment, TableDescriptor, Schema, DataTypes
+
+
+class AsyncLLMRequest(AsyncFunction[Row, str]):
+
+    def __init__(self):
+        self.retried_keys = {}
+
+    def open(self, runtime_context: RuntimeContext):
+        # create model inference client here
+        pass
+
+    def close(self):
+        # close the model inference client here
+        pass
+
+    async def async_invoke(self, value: Row) -> List[str]:
+        # issue the asynchronous request
+        await asyncio.sleep(random.randint(1, 2))
+
+        if value.user_id not in self.retried_keys and random.randint(1, 10) % 3 == 0:
+            self.retried_keys[value.user_id] = True
+            # remote model inference request may time out
+            raise TimeoutError
+        else:
+            if value.user_id in self.retried_keys:
+                del self.retried_keys[value.user_id]
+            # remote model inference request completes
+            # note that the result should be a collection even there is only one result
+            analysis_result = "positive"
+            result = {
+                "user_id": value.user_id,
+                "comments": value.comments,
+                "analysis_result": analysis_result
+            }
+            return [json.dumps(result)]
+
+    def timeout(self, value: Row) -> List[str]:
+        # return a default value in case timeout
+        result = {
+            "user_id": value.user_id,
+            "comments": value.comments,
+            "analysis_result": None
+        }
+        return [json.dumps(result)]
+
+
+def main(output_path):
+    env = StreamExecutionEnvironment.get_execution_environment()
+    env.enable_checkpointing(30000, CheckpointingMode.EXACTLY_ONCE)
+    t_env = StreamTableEnvironment.create(stream_execution_environment=env)
+
+    # source: user_id, comments
+    t_env.create_temporary_table(
+        'source',
+        TableDescriptor.for_connector('datagen')
+                       .schema(Schema.new_builder()
+                               .column('user_id', DataTypes.INT())
+                               .column('comments', DataTypes.STRING())
+                               .build())
+                       .option('fields.user_id.kind', 'random')
+                       .option('fields.comments.kind', 'random')
+                       .option('rows-per-second', '100')
+                       .build())
+
+    table = t_env.from_path('source')
+    ds = t_env.to_data_stream(table)
+
+    # create an async retry strategy via utility class or a user defined strategy
+    async_retry_strategy = AsyncRetryStrategy.fixed_delay(
+        max_attempts=100,
+        backoff_time_millis=1000,
+        result_predicate=None,
+        exception_predicate=functools.partial(async_retry_predicates.exception_type_predicate,
+                                              expected_error_type=TimeoutError))
+
+    result_stream = AsyncDataStream.unordered_wait_with_retry(
+        data_stream=ds,
+        async_function=AsyncLLMRequest(),
+        timeout=Time.seconds(10),
+        async_retry_strategy=async_retry_strategy,
+        capacity=1000,
+        output_type=Types.STRING())
+
+    # define the sink
+    if output_path is not None:
+        result_stream.sink_to(
+            sink=FileSink.for_row_format(
+                base_path=output_path,
+                encoder=Encoder.simple_string_encoder())
+            .with_output_file_config(
+                OutputFileConfig.builder()
+                .with_part_prefix("prefix")
+                .with_part_suffix(".ext")
+                .build())
+            .with_rolling_policy(RollingPolicy.default_rolling_policy())
+            .build()
+        )
+    else:
+        print("Printing result to stdout. Use --output to specify output path.")
+        result_stream.print()
+
+    # submit for execution
+    env.execute()
+
+
+if __name__ == '__main__':
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(message)s")
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--output',
+        dest='output',
+        required=False,
+        help='Output file to write results to.')
+
+    argv = sys.argv[1:]
+    known_args, _ = parser.parse_known_args(argv)
+
+    main(known_args.output)

{apache_flink-2.1.0 → apache_flink-2.2.0}/deps/examples/datastream/connectors/kafka_avro_format.py

@@ -18,9 +18,10 @@
 import logging
 import sys
 
-from pyflink.common import Types
+from pyflink.common import Types, WatermarkStrategy
 from pyflink.datastream import StreamExecutionEnvironment
-from pyflink.datastream.connectors.kafka import FlinkKafkaProducer, FlinkKafkaConsumer
+from pyflink.datastream.connectors.kafka import (KafkaRecordSerializationSchema, KafkaSink,
+                                                 KafkaSource, KafkaOffsetsInitializer)
 from pyflink.datastream.formats.avro import AvroRowSerializationSchema, AvroRowDeserializationSchema
 
 
@@ -43,14 +44,20 @@ def write_to_kafka(env):
             }"""
     )
 
-    kafka_producer = FlinkKafkaProducer(
-        topic='test_avro_topic',
-        serialization_schema=serialization_schema,
-        producer_config={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group'}
+    record_serializer = KafkaRecordSerializationSchema.builder() \
+        .set_topic('test_avro_topic') \
+        .set_value_serialization_schema(serialization_schema) \
+        .build()
+    kafka_sink = (
+        KafkaSink.builder()
+        .set_record_serializer(record_serializer)
+        .set_bootstrap_servers('localhost:9092')
+        .set_property("group.id", "test_group")
+        .build()
     )
 
     # note that the output type of ds must be RowTypeInfo
-    ds.add_sink(kafka_producer)
+    ds.sink_to(kafka_sink)
     env.execute()
 
 
@@ -67,14 +74,22 @@ def read_from_kafka(env):
             }"""
     )
 
-    kafka_consumer = FlinkKafkaConsumer(
-        topics='test_avro_topic',
-        deserialization_schema=deserialization_schema,
-        properties={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'}
+    kafka_source = (
+        KafkaSource.builder()
+        .set_topics('test_avro_topic')
+        .set_value_only_deserializer(deserialization_schema)
+        .set_properties({'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'})
+        .set_starting_offsets(KafkaOffsetsInitializer.earliest())
+        .build()
     )
-    kafka_consumer.set_start_from_earliest()
 
-    env.add_source(kafka_consumer).print()
+    ds = env.from_source(
+        kafka_source,
+        watermark_strategy=WatermarkStrategy.no_watermarks(),
+        source_name="kafka source"
+    )
+
+    ds.print()
     env.execute()
 
 

apache_flink-2.2.0/deps/examples/datastream/connectors/kafka_bytearray_format.py

@@ -0,0 +1,102 @@
+################################################################################
+#  Licensed to the Apache Software Foundation (ASF) under one
+#  or more contributor license agreements.  See the NOTICE file
+#  distributed with this work for additional information
+#  regarding copyright ownership.  The ASF licenses this file
+#  to you under the Apache License, Version 2.0 (the
+#  "License"); you may not use this file except in compliance
+#  with the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+import json
+import logging
+import sys
+
+from pyflink.common import Types, ByteArraySchema, WatermarkStrategy
+from pyflink.datastream import StreamExecutionEnvironment
+from pyflink.datastream.connectors.kafka import KafkaSource, \
+    KafkaOffsetsInitializer, KafkaSink, KafkaRecordSerializationSchema
+
+
+# This example works since Flink 2.0 since ByteArraySchema was introduced in Flink 2.0
+
+# Make sure that the Kafka cluster is started and the topic 'test_json_topic' is
+# created before executing this job.
+def write_to_kafka(env):
+    data = [
+        (json.dumps({
+            "id": 1,
+            "country": "USA"
+        }).encode("utf-8"),),
+        (json.dumps({
+            "id": 2,
+            "country": "Canada"
+        }).encode("utf-8"),),
+        (json.dumps({
+            "id": 3,
+            "country": "Germany"
+        }).encode("utf-8"),)
+    ]
+    type_info = Types.ROW([Types.PRIMITIVE_ARRAY(Types.BYTE())])
+    ds = env.from_collection(data, type_info=type_info)
+
+    # declare the output type as Types.PRIMITIVE_ARRAY(Types.BYTE()),
+    # otherwise, Types.PICKLED_BYTE_ARRAY() will be used by default, it will
+    # use pickler to serialize the result byte array which is unnecessary
+    ds = ds.map(lambda x: x[0], output_type=Types.PRIMITIVE_ARRAY(Types.BYTE()))
+
+    record_serializer = KafkaRecordSerializationSchema.builder() \
+        .set_topic('test_bytearray_topic') \
+        .set_value_serialization_schema(ByteArraySchema()) \
+        .build()
+    kafka_sink = (
+        KafkaSink.builder()
+        .set_record_serializer(record_serializer)
+        .set_bootstrap_servers('localhost:9092')
+        .set_property("group.id", "test_group")
+        .build()
+    )
+
+    ds.sink_to(kafka_sink)
+    env.execute()
+
+
+def read_from_kafka(env):
+    kafka_source = (
+        KafkaSource.builder()
+        .set_topics('test_bytearray_topic')
+        .set_value_only_deserializer(ByteArraySchema())
+        .set_properties({'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'})
+        .set_starting_offsets(KafkaOffsetsInitializer.earliest())
+        .build()
+    )
+
+    ds = env.from_source(
+        kafka_source,
+        watermark_strategy=WatermarkStrategy.no_watermarks(),
+        source_name="kafka source"
+    )
+
+    # the data read out from the source is byte array, decode it as a string
+    ds.map(lambda data: data.decode("utf-8")).print()
+    env.execute()
+
+
+if __name__ == '__main__':
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(message)s")
+
+    env = StreamExecutionEnvironment.get_execution_environment()
+    env.add_jars("file:///path/to/flink-sql-connector-kafka-1.15.0.jar")
+
+    print("start writing data to kafka")
+    write_to_kafka(env)
+
+    print("start reading data from kafka")
+    read_from_kafka(env)

{apache_flink-2.1.0 → apache_flink-2.2.0}/deps/examples/datastream/connectors/kafka_csv_format.py

@@ -18,9 +18,10 @@
 import logging
 import sys
 
-from pyflink.common import Types
+from pyflink.common import Types, WatermarkStrategy
 from pyflink.datastream import StreamExecutionEnvironment
-from pyflink.datastream.connectors.kafka import FlinkKafkaProducer, FlinkKafkaConsumer
+from pyflink.datastream.connectors.kafka import (KafkaRecordSerializationSchema, KafkaSink,
+                                                 KafkaSource, KafkaOffsetsInitializer)
 from pyflink.datastream.formats.csv import CsvRowSerializationSchema, CsvRowDeserializationSchema
 
 
@@ -33,14 +34,20 @@ def write_to_kafka(env):
         type_info=type_info)
 
     serialization_schema = CsvRowSerializationSchema.Builder(type_info).build()
-    kafka_producer = FlinkKafkaProducer(
-        topic='test_csv_topic',
-        serialization_schema=serialization_schema,
-        producer_config={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group'}
+    record_serializer = KafkaRecordSerializationSchema.builder() \
+        .set_topic('test_csv_topic') \
+        .set_value_serialization_schema(serialization_schema) \
+        .build()
+    kafka_sink = (
+        KafkaSink.builder()
+        .set_record_serializer(record_serializer)
+        .set_bootstrap_servers('localhost:9092')
+        .set_property("group.id", "test_group")
+        .build()
     )
 
     # note that the output type of ds must be RowTypeInfo
-    ds.add_sink(kafka_producer)
+    ds.sink_to(kafka_sink)
     env.execute()
 
 
@@ -48,14 +55,22 @@ def read_from_kafka(env):
     type_info = Types.ROW([Types.INT(), Types.STRING()])
     deserialization_schema = CsvRowDeserializationSchema.Builder(type_info).build()
 
-    kafka_consumer = FlinkKafkaConsumer(
-        topics='test_csv_topic',
-        deserialization_schema=deserialization_schema,
-        properties={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'}
+    kafka_source = (
+        KafkaSource.builder()
+        .set_topics('test_csv_topic')
+        .set_value_only_deserializer(deserialization_schema)
+        .set_properties({'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'})
+        .set_starting_offsets(KafkaOffsetsInitializer.earliest())
+        .build()
     )
-    kafka_consumer.set_start_from_earliest()
 
-    env.add_source(kafka_consumer).print()
+    ds = env.from_source(
+        kafka_source,
+        watermark_strategy=WatermarkStrategy.no_watermarks(),
+        source_name="kafka source"
+    )
+
+    ds.print()
     env.execute()
 
 

{apache_flink-2.1.0 → apache_flink-2.2.0}/deps/examples/datastream/connectors/kafka_json_format.py

@@ -18,9 +18,10 @@
 import logging
 import sys
 
-from pyflink.common import Types
+from pyflink.common import Types, WatermarkStrategy
 from pyflink.datastream import StreamExecutionEnvironment
-from pyflink.datastream.connectors.kafka import FlinkKafkaProducer, FlinkKafkaConsumer
+from pyflink.datastream.connectors.kafka import (KafkaRecordSerializationSchema, KafkaSink,
+                                                 KafkaSource, KafkaOffsetsInitializer)
 from pyflink.datastream.formats.json import JsonRowSerializationSchema, JsonRowDeserializationSchema
 
 
@@ -35,14 +36,20 @@ def write_to_kafka(env):
     serialization_schema = JsonRowSerializationSchema.Builder() \
         .with_type_info(type_info) \
         .build()
-    kafka_producer = FlinkKafkaProducer(
-        topic='test_json_topic',
-        serialization_schema=serialization_schema,
-        producer_config={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group'}
+    record_serializer = KafkaRecordSerializationSchema.builder() \
+        .set_topic('test_json_topic') \
+        .set_value_serialization_schema(serialization_schema) \
+        .build()
+    kafka_sink = (
+        KafkaSink.builder()
+        .set_record_serializer(record_serializer)
+        .set_bootstrap_servers('localhost:9092')
+        .set_property("group.id", "test_group")
+        .build()
     )
 
     # note that the output type of ds must be RowTypeInfo
-    ds.add_sink(kafka_producer)
+    ds.sink_to(kafka_sink)
     env.execute()
 
 
@@ -50,14 +57,22 @@ def read_from_kafka(env):
     deserialization_schema = JsonRowDeserializationSchema.Builder() \
         .type_info(Types.ROW([Types.INT(), Types.STRING()])) \
         .build()
-    kafka_consumer = FlinkKafkaConsumer(
-        topics='test_json_topic',
-        deserialization_schema=deserialization_schema,
-        properties={'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'}
+    kafka_source = (
+        KafkaSource.builder()
+        .set_topics('test_json_topic')
+        .set_value_only_deserializer(deserialization_schema)
+        .set_properties({'bootstrap.servers': 'localhost:9092', 'group.id': 'test_group_1'})
+        .set_starting_offsets(KafkaOffsetsInitializer.earliest())
+        .build()
+    )
+
+    ds = env.from_source(
+        kafka_source,
+        watermark_strategy=WatermarkStrategy.no_watermarks(),
+        source_name="kafka source"
     )
-    kafka_consumer.set_start_from_earliest()
 
-    env.add_source(kafka_consumer).print()
+    ds.print()
     env.execute()
 
 

{apache_flink-2.1.0 → apache_flink-2.2.0}/pyflink/datastream/__init__.py

@@ -82,6 +82,8 @@ Functions used to transform a :class:`DataStream` into another :class:`DataStrea
     - :class:`KeyedBroadcastProcessFunction`:
       A function to be applied to a :class:`BroadcastConnectedStream` that connects
       :class:`BroadcastStream`, i.e. a stream with broadcast state, with a :class:`KeyedStream`.
+    - :class:`AsyncFunction`:
+      A function to trigger Async I/O operation.
     - :class:`RuntimeContext`:
       Contains information about the context in which functions are executed. Each
       parallel instance of the function will have a context through which it can access static
@@ -256,6 +258,7 @@ Other important classes:
     - :class:`OutputTag`:
       Tag with a name and type for identifying side output of an operator
 """
+from pyflink.datastream.async_data_stream import AsyncDataStream
 from pyflink.datastream.checkpoint_config import CheckpointConfig
 from pyflink.datastream.externalized_checkpoint_retention import ExternalizedCheckpointRetention
 from pyflink.datastream.checkpointing_mode import CheckpointingMode
@@ -268,7 +271,8 @@ from pyflink.datastream.functions import (MapFunction, CoMapFunction, FlatMapFun
                                           SinkFunction, CoProcessFunction, KeyedProcessFunction,
                                           KeyedCoProcessFunction, AggregateFunction, WindowFunction,
                                           ProcessWindowFunction, BroadcastProcessFunction,
-                                          KeyedBroadcastProcessFunction)
+                                          KeyedBroadcastProcessFunction, AsyncFunction,
+                                          AsyncRetryPredicate, AsyncRetryStrategy)
 from pyflink.datastream.slot_sharing_group import SlotSharingGroup, MemorySize
 from pyflink.datastream.state_backend import (StateBackend, CustomStateBackend,
                                               PredefinedOptions, HashMapStateBackend,
@@ -292,6 +296,7 @@ __all__ = [
     'ConnectedStreams',
     'BroadcastStream',
     'BroadcastConnectedStream',
+    'AsyncDataStream',
     'DataStreamSink',
     'MapFunction',
     'CoMapFunction',
@@ -308,6 +313,7 @@ __all__ = [
     'AggregateFunction',
     'BroadcastProcessFunction',
     'KeyedBroadcastProcessFunction',
+    'AsyncFunction',
     'RuntimeContext',
     'TimerService',
     'CheckpointingMode',
@@ -338,5 +344,7 @@ __all__ = [
     'SinkFunction',
     'SlotSharingGroup',
     'MemorySize',
-    'OutputTag'
+    'OutputTag',
+    'AsyncRetryPredicate',
+    'AsyncRetryStrategy'
 ]