unstructured-ingest 0.5.9__py3-none-any.whl → 0.5.10__py3-none-any.whl

test/integration/connectors/test_dropbox.py

@@ -0,0 +1,151 @@
+import os
+
+import pytest
+import requests
+
+from test.integration.connectors.utils.constants import (
+    BLOB_STORAGE_TAG,
+    SOURCE_TAG,
+)
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
+    source_connector_validation,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.v2.processes.connectors.fsspec.dropbox import (
+    CONNECTOR_TYPE as DROPBOX_CONNECTOR_TYPE,
+)
+from unstructured_ingest.v2.processes.connectors.fsspec.dropbox import (
+    DropboxAccessConfig,
+    DropboxConnectionConfig,
+    DropboxDownloader,
+    DropboxDownloaderConfig,
+    DropboxIndexer,
+    DropboxIndexerConfig,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(DROPBOX_CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
+@requires_env("DROPBOX_REFRESH_TOKEN", "DROPBOX_APP_KEY", "DROPBOX_APP_SECRET")
+async def test_dropbox_source(temp_dir):
+    """
+    Integration test for the Dropbox source connector.
+
+    This test indexes data from dropbox://test-input/ and downloads the resulting files,
+    then compares them to fixture data.
+    """
+    refresh_token = os.getenv("DROPBOX_REFRESH_TOKEN")
+    app_key = os.getenv("DROPBOX_APP_KEY")
+    app_secret = os.getenv("DROPBOX_APP_SECRET")
+
+    connection_config = DropboxConnectionConfig(
+        access_config=DropboxAccessConfig(
+            refresh_token=refresh_token,
+            app_key=app_key,
+            app_secret=app_secret,
+        )
+    )
+
+    index_config = DropboxIndexerConfig(
+        recursive=True,
+        remote_url="dropbox://test-input",
+    )
+    downloader_config = DropboxDownloaderConfig(download_dir=temp_dir)
+
+    indexer = DropboxIndexer(
+        connection_config=connection_config,
+        index_config=index_config,
+    )
+    downloader = DropboxDownloader(
+        connection_config=connection_config,
+        download_config=downloader_config,
+    )
+
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="dropbox",
+            expected_num_files=4,
+            validate_downloaded_files=True,
+            exclude_fields_extend=[
+                "metadata.date_created",
+                "metadata.date_modified",
+            ],
+        ),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(DROPBOX_CONNECTOR_TYPE, SOURCE_TAG, BLOB_STORAGE_TAG)
+@requires_env("DROPBOX_REFRESH_TOKEN", "DROPBOX_APP_KEY", "DROPBOX_APP_SECRET")
+async def test_dropbox_short_lived_token_via_refresh(temp_dir):
+    """
+    Demonstrates manually generating an access token from refresh credentials,
+    then passing ONLY the short-lived token to the Dropbox connector
+    (no app_key, app_secret, or refresh_token in the actual connection config).
+
+    This effectively mimics an external system that hands us a short-lived token.
+    """
+    refresh_token = os.getenv("DROPBOX_REFRESH_TOKEN")
+    app_key = os.getenv("DROPBOX_APP_KEY")
+    app_secret = os.getenv("DROPBOX_APP_SECRET")
+
+    #    Manually request a short-lived token from Dropbox's OAuth endpoint
+    #    This call is basically what the connector code does internally,
+    #    but we're doing it here in the test so we can pass only the short-lived token later.
+    response = requests.post(
+        "https://api.dropboxapi.com/oauth2/token",
+        data={
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+        },
+        auth=(app_key, app_secret),
+        timeout=30,  # seconds
+    )
+    response.raise_for_status()
+    data = response.json()
+    short_lived_token = data["access_token"]
+    print("Acquired an access token from Dropbox")
+
+    #    Build connection config with ONLY the short-lived token
+    #    We omit refresh_token, app_key, and app_secret to confirm that
+    #    our connector can operate purely on the short-lived token.
+    connection_config = DropboxConnectionConfig(
+        access_config=DropboxAccessConfig(
+            token=short_lived_token,
+            app_key=None,
+            app_secret=None,
+            refresh_token=None,
+        )
+    )
+
+    index_config = DropboxIndexerConfig(
+        recursive=True,
+        remote_url="dropbox://test-input",
+    )
+    downloader_config = DropboxDownloaderConfig(download_dir=temp_dir)
+
+    indexer = DropboxIndexer(
+        connection_config=connection_config,
+        index_config=index_config,
+    )
+    downloader = DropboxDownloader(
+        connection_config=connection_config,
+        download_config=downloader_config,
+    )
+
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="dropbox_short_lived_via_refresh",
+            expected_num_files=4,
+            validate_downloaded_files=True,
+            exclude_fields_extend=[
+                "metadata.date_created",
+                "metadata.date_modified",
+            ],
+        ),
+    )

