airbyte-cdk 0.72.1__py3-none-any.whl → 6.17.1.dev1__py3-none-any.whl

unit_tests/sources/file_based/test_scenarios.py

@@ -1,253 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-import json
-import math
-from pathlib import Path, PosixPath
-from typing import Any, Dict, List, Mapping, Optional, Union
-
-import pytest
-from _pytest.capture import CaptureFixture
-from _pytest.reports import ExceptionInfo
-from airbyte_cdk.entrypoint import launch
-from airbyte_cdk.models import AirbyteAnalyticsTraceMessage, SyncMode
-from airbyte_cdk.sources import AbstractSource
-from airbyte_cdk.sources.file_based.stream.concurrent.cursor import AbstractConcurrentFileBasedCursor
-from airbyte_cdk.test.entrypoint_wrapper import EntrypointOutput
-from airbyte_cdk.test.entrypoint_wrapper import read as entrypoint_read
-from airbyte_cdk.utils import message_utils
-from airbyte_cdk.utils.traced_exception import AirbyteTracedException
-from airbyte_protocol.models import AirbyteLogMessage, AirbyteMessage, ConfiguredAirbyteCatalog
-from unit_tests.sources.file_based.scenarios.scenario_builder import TestScenario
-
-
-def verify_discover(capsys: CaptureFixture[str], tmp_path: PosixPath, scenario: TestScenario[AbstractSource]) -> None:
-    expected_exc, expected_msg = scenario.expected_discover_error
-    expected_logs = scenario.expected_logs
-    if expected_exc:
-        with pytest.raises(expected_exc) as exc:
-            discover(capsys, tmp_path, scenario)
-        if expected_msg:
-            assert expected_msg in get_error_message_from_exc(exc)
-    elif scenario.expected_catalog:
-        output = discover(capsys, tmp_path, scenario)
-        catalog, logs = output["catalog"], output["logs"]
-        assert catalog == scenario.expected_catalog
-        if expected_logs:
-            discover_logs = expected_logs.get("discover")
-            logs = [log for log in logs if log.get("log", {}).get("level") in ("ERROR", "WARN")]
-            _verify_expected_logs(logs, discover_logs)
-
-
-def verify_read(scenario: TestScenario[AbstractSource]) -> None:
-    if scenario.incremental_scenario_config:
-        run_test_read_incremental(scenario)
-    else:
-        run_test_read_full_refresh(scenario)
-
-
-def run_test_read_full_refresh(scenario: TestScenario[AbstractSource]) -> None:
-    expected_exc, expected_msg = scenario.expected_read_error
-    output = read(scenario)
-    if expected_exc:
-        assert_exception(expected_exc, output)
-        if expected_msg:
-            assert expected_msg in output.errors[-1].trace.error.internal_message
-    else:
-        _verify_read_output(output, scenario)
-
-
-def run_test_read_incremental(scenario: TestScenario[AbstractSource]) -> None:
-    expected_exc, expected_msg = scenario.expected_read_error
-    output = read_with_state(scenario)
-    if expected_exc:
-        assert_exception(expected_exc, output)
-    else:
-        _verify_read_output(output, scenario)
-
-
-def assert_exception(expected_exception: type[BaseException], output: EntrypointOutput) -> None:
-    assert expected_exception.__name__ in output.errors[-1].trace.error.stack_trace
-
-
-def _verify_read_output(output: EntrypointOutput, scenario: TestScenario[AbstractSource]) -> None:
-    records_and_state_messages, log_messages = output.records_and_state_messages, output.logs
-    logs = [message.log for message in log_messages if message.log.level.value in scenario.log_levels]
-    if scenario.expected_records is None:
-        return
-
-    expected_records = [r for r in scenario.expected_records] if scenario.expected_records else []
-
-    sorted_expected_records = sorted(
-        filter(lambda e: "data" in e, expected_records),
-        key=lambda record: ",".join(
-            f"{k}={v}" for k, v in sorted(record["data"].items(), key=lambda items: (items[0], items[1])) if k != "emitted_at"
-        ),
-    )
-    sorted_records = sorted(
-        filter(lambda r: r.record, records_and_state_messages),
-        key=lambda record: ",".join(
-            f"{k}={v}" for k, v in sorted(record.record.data.items(), key=lambda items: (items[0], items[1])) if k != "emitted_at"
-        ),
-    )
-
-    assert len(sorted_records) == len(sorted_expected_records)
-
-    for actual, expected in zip(sorted_records, sorted_expected_records):
-        if actual.record:
-            assert len(actual.record.data) == len(expected["data"])
-            for key, value in actual.record.data.items():
-                if isinstance(value, float):
-                    assert math.isclose(value, expected["data"][key], abs_tol=1e-04)
-                else:
-                    assert value == expected["data"][key]
-            assert actual.record.stream == expected["stream"]
-
-    expected_states = list(filter(lambda e: "data" not in e, expected_records))
-    states = list(filter(lambda r: r.state, records_and_state_messages))
-    assert len(states) > 0, "No state messages emitted. Successful syncs should emit at least one stream state."
-    _verify_state_record_counts(sorted_records, states)
-
-    if hasattr(scenario.source, "cursor_cls") and issubclass(scenario.source.cursor_cls, AbstractConcurrentFileBasedCursor):
-        # Only check the last state emitted because we don't know the order the others will be in.
-        # This may be needed for non-file-based concurrent scenarios too.
-        assert states[-1].state.stream.stream_state.dict() == expected_states[-1]
-    else:
-        for actual, expected in zip(states, expected_states):  # states should be emitted in sorted order
-            assert actual.state.stream.stream_state.dict() == expected
-
-    if scenario.expected_logs:
-        read_logs = scenario.expected_logs.get("read")
-        assert len(logs) == (len(read_logs) if read_logs else 0)
-        _verify_expected_logs(logs, read_logs)
-
-    if scenario.expected_analytics:
-        analytics = output.analytics_messages
-
-        _verify_analytics(analytics, scenario.expected_analytics)
-
-
-def _verify_state_record_counts(records: List[AirbyteMessage], states: List[AirbyteMessage]) -> None:
-    actual_record_counts = {}
-    for record in records:
-        stream_descriptor = message_utils.get_stream_descriptor(record)
-        actual_record_counts[stream_descriptor] = actual_record_counts.get(stream_descriptor, 0) + 1
-
-    state_record_count_sums = {}
-    for state_message in states:
-        stream_descriptor = message_utils.get_stream_descriptor(state_message)
-        state_record_count_sums[stream_descriptor] = (
-            state_record_count_sums.get(stream_descriptor, 0)
-            + state_message.state.sourceStats.recordCount
-        )
-
-    for stream, actual_count in actual_record_counts.items():
-        assert state_record_count_sums.get(stream) == actual_count
-
-    # We can have extra keys in state_record_count_sums if we processed a stream and reported 0 records
-    extra_keys = state_record_count_sums.keys() - actual_record_counts.keys()
-    for stream in extra_keys:
-        assert state_record_count_sums[stream] == 0
-
-
-def _verify_analytics(analytics: List[AirbyteMessage], expected_analytics: Optional[List[AirbyteAnalyticsTraceMessage]]) -> None:
-    if expected_analytics:
-        assert len(analytics) == len(
-            expected_analytics), \
-            f"Number of actual analytics messages ({len(analytics)}) did not match expected ({len(expected_analytics)})"
-        for actual, expected in zip(analytics, expected_analytics):
-            actual_type, actual_value = actual.trace.analytics.type, actual.trace.analytics.value
-            expected_type = expected.type
-            expected_value = expected.value
-            assert actual_type == expected_type
-            assert actual_value == expected_value
-
-
-def _verify_expected_logs(logs: List[AirbyteLogMessage], expected_logs: Optional[List[Mapping[str, Any]]]) -> None:
-    if expected_logs:
-        for actual, expected in zip(logs, expected_logs):
-            actual_level, actual_message = actual.level.value, actual.message
-            expected_level = expected["level"]
-            expected_message = expected["message"]
-            assert actual_level == expected_level
-            assert expected_message in actual_message
-
-
-def verify_spec(capsys: CaptureFixture[str], scenario: TestScenario[AbstractSource]) -> None:
-    assert spec(capsys, scenario) == scenario.expected_spec
-
-
-def verify_check(capsys: CaptureFixture[str], tmp_path: PosixPath, scenario: TestScenario[AbstractSource]) -> None:
-    expected_exc, expected_msg = scenario.expected_check_error
-
-    if expected_exc:
-        with pytest.raises(expected_exc):
-            output = check(capsys, tmp_path, scenario)
-            if expected_msg:
-                # expected_msg is a string. what's the expected value field?
-                assert expected_msg in output["message"]  # type: ignore
-                assert output["status"] == scenario.expected_check_status
-
-    else:
-        output = check(capsys, tmp_path, scenario)
-        assert output["status"] == scenario.expected_check_status
-
-
-def spec(capsys: CaptureFixture[str], scenario: TestScenario[AbstractSource]) -> Mapping[str, Any]:
-    launch(
-        scenario.source,
-        ["spec"],
-    )
-    captured = capsys.readouterr()
-    return json.loads(captured.out.splitlines()[0])["spec"]  # type: ignore
-
-
-def check(capsys: CaptureFixture[str], tmp_path: PosixPath, scenario: TestScenario[AbstractSource]) -> Dict[str, Any]:
-    launch(
-        scenario.source,
-        ["check", "--config", make_file(tmp_path / "config.json", scenario.config)],
-    )
-    captured = capsys.readouterr()
-    return json.loads(captured.out.splitlines()[0])["connectionStatus"]  # type: ignore
-
-
-def discover(capsys: CaptureFixture[str], tmp_path: PosixPath, scenario: TestScenario[AbstractSource]) -> Dict[str, Any]:
-    launch(
-        scenario.source,
-        ["discover", "--config", make_file(tmp_path / "config.json", scenario.config)],
-    )
-    output = [json.loads(line) for line in capsys.readouterr().out.splitlines()]
-    [catalog] = [o["catalog"] for o in output if o.get("catalog")]  # type: ignore
-    return {
-        "catalog": catalog,
-        "logs": [o["log"] for o in output if o.get("log")],
-    }
-
-
-def read(scenario: TestScenario[AbstractSource]) -> EntrypointOutput:
-    return entrypoint_read(
-        scenario.source,
-        scenario.config,
-        ConfiguredAirbyteCatalog.parse_obj(scenario.configured_catalog(SyncMode.full_refresh)),
-    )
-
-
-def read_with_state(scenario: TestScenario[AbstractSource]) -> EntrypointOutput:
-    return entrypoint_read(
-        scenario.source,
-        scenario.config,
-        ConfiguredAirbyteCatalog.parse_obj(scenario.configured_catalog(SyncMode.incremental)),
-        scenario.input_state(),
-    )
-
-
-def make_file(path: Path, file_contents: Optional[Union[Mapping[str, Any], List[Mapping[str, Any]]]]) -> str:
-    path.write_text(json.dumps(file_contents))
-    return str(path)
-
-
-def get_error_message_from_exc(exc: ExceptionInfo[Any]) -> str:
-    if isinstance(exc.value, AirbyteTracedException):
-        return exc.value.message
-    return str(exc.value.args[0])

