Merge main branch and regenerate poetry.lock

Resolves merge conflicts with main branch while preserving the
langchain-core version bump to ^1.2.5 (resolves to 1.2.6) to
address CVE-2025-68664.

Co-Authored-By: unknown <>

Author: devin-ai-integration[bot]

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -2110,11 +2110,11 @@ def create_default_stream(
             name=stream_name,
             json_schema=schema_loader.get_json_schema,
             primary_key=get_primary_key_from_stream(primary_key),
-            cursor_field=concurrent_cursor.cursor_field
-            if hasattr(concurrent_cursor, "cursor_field")
-            else CursorField(
-                cursor_field_key=""
-            ),  # FIXME we should have the cursor field has part of the interface of cursor,
+            cursor_field=(
+                concurrent_cursor.cursor_field
+                if hasattr(concurrent_cursor, "cursor_field")
+                else None
+            ),
             logger=logging.getLogger(f"airbyte.{stream_name}"),
             cursor=concurrent_cursor,
             supports_file_transfer=hasattr(model, "file_uploader") and bool(model.file_uploader),
@@ -4339,8 +4339,14 @@ def _get_catalog_defined_cursor_field(
         configured_stream = self._stream_name_to_configured_stream.get(stream_name)
 
         # Depending on the operation is being performed, there may not be a configured stream yet. In this
-        # case we return None which will then use the default cursor field defined on the cursor model
-        if not configured_stream or not configured_stream.cursor_field:
+        # case we return None which will then use the default cursor field defined on the cursor model.
+        # We also treat cursor_field: [""] (list with empty string) as no cursor field, since this can
+        # occur when the platform serializes "no cursor configured" streams incorrectly.
+        if (
+            not configured_stream
+            or not configured_stream.cursor_field
+            or not configured_stream.cursor_field[0]
+        ):
             return None
         elif len(configured_stream.cursor_field) > 1:
             raise ValueError(

airbyte_cdk/sources/file_based/exceptions.py

@@ -92,6 +92,12 @@ class RecordParseError(BaseFileBasedSourceError):
     pass
 
 
+class ExcelCalamineParsingError(BaseFileBasedSourceError):
+    """Raised when Calamine engine fails to parse an Excel file."""
+
+    pass
+
+
 class SchemaInferenceError(BaseFileBasedSourceError):
     pass
 

airbyte_cdk/sources/file_based/file_types/excel_parser.py

@@ -3,6 +3,7 @@
 #
 
 import logging
+import warnings
 from io import IOBase
 from pathlib import Path
 from typing import Any, Dict, Iterable, Mapping, Optional, Tuple, Union
@@ -17,6 +18,7 @@
 )
 from airbyte_cdk.sources.file_based.exceptions import (
     ConfigValidationError,
+    ExcelCalamineParsingError,
     FileBasedSourceError,
     RecordParseError,
 )
@@ -64,7 +66,7 @@ async def infer_schema(
         fields: Dict[str, str] = {}
 
         with stream_reader.open_file(file, self.file_read_mode, self.ENCODING, logger) as fp:
-            df = self.open_and_parse_file(fp)
+            df = self.open_and_parse_file(fp, logger, file)
             for column, df_type in df.dtypes.items():
                 # Choose the broadest data type if the column's data type differs in dataframes
                 prev_frame_column_type = fields.get(column)  # type: ignore [call-overload]
@@ -92,7 +94,7 @@ def parse_records(
         discovered_schema: Optional[Mapping[str, SchemaType]] = None,
     ) -> Iterable[Dict[str, Any]]:
         """
-        Parses records from an Excel file based on the provided configuration.
+        Parses records from an Excel file with fallback error handling.
 
         Args:
             config (FileBasedStreamConfig): Configuration for the file-based stream.
@@ -111,7 +113,7 @@ def parse_records(
         try:
             # Open and parse the file using the stream reader
             with stream_reader.open_file(file, self.file_read_mode, self.ENCODING, logger) as fp:
-                df = self.open_and_parse_file(fp)
+                df = self.open_and_parse_file(fp, logger, file)
                 # Yield records as dictionaries
                 # DataFrame.to_dict() method returns datetime values in pandas.Timestamp values, which are not serializable by orjson
                 # DataFrame.to_json() returns string with datetime values serialized to iso8601 with microseconds to align with pydantic behavior
@@ -180,15 +182,93 @@ def validate_format(excel_format: BaseModel, logger: logging.Logger) -> None:
             logger.info(f"Expected ExcelFormat, got {excel_format}")
             raise ConfigValidationError(FileBasedSourceError.CONFIG_VALIDATION_ERROR)
 
-    @staticmethod
-    def open_and_parse_file(fp: Union[IOBase, str, Path]) -> pd.DataFrame:
+    def _open_and_parse_file_with_calamine(
+        self,
+        fp: Union[IOBase, str, Path],
+        logger: logging.Logger,
+        file: RemoteFile,
+    ) -> pd.DataFrame:
+        """Opens and parses Excel file using Calamine engine.
+
+        Args:
+            fp: File pointer to the Excel file.
+            logger: Logger for logging information and errors.
+            file: Remote file information for logging context.
+
+        Returns:
+            pd.DataFrame: Parsed data from the Excel file.
+
+        Raises:
+            ExcelCalamineParsingError: If Calamine fails to parse the file.
+        """
+        try:
+            return pd.ExcelFile(fp, engine="calamine").parse()  # type: ignore [arg-type, call-overload, no-any-return]
+        except BaseException as exc:
+            # Calamine engine raises PanicException(child of BaseException) if Calamine fails to parse the file.
+            # Checking if ValueError in exception arg to know if it was actually an error during parsing due to invalid values in cells.
+            # Otherwise, raise an exception.
+            if "ValueError" in str(exc):
+                logger.warning(
+                    f"Calamine parsing failed for {file.file_uri_for_logging}, falling back to openpyxl: {exc}"
+                )
+                raise ExcelCalamineParsingError(
+                    f"Calamine engine failed to parse {file.file_uri_for_logging}",
+                    filename=file.uri,
+                ) from exc
+            raise exc
+
+    def _open_and_parse_file_with_openpyxl(
+        self,
+        fp: Union[IOBase, str, Path],
+        logger: logging.Logger,
+        file: RemoteFile,
+    ) -> pd.DataFrame:
+        """Opens and parses Excel file using Openpyxl engine.
+
+        Args:
+            fp: File pointer to the Excel file.
+            logger: Logger for logging information and errors.
+            file: Remote file information for logging context.
+
+        Returns:
+            pd.DataFrame: Parsed data from the Excel file.
         """
-        Opens and parses the Excel file.
+        # Some file-like objects are not seekable.
+        if hasattr(fp, "seek"):
+            try:
+                fp.seek(0)  # type: ignore [union-attr]
+            except OSError as exc:
+                logger.info(
+                    f"Could not rewind stream for {file.file_uri_for_logging}; "
+                    f"proceeding with openpyxl from current position: {exc}"
+                )
+
+        with warnings.catch_warnings(record=True) as warning_records:
+            warnings.simplefilter("always")
+            df = pd.ExcelFile(fp, engine="openpyxl").parse()  # type: ignore [arg-type, call-overload]
+
+        for warning in warning_records:
+            logger.warning(f"Openpyxl warning for {file.file_uri_for_logging}: {warning.message}")
+
+        return df  # type: ignore [no-any-return]
+
+    def open_and_parse_file(
+        self,
+        fp: Union[IOBase, str, Path],
+        logger: logging.Logger,
+        file: RemoteFile,
+    ) -> pd.DataFrame:
+        """Opens and parses the Excel file with Calamine-first and Openpyxl fallback.
 
         Args:
             fp: File pointer to the Excel file.
+            logger: Logger for logging information and errors.
+            file: Remote file information for logging context.
 
         Returns:
             pd.DataFrame: Parsed data from the Excel file.
         """
-        return pd.ExcelFile(fp, engine="calamine").parse()  # type: ignore [arg-type, call-overload, no-any-return]
+        try:
+            return self._open_and_parse_file_with_calamine(fp, logger, file)
+        except ExcelCalamineParsingError:
+            return self._open_and_parse_file_with_openpyxl(fp, logger, file)

airbyte_cdk/sources/file_based/remote_file.py

@@ -17,6 +17,11 @@ class RemoteFile(BaseModel):
     last_modified: datetime
     mime_type: Optional[str] = None
 
+    @property
+    def file_uri_for_logging(self) -> str:
+        """Returns a user-friendly identifier for logging."""
+        return self.uri
+
 
 class UploadableRemoteFile(RemoteFile, ABC):
     """
@@ -49,13 +54,6 @@ def source_file_relative_path(self) -> str:
         """
         return self.uri
 
-    @property
-    def file_uri_for_logging(self) -> str:
-        """
-        Returns the URI for the file being logged.
-        """
-        return self.uri
-
     @property
     def source_uri(self) -> str:
         """

airbyte_cdk/sources/streams/concurrent/helpers.py

@@ -34,7 +34,8 @@ def get_cursor_field_from_stream(stream: Stream) -> Optional[str]:
             raise ValueError(
                 f"Nested cursor fields are not supported. Got {stream.cursor_field} for {stream.name}"
             )
-        elif len(stream.cursor_field) == 0:
+        elif len(stream.cursor_field) == 0 or not stream.cursor_field[0]:
+            # Treat cursor_field: [""] (list with empty string) as no cursor field
             return None
         else:
             return stream.cursor_field[0]