test/integration/connectors/test_jira.py

@@ -0,0 +1,67 @@
+import os
+
+import pytest
+
+from test.integration.connectors.utils.constants import SOURCE_TAG, UNCATEGORIZED_TAG
+from test.integration.connectors.utils.validation.source import (
+    SourceValidationConfigs,
+    source_connector_validation,
+)
+from test.integration.utils import requires_env
+from unstructured_ingest.v2.processes.connectors.jira import (
+    CONNECTOR_TYPE,
+    JiraAccessConfig,
+    JiraConnectionConfig,
+    JiraDownloader,
+    JiraDownloaderConfig,
+    JiraIndexer,
+    JiraIndexerConfig,
+)
+
+
+@pytest.mark.asyncio
+@pytest.mark.tags(CONNECTOR_TYPE, SOURCE_TAG, UNCATEGORIZED_TAG)
+@requires_env("JIRA_INGEST_USER_EMAIL", "JIRA_INGEST_API_TOKEN")
+async def test_jira_source(temp_dir):
+    # Retrieve environment variables
+    jira_url = os.environ.get(
+        "JIRA_INGEST_URL", "https://unstructured-jira-connector-test.atlassian.net"
+    )
+    user_email = os.environ["JIRA_INGEST_USER_EMAIL"]
+    api_token = os.environ["JIRA_INGEST_API_TOKEN"]
+    projects = ["JCTP1"]
+    boards = ["3"]
+    issues = ["JCTP2-1", "JCTP2-2", "JCTP2-3"]
+
+    # Create connection and indexer configurations
+    access_config = JiraAccessConfig(password=api_token)
+    connection_config = JiraConnectionConfig(
+        url=jira_url,
+        username=user_email,
+        access_config=access_config,
+    )
+    index_config = JiraIndexerConfig(projects=projects, boards=boards, issues=issues)
+
+    download_config = JiraDownloaderConfig(download_dir=temp_dir)
+
+    # Instantiate indexer and downloader
+    indexer = JiraIndexer(
+        connection_config=connection_config,
+        index_config=index_config,
+    )
+    downloader = JiraDownloader(
+        connection_config=connection_config,
+        download_config=download_config,
+    )
+
+    # Run the source connector validation
+    await source_connector_validation(
+        indexer=indexer,
+        downloader=downloader,
+        configs=SourceValidationConfigs(
+            test_id="jira",
+            expected_num_files=8,
+            validate_file_data=True,
+            validate_downloaded_files=True,
+        ),
+    )

test/unit/test_utils.py

@@ -10,6 +10,7 @@ from unstructured_ingest.cli.utils import extract_config
 from unstructured_ingest.interfaces import BaseConfig
 from unstructured_ingest.utils.string_and_date_utils import (
     ensure_isoformat_datetime,
+    fix_unescaped_unicode,
     json_to_dict,
     truncate_string_bytes,
 )
@@ -182,3 +183,29 @@ def test_truncate_string_bytes_return_untouched_string():
     result = truncate_string_bytes(test_string, max_bytes)
     assert result == "abcdef"
     assert len(result.encode("utf-8")) <= max_bytes
+
+
+def test_fix_unescaped_unicode_valid():
+    text = "This is a test with unescaped unicode: \\u0041"
+    expected = "This is a test with unescaped unicode: \u0041"
+    assert fix_unescaped_unicode(text) == expected
+
+
+def test_fix_unescaped_unicode_no_unescaped_chars():
+    text = "This is a test with no unescaped unicode: \u0041"
+    expected = "This is a test with no unescaped unicode: \u0041"
+    assert fix_unescaped_unicode(text) == expected
+
+
+def test_fix_unescaped_unicode_invalid_unicode():
+    text = "This is a test with invalid unescaped unicode: \\uZZZZ"
+    expected = "This is a test with invalid unescaped unicode: \\uZZZZ"
+    assert fix_unescaped_unicode(text) == expected
+
+
+def test_fix_unescaped_unicode_encoding_error(caplog: pytest.LogCaptureFixture):
+    text = "This is a test with unescaped unicode: \\uD83D"
+    fix_unescaped_unicode(text)
+    with caplog.at_level("WARNING"):
+        fix_unescaped_unicode(text)
+        assert "Failed to fix unescaped Unicode sequences" in caplog.text

test/unit/v2/connectors/test_jira.py