unit_tests/sources/file_based/test_schema_helpers.py

@@ -1,346 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from typing import Any, Mapping, Optional
-
-import pytest
-from airbyte_cdk.sources.file_based.exceptions import ConfigValidationError, SchemaInferenceError
-from airbyte_cdk.sources.file_based.schema_helpers import (
-    ComparableType,
-    SchemaType,
-    conforms_to_schema,
-    merge_schemas,
-    type_mapping_to_jsonschema,
-)
-
-COMPLETE_CONFORMING_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-
-NONCONFORMING_EXTRA_COLUMN_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-    "column_x": "extra",
-}
-
-CONFORMING_WITH_MISSING_COLUMN_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-}
-
-CONFORMING_WITH_NARROWER_TYPE_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": True,
-    "number_field": True,
-    "string_field": True,
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-NONCONFORMING_WIDER_TYPE_RECORD = {
-    "null_field": "not None",
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-NONCONFORMING_NON_OBJECT_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": "not an object",
-}
-
-NONCONFORMING_NON_ARRAY_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": "not an array",
-    "object_field": {"col": "val"},
-}
-
-CONFORMING_MIXED_TYPE_NARROWER_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-NONCONFORMING_MIXED_TYPE_WIDER_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-CONFORMING_MIXED_TYPE_WITHIN_TYPE_RANGE_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "val1",
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-NONCONFORMING_INVALID_ARRAY_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": ["this should not be an array"],
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-NONCONFORMING_TOO_WIDE_ARRAY_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "okay",
-    "array_field": ["val1", "val2"],
-    "object_field": {"col": "val"},
-}
-
-
-CONFORMING_NARROWER_ARRAY_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": "okay",
-    "array_field": [1, 2],
-    "object_field": {"col": "val"},
-}
-
-
-NONCONFORMING_INVALID_OBJECT_RECORD = {
-    "null_field": None,
-    "boolean_field": True,
-    "integer_field": 1,
-    "number_field": 1.5,
-    "string_field": {"this": "should not be an object"},
-    "array_field": [1.1, 2.2],
-    "object_field": {"col": "val"},
-}
-
-
-SCHEMA = {
-    "type": "object",
-    "properties": {
-        "null_field": {"type": "null"},
-        "boolean_field": {"type": "boolean"},
-        "integer_field": {"type": "integer"},
-        "number_field": {"type": "number"},
-        "string_field": {"type": "string"},
-        "array_field": {
-            "type": "array",
-            "items": {
-                "type": "number",
-            },
-        },
-        "object_field": {"type": "object"},
-    },
-}
-
-
-@pytest.mark.parametrize(
-    "record,schema,expected_result",
-    [
-        pytest.param(COMPLETE_CONFORMING_RECORD, SCHEMA, True, id="record-conforms"),
-        pytest.param(NONCONFORMING_EXTRA_COLUMN_RECORD, SCHEMA, False, id="nonconforming-extra-column"),
-        pytest.param(CONFORMING_WITH_MISSING_COLUMN_RECORD, SCHEMA, True, id="record-conforms-with-missing-column"),
-        pytest.param(CONFORMING_WITH_NARROWER_TYPE_RECORD, SCHEMA, True, id="record-conforms-with-narrower-type"),
-        pytest.param(NONCONFORMING_WIDER_TYPE_RECORD, SCHEMA, False, id="nonconforming-wider-type"),
-        pytest.param(NONCONFORMING_NON_OBJECT_RECORD, SCHEMA, False, id="nonconforming-string-is-not-an-object"),
-        pytest.param(NONCONFORMING_NON_ARRAY_RECORD, SCHEMA, False, id="nonconforming-string-is-not-an-array"),
-        pytest.param(NONCONFORMING_TOO_WIDE_ARRAY_RECORD, SCHEMA, False, id="nonconforming-array-values-too-wide"),
-        pytest.param(CONFORMING_NARROWER_ARRAY_RECORD, SCHEMA, True, id="conforming-array-values-narrower-than-schema"),
-        pytest.param(NONCONFORMING_INVALID_ARRAY_RECORD, SCHEMA, False, id="nonconforming-array-is-not-a-string"),
-        pytest.param(NONCONFORMING_INVALID_OBJECT_RECORD, SCHEMA, False, id="nonconforming-object-is-not-a-string"),
-    ],
-)
-def test_conforms_to_schema(record: Mapping[str, Any], schema: Mapping[str, Any], expected_result: bool) -> None:
-    assert conforms_to_schema(record, schema) == expected_result
-
-
-def test_comparable_types() -> None:
-    assert ComparableType.OBJECT > ComparableType.STRING
-    assert ComparableType.STRING > ComparableType.NUMBER
-    assert ComparableType.NUMBER > ComparableType.INTEGER
-    assert ComparableType.INTEGER > ComparableType.BOOLEAN
-    assert ComparableType["OBJECT"] == ComparableType.OBJECT
-
-
-@pytest.mark.parametrize(
-    "schema1,schema2,expected_result",
-    [
-        pytest.param({}, {}, {}, id="empty-schemas"),
-        pytest.param({"a": None}, {}, None, id="null-value-in-schema"),
-        pytest.param({"a": {"type": "integer"}}, {}, {"a": {"type": "integer"}}, id="single-key-schema1"),
-        pytest.param({}, {"a": {"type": "integer"}}, {"a": {"type": "integer"}}, id="single-key-schema2"),
-        pytest.param({"a": {"type": "integer"}}, {"a": {"type": "integer"}}, {"a": {"type": "integer"}}, id="single-key-both-schemas"),
-        pytest.param({"a": {"type": "integer"}}, {"a": {"type": "number"}}, {"a": {"type": "number"}}, id="single-key-schema2-is-wider"),
-        pytest.param({"a": {"type": "number"}}, {"a": {"type": "integer"}}, {"a": {"type": "number"}}, id="single-key-schema1-is-wider"),
-        pytest.param({"a": {"type": "array"}}, {"a": {"type": "integer"}}, None, id="single-key-with-array-schema1"),
-        pytest.param({"a": {"type": "integer"}}, {"a": {"type": "array"}}, None, id="single-key-with-array-schema2"),
-        pytest.param(
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            id="single-key-same-object",
-        ),
-        pytest.param(
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            {"a": {"type": "object", "properties": {"b": {"type": "string"}}}},
-            None,
-            id="single-key-different-objects",
-        ),
-        pytest.param(
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            {"a": {"type": "number"}},
-            None,
-            id="single-key-with-object-schema1",
-        ),
-        pytest.param(
-            {"a": {"type": "number"}},
-            {"a": {"type": "object", "properties": {"b": {"type": "integer"}}}},
-            None,
-            id="single-key-with-object-schema2",
-        ),
-        pytest.param(
-            {"a": {"type": "array", "items": {"type": "number"}}},
-            {"a": {"type": "array", "items": {"type": "number"}}},
-            {"a": {"type": "array", "items": {"type": "number"}}},
-            id="equal-arrays-in-both-schemas",
-        ),
-        pytest.param(
-            {"a": {"type": "array", "items": {"type": "integer"}}},
-            {"a": {"type": "array", "items": {"type": "number"}}},
-            None,
-            id="different-arrays-in-both-schemas",
-        ),
-        pytest.param(
-            {"a": {"type": "integer"}, "b": {"type": "string"}},
-            {"c": {"type": "number"}},
-            {"a": {"type": "integer"}, "b": {"type": "string"}, "c": {"type": "number"}},
-            id="",
-        ),
-        pytest.param({"a": {"type": "invalid_type"}}, {"b": {"type": "integer"}}, None, id="invalid-type"),
-    ],
-)
-def test_merge_schemas(schema1: SchemaType, schema2: SchemaType, expected_result: Optional[SchemaType]) -> None:
-    if expected_result is not None:
-        assert merge_schemas(schema1, schema2) == expected_result
-    else:
-        with pytest.raises(SchemaInferenceError):
-            merge_schemas(schema1, schema2)
-
-
-@pytest.mark.parametrize(
-    "type_mapping,expected_schema,expected_exc_msg",
-    [
-        pytest.param(
-            '{"col1": "null", "col2": "array", "col3": "boolean", "col4": "float", "col5": "integer", "col6": "number", "col7": "object", "col8": "string"}',
-            {
-                "type": "object",
-                "properties": {
-                    "col1": {"type": "null"},
-                    "col2": {"type": "array"},
-                    "col3": {"type": "boolean"},
-                    "col4": {"type": "number"},
-                    "col5": {"type": "integer"},
-                    "col6": {"type": "number"},
-                    "col7": {"type": "object"},
-                    "col8": {"type": "string"},
-                },
-            },
-            None,
-            id="valid_all_types",
-        ),
-        pytest.param(
-            '{"col1 ": " string", "col2":  " integer"}',
-            {"type": "object", "properties": {"col1": {"type": "string"}, "col2": {"type": "integer"}}},
-            None,
-            id="valid_extra_spaces",
-        ),
-        pytest.param(
-            "",
-            None,
-            None,
-            id="valid_empty_string",
-        ),
-        pytest.param(
-            '{"col1": "x", "col2": "integer"}',
-            None,
-            "Invalid type 'x' for property 'col1'",
-            id="invalid_type",
-        ),
-        pytest.param(
-            '{"col1": "", "col2": "integer"}',
-            None,
-            "Invalid input schema",
-            id="invalid_missing_type",
-        ),
-        pytest.param(
-            '{"": "string", "col2": "integer"}',
-            None,
-            "Invalid input schema",
-            id="invalid_missing_name",
-        ),
-        pytest.param(
-            '{"type": "object", "properties": {"col1": {"type": "string"}, "col2": {"type": "integer"}}}',
-            None,
-            "Invalid input schema; nested schemas are not supported.",
-            id="invalid_nested_input_string",
-        ),
-        pytest.param(
-            '{"type": "object", "properties": {"col1": {"type": "string"}, "col2": {"type": "integer"}}}',
-            None,
-            "Invalid input schema; nested schemas are not supported.",
-            id="invalid_nested_input_json",
-        ),
-    ],
-)
-def test_type_mapping_to_jsonschema(
-    type_mapping: Mapping[str, Any], expected_schema: Optional[Mapping[str, Any]], expected_exc_msg: Optional[str]
-) -> None:
-    if expected_exc_msg:
-        with pytest.raises(ConfigValidationError) as exc:
-            type_mapping_to_jsonschema(type_mapping)
-        assert expected_exc_msg in exc.value.args[0]
-    else:
-        assert type_mapping_to_jsonschema(type_mapping) == expected_schema

unit_tests/sources/fixtures/__init__.py

@@ -1,3 +0,0 @@
-#
-# Copyright (c) 2021 Airbyte, Inc., all rights reserved.
-#