fix: migrate deprecated RefResolver to referencing library for jsonschema 4.18+ compatibility

- Replace RefResolver.from_schema() with Registry().with_resource() pattern
- Update resolver.resolve() calls to use resolver.lookup().contents
- Addresses jsonschema 4.18+ deprecation warnings
- Maintains backward compatibility with existing functionality

Co-Authored-By: AJ Steers <[email protected]>

Author: devin-ai-integration[bot]

airbyte_cdk/sources/utils/schema_helpers.py

@@ -10,9 +10,10 @@
 from typing import Any, ClassVar, Dict, List, Mapping, MutableMapping, Optional, Tuple
 
 import jsonref
-from jsonschema import RefResolver, validate
+from jsonschema import validate
 from jsonschema.exceptions import ValidationError
 from pydantic.v1 import BaseModel, Field
+from referencing import Registry, Resource
 
 from airbyte_cdk.models import ConnectorSpecification, FailureType
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
@@ -63,18 +64,21 @@ def resolve_ref_links(obj: Any) -> Any:
         return obj
 
 
-def _expand_refs(schema: Any, ref_resolver: Optional[RefResolver] = None) -> None:
+def _expand_refs(schema: Any, ref_resolver: Optional[Registry] = None) -> None:
     """Internal function to iterate over schema and replace all occurrences of $ref with their definitions. Recursive.
 
     :param schema: schema that will be patched
     :param ref_resolver: resolver to get definition from $ref, if None pass it will be instantiated
     """
-    ref_resolver = ref_resolver or RefResolver.from_schema(schema)
+    if ref_resolver is None:
+        resource = Resource.from_contents(schema)
+        ref_resolver = Registry().with_resource("", resource)
+    resolver = ref_resolver.resolver()
 
     if isinstance(schema, MutableMapping):
         if "$ref" in schema:
             ref_url = schema.pop("$ref")
-            _, definition = ref_resolver.resolve(ref_url)
+            definition = resolver.lookup(ref_url).contents
             _expand_refs(
                 definition, ref_resolver=ref_resolver
             )  # expand refs in definitions as well

airbyte_cdk/sources/utils/transform.py

@@ -6,7 +6,8 @@
 from enum import Flag, auto
 from typing import Any, Callable, Dict, Generator, Mapping, Optional, cast
 
-from jsonschema import Draft7Validator, RefResolver, ValidationError, Validator, validators
+from jsonschema import Draft7Validator, ValidationError, Validator, validators
+from referencing import Registry, Resource
 
 MAX_NESTING_DEPTH = 3
 json_to_python_simple = {
@@ -194,10 +195,7 @@ def normalizator(
 
             def resolve(subschema: dict[str, Any]) -> dict[str, Any]:
                 if "$ref" in subschema:
-                    _, resolved = cast(
-                        RefResolver,
-                        validator_instance.resolver,
-                    ).resolve(subschema["$ref"])
+                    resolved = validator_instance.resolver.lookup(subschema["$ref"]).contents
                     return cast(dict[str, Any], resolved)
                 return subschema
 

airbyte_cdk/utils/spec_schema_transformations.py

@@ -6,21 +6,22 @@
 import re
 from typing import Any
 
-from jsonschema import RefResolver
+from referencing import Registry, Resource
 
 
 def resolve_refs(schema: dict[str, Any]) -> dict[str, Any]:
     """
     For spec schemas generated using Pydantic models, the resulting JSON schema can contain refs between object
     relationships.
     """
-    json_schema_ref_resolver = RefResolver.from_schema(schema)
+    resource = Resource.from_contents(schema)
+    registry = Registry().with_resource("", resource)
+    resolver = registry.resolver()
     str_schema = json.dumps(schema)
     for ref_block in re.findall(r'{"\$ref": "#\/definitions\/.+?(?="})"}', str_schema):
         ref = json.loads(ref_block)["$ref"]
-        str_schema = str_schema.replace(
-            ref_block, json.dumps(json_schema_ref_resolver.resolve(ref)[1])
-        )
+        resolved = resolver.lookup(ref).contents
+        str_schema = str_schema.replace(ref_block, json.dumps(resolved))
     pyschema: dict[str, Any] = json.loads(str_schema)
     del pyschema["definitions"]
     return pyschema