@@ -0,0 +1,401 @@
+from unittest.mock import MagicMock
+
+import pytest
+from pydantic import ValidationError
+from pytest_mock import MockerFixture
+
+from unstructured_ingest.v2.processes.connectors.jira import (
+    FieldGetter,
+    JiraAccessConfig,
+    JiraConnectionConfig,
+    JiraIndexer,
+    JiraIndexerConfig,
+    JiraIssueMetadata,
+    issues_fetcher_wrapper,
+    nested_object_to_field_getter,
+)
+
+
+@pytest.fixture
+def jira_connection_config():
+    access_config = JiraAccessConfig(password="password")
+    return JiraConnectionConfig(
+        url="http://localhost:1234",
+        username="test@example.com",
+        access_config=access_config,
+    )
+
+
+@pytest.fixture
+def jira_indexer(jira_connection_config: JiraConnectionConfig):
+    indexer_config = JiraIndexerConfig(projects=["TEST1"], boards=["2"], issues=["TEST2-1"])
+    return JiraIndexer(connection_config=jira_connection_config, index_config=indexer_config)
+
+
+@pytest.fixture
+def mock_jira(mocker: MockerFixture):
+    mock_client = mocker.patch.object(JiraConnectionConfig, "get_client", autospec=True)
+    mock_jira = mocker.MagicMock()
+    mock_client.return_value.__enter__.return_value = mock_jira
+    return mock_jira
+
+
+def test_jira_indexer_precheck_success(
+    caplog: pytest.LogCaptureFixture,
+    mocker: MockerFixture,
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    get_permissions = mocker.MagicMock()
+    get_permissions.return_value = {"permissions": {"BROWSE_PROJECTS": {"havePermission": True}}}
+    mock_jira.get_permissions = get_permissions
+
+    with caplog.at_level("INFO"):
+        jira_indexer.precheck()
+        assert "Connection to Jira successful." in caplog.text
+
+    get_permissions.assert_called_once()
+
+
+def test_jira_indexer_precheck_no_permission(
+    mocker: MockerFixture,
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    get_permissions = mocker.MagicMock()
+    get_permissions.return_value = {"permissions": {"BROWSE_PROJECTS": {"havePermission": False}}}
+    mock_jira.get_permissions = get_permissions
+
+    with pytest.raises(ValueError):
+        jira_indexer.precheck()
+
+    get_permissions.assert_called_once()
+
+
+@pytest.mark.parametrize(
+    ("project_issues_count", "expected_issues_count"), [(2, 2), ({"total": 2}, 2), (0, 0)]
+)
+def test_jira_indexer_get_issues_within_single_project(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+    project_issues_count,
+    expected_issues_count,
+):
+    mock_jira.get_project_issues_count.return_value = project_issues_count
+    mock_jira.get_all_project_issues.return_value = [
+        {"id": "1", "key": "TEST-1"},
+        {"id": "2", "key": "TEST-2"},
+    ]
+
+    issues = jira_indexer._get_issues_within_single_project("TEST1")
+    assert len(issues) == expected_issues_count
+
+    if issues:
+        assert issues[0].id == "1"
+        assert issues[0].key == "TEST-1"
+        assert issues[1].id == "2"
+        assert issues[1].key == "TEST-2"
+
+
+def test_jira_indexer_get_issues_within_single_project_error(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    mock_jira.get_project_issues_count.return_value = {}
+
+    with pytest.raises(KeyError):
+        jira_indexer._get_issues_within_single_project("TEST1")
+
+
+def test_jira_indexer_get_issues_within_projects_with_projects(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    mock_jira.get_project_issues_count.return_value = 2
+    mock_jira.get_all_project_issues.return_value = [
+        {"id": "1", "key": "TEST-1"},
+        {"id": "2", "key": "TEST-2"},
+    ]
+
+    issues = jira_indexer._get_issues_within_projects()
+    assert len(issues) == 2
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+
+
+def test_jira_indexer_get_issues_within_projects_no_projects_with_boards_or_issues(
+    mocker: MockerFixture,
+    jira_indexer: JiraIndexer,
+):
+    jira_indexer.index_config.projects = None
+    jira_indexer.index_config.boards = ["2"]
+    mocker.patch.object(JiraConnectionConfig, "get_client", autospec=True)
+
+    issues = jira_indexer._get_issues_within_projects()
+    assert issues == []
+
+
+def test_jira_indexer_get_issues_within_projects_no_projects_no_boards_no_issues(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    jira_indexer.index_config.projects = None
+    jira_indexer.index_config.boards = None
+    jira_indexer.index_config.issues = None
+    mock_jira.projects.return_value = [{"key": "TEST1"}, {"key": "TEST2"}]
+    mock_jira.get_project_issues_count.return_value = 2
+    mock_jira.get_all_project_issues.return_value = [
+        {"id": "1", "key": "TEST-1"},
+        {"id": "2", "key": "TEST-2"},
+    ]
+
+    issues = jira_indexer._get_issues_within_projects()
+    assert len(issues) == 4
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+    assert issues[2].id == "1"
+    assert issues[2].key == "TEST-1"
+    assert issues[3].id == "2"
+    assert issues[3].key == "TEST-2"
+
+
+def test_jira_indexer_get_issues_within_boards(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    mock_jira.get_issues_for_board.return_value = [
+        {"id": "1", "key": "TEST-1"},
+        {"id": "2", "key": "TEST-2"},
+    ]
+
+    issues = jira_indexer._get_issues_within_boards()
+    assert len(issues) == 2
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+
+
+def test_jira_indexer_get_issues_within_single_board(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    mock_jira.get_issues_for_board.return_value = [
+        {"id": "1", "key": "TEST-1"},
+        {"id": "2", "key": "TEST-2"},
+    ]
+
+    issues = jira_indexer._get_issues_within_single_board("1")
+    assert len(issues) == 2
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[0].board_id == "1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+    assert issues[1].board_id == "1"
+
+
+def test_jira_indexer_get_issues_within_single_board_no_issues(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    mock_jira.get_issues_for_board.return_value = []
+
+    issues = jira_indexer._get_issues_within_single_board("1")
+    assert len(issues) == 0
+
+
+def test_jira_indexer_get_issues(
+    jira_indexer: JiraIndexer,
+    mock_jira: MagicMock,
+):
+    jira_indexer.index_config.issues = ["TEST2-1", "TEST2-2"]
+    mock_jira.get_issue.return_value = {
+        "id": "ISSUE_ID",
+        "key": "ISSUE_KEY",
+    }
+
+    issues = jira_indexer._get_issues()
+    assert len(issues) == 2
+    assert issues[0].id == "ISSUE_ID"
+    assert issues[0].key == "ISSUE_KEY"
+
+
+def test_jira_indexer_get_issues_unique_issues(mocker: MockerFixture, jira_indexer: JiraIndexer):
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues_within_boards",
+        return_value=[
+            JiraIssueMetadata(id="1", key="TEST-1", board_id="1"),
+            JiraIssueMetadata(id="2", key="TEST-2", board_id="1"),
+        ],
+    )
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues_within_projects",
+        return_value=[
+            JiraIssueMetadata(id="1", key="TEST-1"),
+            JiraIssueMetadata(id="3", key="TEST-3"),
+        ],
+    )
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues",
+        return_value=[
+            JiraIssueMetadata(id="4", key="TEST-4"),
+            JiraIssueMetadata(id="2", key="TEST-2"),
+        ],
+    )
+
+    issues = jira_indexer.get_issues()
+    assert len(issues) == 4
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[0].board_id == "1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+    assert issues[1].board_id == "1"
+    assert issues[2].id == "3"
+    assert issues[2].key == "TEST-3"
+    assert issues[3].id == "4"
+    assert issues[3].key == "TEST-4"
+
+
+def test_jira_indexer_get_issues_no_duplicates(mocker: MockerFixture, jira_indexer: JiraIndexer):
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues_within_boards",
+        return_value=[
+            JiraIssueMetadata(id="1", key="TEST-1", board_id="1"),
+        ],
+    )
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues_within_projects",
+        return_value=[
+            JiraIssueMetadata(id="2", key="TEST-2"),
+        ],
+    )
+    mocker.patch.object(
+        JiraIndexer,
+        "_get_issues",
+        return_value=[
+            JiraIssueMetadata(id="3", key="TEST-3"),
+        ],
+    )
+
+    issues = jira_indexer.get_issues()
+    assert len(issues) == 3
+    assert issues[0].id == "1"
+    assert issues[0].key == "TEST-1"
+    assert issues[0].board_id == "1"
+    assert issues[1].id == "2"
+    assert issues[1].key == "TEST-2"
+    assert issues[2].id == "3"
+    assert issues[2].key == "TEST-3"
+
+
+def test_jira_indexer_get_issues_empty(mocker: MockerFixture, jira_indexer: JiraIndexer):
+    mocker.patch.object(JiraIndexer, "_get_issues_within_boards", return_value=[])
+    mocker.patch.object(JiraIndexer, "_get_issues_within_projects", return_value=[])
+    mocker.patch.object(JiraIndexer, "_get_issues", return_value=[])
+
+    issues = jira_indexer.get_issues()
+    assert len(issues) == 0
+
+
+def test_connection_config_multiple_auth():
+    with pytest.raises(ValidationError):
+        JiraConnectionConfig(
+            access_config=JiraAccessConfig(
+                password="api_token",
+                token="access_token",
+            ),
+            username="user_email",
+            url="url",
+        )
+
+
+def test_connection_config_no_auth():
+    with pytest.raises(ValidationError):
+        JiraConnectionConfig(access_config=JiraAccessConfig(), url="url")
+
+
+def test_connection_config_basic_auth():
+    JiraConnectionConfig(
+        access_config=JiraAccessConfig(password="api_token"),
+        url="url",
+        username="user_email",
+    )
+
+
+def test_connection_config_pat_auth():
+    JiraConnectionConfig(
+        access_config=JiraAccessConfig(token="access_token"),
+        url="url",
+    )
+
+
+def test_jira_issue_metadata_object():
+    expected = {"id": "10000", "key": "TEST-1", "board_id": "1", "project_id": "TEST"}
+    metadata = JiraIssueMetadata(id="10000", key="TEST-1", board_id="1")
+    assert expected == metadata.to_dict()
+
+
+def test_nested_object_to_field_getter():
+    obj = {"a": 1, "b": {"c": 2}}
+    fg = nested_object_to_field_getter(obj)
+    assert isinstance(fg, FieldGetter)
+    assert fg["a"] == 1
+    assert isinstance(fg["b"], FieldGetter)
+    assert fg["b"]["c"] == 2
+    assert isinstance(fg["b"]["d"], FieldGetter)
+    assert fg["b"]["d"]["e"] == {}
+
+
+def test_issues_fetcher_wrapper():
+    test_issues_to_fetch = 250
+    test_issues = [{"id": i} for i in range(0, test_issues_to_fetch)]
+
+    def mock_func(limit, start):
+        return {"results": test_issues[start : start + limit]}
+
+    wrapped_func = issues_fetcher_wrapper(mock_func, number_of_issues_to_fetch=test_issues_to_fetch)
+    results = wrapped_func()
+    assert len(results) == 250
+    assert results[0]["id"] == 0
+    assert results[-1]["id"] == 249
+
+    test_issues_to_fetch = 150
+    test_issues = [{"id": i} for i in range(0, test_issues_to_fetch)]
+
+    def mock_func_list(limit, start):
+        return test_issues[start : start + limit]
+
+    wrapped_func_list = issues_fetcher_wrapper(
+        mock_func_list, number_of_issues_to_fetch=test_issues_to_fetch
+    )
+    results_list = wrapped_func_list()
+    assert len(results_list) == 150
+    assert results_list[0]["id"] == 0
+    assert results_list[-1]["id"] == 149
+
+    def mock_func_invalid(limit, start):
+        return "invalid"
+
+    wrapped_func_invalid = issues_fetcher_wrapper(mock_func_invalid, number_of_issues_to_fetch=50)
+    with pytest.raises(TypeError):
+        wrapped_func_invalid()
+
+    def mock_func_key_error(limit, start):
+        return {"wrong_key": []}
+
+    wrapped_func_key_error = issues_fetcher_wrapper(
+        mock_func_key_error, number_of_issues_to_fetch=50
+    )
+    with pytest.raises(KeyError):
+        wrapped_func_key_error()

unstructured_ingest/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.9"  # pragma: no cover
+__version__ = "0.5.10"  # pragma: no cover

unstructured_ingest/embed/openai.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from pydantic import Field, SecretStr
 
@@ -26,6 +26,7 @@ if TYPE_CHECKING:
 class OpenAIEmbeddingConfig(EmbeddingConfig):
     api_key: SecretStr
     embedder_model_name: str = Field(default="text-embedding-ada-002", alias="model_name")
+    base_url: Optional[str] = None
 
     def wrap_error(self, e: Exception) -> Exception:
         if is_internal_error(e=e):
@@ -57,13 +58,13 @@ class OpenAIEmbeddingConfig(EmbeddingConfig):
     def get_client(self) -> "OpenAI":
         from openai import OpenAI
 
-        return OpenAI(api_key=self.api_key.get_secret_value())
+        return OpenAI(api_key=self.api_key.get_secret_value(), base_url=self.base_url)
 
     @requires_dependencies(["openai"], extras="openai")
     def get_async_client(self) -> "AsyncOpenAI":
         from openai import AsyncOpenAI
 
-        return AsyncOpenAI(api_key=self.api_key.get_secret_value())
+        return AsyncOpenAI(api_key=self.api_key.get_secret_value(), base_url=self.base_url)
 
 
 @dataclass