airbyte-cdk 6.17.1.dev0__tar.gz → 6.17.1.dev1__tar.gz

{airbyte_cdk-6.17.1.dev0 → airbyte_cdk-6.17.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: airbyte-cdk
-Version: 6.17.1.dev0
+Version: 6.17.1.dev1
 Summary: A framework for writing Airbyte Connectors.
 License: MIT
 Keywords: airbyte,connector-development-kit,cdk

{airbyte_cdk-6.17.1.dev0 → airbyte_cdk-6.17.1.dev1}/airbyte_cdk/sources/declarative/incremental/concurrent_partition_cursor.py

@@ -107,14 +107,11 @@ class ConcurrentPerPartitionCursor(Cursor):
     def state(self) -> MutableMapping[str, Any]:
         states = []
         for partition_tuple, cursor in self._cursor_per_partition.items():
-            cursor_state = cursor._connector_state_converter.convert_to_state_message(
-                self.cursor_field, cursor.state
-            )
-            if cursor_state:
+            if cursor.state:
                 states.append(
                     {
                         "partition": self._to_dict(partition_tuple),
-                        "cursor": copy.deepcopy(cursor_state),
+                        "cursor": copy.deepcopy(cursor.state),
                     }
                 )
         state: dict[str, Any] = {"states": states}
@@ -138,9 +135,6 @@ class ConcurrentPerPartitionCursor(Cursor):
             cursor = self._cursor_per_partition[
                 self._to_partition_key(partition._stream_slice.partition)
             ]
-            cursor_state = cursor._connector_state_converter.convert_to_state_message(
-                cursor._cursor_field, cursor.state
-            )
             if (
                 self._to_partition_key(partition._stream_slice.partition)
                 in self._finished_partitions
@@ -152,9 +146,9 @@ class ConcurrentPerPartitionCursor(Cursor):
                 if (
                     self._new_global_cursor is None
                     or self._new_global_cursor[self.cursor_field.cursor_field_key]
-                    < cursor_state[self.cursor_field.cursor_field_key]
+                    < cursor.state[self.cursor_field.cursor_field_key]
                 ):
-                    self._new_global_cursor = copy.deepcopy(cursor_state)
+                    self._new_global_cursor = copy.deepcopy(cursor.state)
 
     def ensure_at_least_one_state_emitted(self) -> None:
         """

{airbyte_cdk-6.17.1.dev0 → airbyte_cdk-6.17.1.dev1}/airbyte_cdk/sources/declarative/incremental/per_partition_cursor.py

@@ -304,7 +304,8 @@ class PerPartitionCursor(DeclarativeCursor):
 
     def should_be_synced(self, record: Record) -> bool:
         if (
-            self._to_partition_key(record.associated_slice.partition)
+            record.associated_slice
+            and self._to_partition_key(record.associated_slice.partition)
             not in self._cursor_per_partition
         ):
             partition_state = (

{airbyte_cdk-6.17.1.dev0 → airbyte_cdk-6.17.1.dev1}/airbyte_cdk/sources/streams/concurrent/cursor.py

@@ -196,7 +196,9 @@ class ConcurrentCursor(Cursor):
 
     @property
     def state(self) -> MutableMapping[str, Any]:
-        return self._concurrent_state
+        return self._connector_state_converter.convert_to_state_message(
+            self.cursor_field, self._concurrent_state
+        )
 
     @property
     def cursor_field(self) -> CursorField:
@@ -241,10 +243,10 @@ class ConcurrentCursor(Cursor):
         return self._connector_state_converter.parse_value(self._cursor_field.extract_value(record))
 
     def close_partition(self, partition: Partition) -> None:
-        slice_count_before = len(self.state.get("slices", []))
+        slice_count_before = len(self._concurrent_state.get("slices", []))
         self._add_slice_to_state(partition)
         if slice_count_before < len(
-            self.state["slices"]
+            self._concurrent_state["slices"]
         ):  # only emit if at least one slice has been processed
             self._merge_partitions()
             self._emit_state_message()
@@ -256,11 +258,11 @@ class ConcurrentCursor(Cursor):
         )
 
         if self._slice_boundary_fields:
-            if "slices" not in self.state:
+            if "slices" not in self._concurrent_state:
                 raise RuntimeError(
                     f"The state for stream {self._stream_name} should have at least one slice to delineate the sync start time, but no slices are present. This is unexpected. Please contact Support."
                 )
-            self.state["slices"].append(
+            self._concurrent_state["slices"].append(
                 {
                     self._connector_state_converter.START_KEY: self._extract_from_slice(
                         partition, self._slice_boundary_fields[self._START_BOUNDARY]
@@ -288,7 +290,7 @@ class ConcurrentCursor(Cursor):
                     "expected. Please contact the Airbyte team."
                 )
 
-            self.state["slices"].append(
+            self._concurrent_state["slices"].append(
                 {
                     self._connector_state_converter.START_KEY: self.start,
                     self._connector_state_converter.END_KEY: most_recent_cursor_value,
@@ -300,9 +302,7 @@ class ConcurrentCursor(Cursor):
         self._connector_state_manager.update_state_for_stream(
             self._stream_name,
             self._stream_namespace,
-            self._connector_state_converter.convert_to_state_message(
-                self._cursor_field, self.state
-            ),
+            self.state,
         )
         state_message = self._connector_state_manager.create_state_message(
             self._stream_name, self._stream_namespace
@@ -310,7 +310,9 @@ class ConcurrentCursor(Cursor):
         self._message_repository.emit_message(state_message)
 
     def _merge_partitions(self) -> None:
-        self.state["slices"] = self._connector_state_converter.merge_intervals(self.state["slices"])
+        self._concurrent_state["slices"] = self._connector_state_converter.merge_intervals(
+            self._concurrent_state["slices"]
+        )
 
     def _extract_from_slice(self, partition: Partition, key: str) -> CursorValueType:
         try:
@@ -347,36 +349,42 @@ class ConcurrentCursor(Cursor):
         if self._start is not None and self._is_start_before_first_slice():
             yield from self._split_per_slice_range(
                 self._start,
-                self.state["slices"][0][self._connector_state_converter.START_KEY],
+                self._concurrent_state["slices"][0][self._connector_state_converter.START_KEY],
                 False,
             )
 
-        if len(self.state["slices"]) == 1:
+        if len(self._concurrent_state["slices"]) == 1:
             yield from self._split_per_slice_range(
                 self._calculate_lower_boundary_of_last_slice(
-                    self.state["slices"][0][self._connector_state_converter.END_KEY]
+                    self._concurrent_state["slices"][0][self._connector_state_converter.END_KEY]
                 ),
                 self._end_provider(),
                 True,
             )
-        elif len(self.state["slices"]) > 1:
-            for i in range(len(self.state["slices"]) - 1):
+        elif len(self._concurrent_state["slices"]) > 1:
+            for i in range(len(self._concurrent_state["slices"]) - 1):
                 if self._cursor_granularity:
                     yield from self._split_per_slice_range(
-                        self.state["slices"][i][self._connector_state_converter.END_KEY]
+                        self._concurrent_state["slices"][i][self._connector_state_converter.END_KEY]
                         + self._cursor_granularity,
-                        self.state["slices"][i + 1][self._connector_state_converter.START_KEY],
+                        self._concurrent_state["slices"][i + 1][
+                            self._connector_state_converter.START_KEY
+                        ],
                         False,
                     )
                 else:
                     yield from self._split_per_slice_range(
-                        self.state["slices"][i][self._connector_state_converter.END_KEY],
-                        self.state["slices"][i + 1][self._connector_state_converter.START_KEY],
+                        self._concurrent_state["slices"][i][
+                            self._connector_state_converter.END_KEY
+                        ],
+                        self._concurrent_state["slices"][i + 1][
+                            self._connector_state_converter.START_KEY
+                        ],
                         False,
                     )
             yield from self._split_per_slice_range(
                 self._calculate_lower_boundary_of_last_slice(
-                    self.state["slices"][-1][self._connector_state_converter.END_KEY]
+                    self._concurrent_state["slices"][-1][self._connector_state_converter.END_KEY]
                 ),
                 self._end_provider(),
                 True,
@@ -387,7 +395,8 @@ class ConcurrentCursor(Cursor):
     def _is_start_before_first_slice(self) -> bool:
         return (
             self._start is not None
-            and self._start < self.state["slices"][0][self._connector_state_converter.START_KEY]
+            and self._start
+            < self._concurrent_state["slices"][0][self._connector_state_converter.START_KEY]
         )
 
     def _calculate_lower_boundary_of_last_slice(

{airbyte_cdk-6.17.1.dev0 → airbyte_cdk-6.17.1.dev1}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 keywords = ["airbyte", "connector-development-kit", "cdk"]
 
 # Python CDK uses dynamic versioning: https://github.com/mtkennerly/poetry-dynamic-versioning
-version = "6.17.1dev0"  # Version will be calculated dynamically.
+version = "6.17.1dev1"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false