airbyte-cdk 6.6.2__tar.gz → 6.6.3__tar.gz

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.6.2
+Version: 6.6.3
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.3}/airbyte_cdk/sources/declarative/manifest_declarative_source.py

@@ -5,10 +5,10 @@
 import json
 import logging
 import pkgutil
-import re
 from copy import deepcopy
 from importlib import metadata
-from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Mapping, Optional
+from packaging.version import Version, InvalidVersion
 
 import yaml
 from airbyte_cdk.models import (
@@ -245,45 +245,54 @@ class ManifestDeclarativeSource(DeclarativeSource):
                 "Validation against json schema defined in declarative_component_schema.yaml schema failed"
             ) from e
 
-        cdk_version = metadata.version("airbyte_cdk")
-        cdk_major, cdk_minor, cdk_patch = self._get_version_parts(cdk_version, "airbyte-cdk")
-        manifest_version = self._source_config.get("version")
-        if manifest_version is None:
+        cdk_version_str = metadata.version("airbyte_cdk")
+        cdk_version = self._parse_version(cdk_version_str, "airbyte-cdk")
+        manifest_version_str = self._source_config.get("version")
+        if manifest_version_str is None:
             raise RuntimeError(
                 "Manifest version is not defined in the manifest. This is unexpected since it should be a required field. Please contact support."
             )
-        manifest_major, manifest_minor, manifest_patch = self._get_version_parts(
-            manifest_version, "manifest"
-        )
+        manifest_version = self._parse_version(manifest_version_str, "manifest")
 
-        if cdk_version.startswith("0.0.0"):
+        if (cdk_version.major, cdk_version.minor, cdk_version.micro) == (0, 0, 0):
             # Skipping version compatibility check on unreleased dev branch
             pass
-        elif cdk_major < manifest_major or (
-            cdk_major == manifest_major and cdk_minor < manifest_minor
+        elif (cdk_version.major, cdk_version.minor) < (
+            manifest_version.major,
+            manifest_version.minor,
         ):
             raise ValidationError(
-                f"The manifest version {manifest_version} is greater than the airbyte-cdk package version ({cdk_version}). Your "
+                f"The manifest version {manifest_version!s} is greater than the airbyte-cdk package version ({cdk_version!s}). Your "
                 f"manifest may contain features that are not in the current CDK version."
             )
-        elif manifest_major == 0 and manifest_minor < 29:
+        elif (manifest_version.major, manifest_version.minor) < (0, 29):
             raise ValidationError(
                 f"The low-code framework was promoted to Beta in airbyte-cdk version 0.29.0 and contains many breaking changes to the "
-                f"language. The manifest version {manifest_version} is incompatible with the airbyte-cdk package version "
-                f"{cdk_version} which contains these breaking changes."
+                f"language. The manifest version {manifest_version!s} is incompatible with the airbyte-cdk package version "
+                f"{cdk_version!s} which contains these breaking changes."
             )
 
     @staticmethod
-    def _get_version_parts(version: str, version_type: str) -> Tuple[int, int, int]:
-        """
-        Takes a semantic version represented as a string and splits it into a tuple of its major, minor, and patch versions.
+    def _parse_version(
+        version: str,
+        version_type: str,
+    ) -> Version:
+        """Takes a semantic version represented as a string and splits it into a tuple.
+
+        The fourth part (prerelease) is not returned in the tuple.
+
+        Returns:
+            Version: the parsed version object
         """
-        version_parts = re.split(r"\.", version)
-        if len(version_parts) != 3 or not all([part.isdigit() for part in version_parts]):
+        try:
+            parsed_version = Version(version)
+        except InvalidVersion as ex:
             raise ValidationError(
-                f"The {version_type} version {version} specified is not a valid version format (ex. 1.2.3)"
-            )
-        return tuple(int(part) for part in version_parts)  # type: ignore # We already verified there were 3 parts and they are all digits
+                f"The {version_type} version '{version}' is not a valid version format."
+            ) from ex
+        else:
+            # No exception
+            return parsed_version
 
     def _stream_configs(self, manifest: Mapping[str, Any]) -> List[Dict[str, Any]]:
         # This has a warning flag for static, but after we finish part 4 we'll replace manifest with self._source_config

{airbyte_cdk-6.6.2 → airbyte_cdk-6.6.3}/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.6.2"  # Version will be calculated dynamically.
+version = "6.6.3"  # Version will be calculated dynamically.
 
 [tool.poetry-dynamic-versioning]
 enable = false