label-studio-sdk 0.0.34__py3-none-any.whl → 1.0.1__py3-none-any.whl

label_studio_sdk/core/http_client.py

@@ -0,0 +1,447 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import asyncio
+import email.utils
+import re
+import time
+import typing
+import urllib.parse
+from contextlib import asynccontextmanager, contextmanager
+from random import random
+
+import httpx
+
+from .file import File, convert_file_dict_to_httpx_tuples
+from .jsonable_encoder import jsonable_encoder
+from .query_encoder import encode_query
+from .remove_none_from_dict import remove_none_from_dict
+from .request_options import RequestOptions
+
+INITIAL_RETRY_DELAY_SECONDS = 0.5
+MAX_RETRY_DELAY_SECONDS = 10
+MAX_RETRY_DELAY_SECONDS_FROM_HEADER = 30
+
+
+def _parse_retry_after(response_headers: httpx.Headers) -> typing.Optional[float]:
+    """
+    This function parses the `Retry-After` header in a HTTP response and returns the number of seconds to wait.
+
+    Inspired by the urllib3 retry implementation.
+    """
+    retry_after_ms = response_headers.get("retry-after-ms")
+    if retry_after_ms is not None:
+        try:
+            return int(retry_after_ms) / 1000 if retry_after_ms > 0 else 0
+        except Exception:
+            pass
+
+    retry_after = response_headers.get("retry-after")
+    if retry_after is None:
+        return None
+
+    # Attempt to parse the header as an int.
+    if re.match(r"^\s*[0-9]+\s*$", retry_after):
+        seconds = float(retry_after)
+    # Fallback to parsing it as a date.
+    else:
+        retry_date_tuple = email.utils.parsedate_tz(retry_after)
+        if retry_date_tuple is None:
+            return None
+        if retry_date_tuple[9] is None:  # Python 2
+            # Assume UTC if no timezone was specified
+            # On Python2.7, parsedate_tz returns None for a timezone offset
+            # instead of 0 if no timezone is given, where mktime_tz treats
+            # a None timezone offset as local time.
+            retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:]
+
+        retry_date = email.utils.mktime_tz(retry_date_tuple)
+        seconds = retry_date - time.time()
+
+    if seconds < 0:
+        seconds = 0
+
+    return seconds
+
+
+def _retry_timeout(response: httpx.Response, retries: int) -> float:
+    """
+    Determine the amount of time to wait before retrying a request.
+    This function begins by trying to parse a retry-after header from the response, and then proceeds to use exponential backoff
+    with a jitter to determine the number of seconds to wait.
+    """
+
+    # If the API asks us to wait a certain amount of time (and it's a reasonable amount), just do what it says.
+    retry_after = _parse_retry_after(response.headers)
+    if retry_after is not None and retry_after <= MAX_RETRY_DELAY_SECONDS_FROM_HEADER:
+        return retry_after
+
+    # Apply exponential backoff, capped at MAX_RETRY_DELAY_SECONDS.
+    retry_delay = min(INITIAL_RETRY_DELAY_SECONDS * pow(2.0, retries), MAX_RETRY_DELAY_SECONDS)
+
+    # Add a randomness / jitter to the retry delay to avoid overwhelming the server with retries.
+    timeout = retry_delay * (1 - 0.25 * random())
+    return timeout if timeout >= 0 else 0
+
+
+def _should_retry(response: httpx.Response) -> bool:
+    retriable_400s = [429, 408, 409]
+    return response.status_code >= 500 or response.status_code in retriable_400s
+
+
+def remove_omit_from_dict(
+    original: typing.Dict[str, typing.Optional[typing.Any]], omit: typing.Optional[typing.Any]
+) -> typing.Dict[str, typing.Any]:
+    if omit is None:
+        return original
+    new: typing.Dict[str, typing.Any] = {}
+    for key, value in original.items():
+        if value is not omit:
+            new[key] = value
+    return new
+
+
+def maybe_filter_request_body(
+    data: typing.Optional[typing.Any],
+    request_options: typing.Optional[RequestOptions],
+    omit: typing.Optional[typing.Any],
+) -> typing.Optional[typing.Any]:
+    if data is None:
+        return (
+            jsonable_encoder(request_options.get("additional_body_parameters", {}))
+            if request_options is not None
+            else None
+        )
+    elif not isinstance(data, typing.Mapping):
+        data_content = jsonable_encoder(data)
+    else:
+        data_content = {
+            **(jsonable_encoder(remove_omit_from_dict(data, omit))),  # type: ignore
+            **(
+                jsonable_encoder(request_options.get("additional_body_parameters", {}))
+                if request_options is not None
+                else {}
+            ),
+        }
+    return data_content
+
+
+class HttpClient:
+    def __init__(
+        self,
+        *,
+        httpx_client: httpx.Client,
+        base_timeout: typing.Optional[float],
+        base_headers: typing.Dict[str, str],
+        base_url: typing.Optional[str] = None,
+    ):
+        self.base_url = base_url
+        self.base_timeout = base_timeout
+        self.base_headers = base_headers
+        self.httpx_client = httpx_client
+
+    def get_base_url(self, maybe_base_url: typing.Optional[str]) -> str:
+        base_url = self.base_url if maybe_base_url is None else maybe_base_url
+        if base_url is None:
+            raise ValueError("A base_url is required to make this request, please provide one and try again.")
+        return base_url
+
+    def request(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+    ) -> httpx.Response:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout
+        )
+
+        response = self.httpx_client.request(
+            method=method,
+            url=urllib.parse.urljoin(f"{base_url}/", path),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self.base_headers,
+                        **(headers if headers is not None else {}),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
+            json=maybe_filter_request_body(json, request_options, omit),
+            data=maybe_filter_request_body(data, request_options, omit),
+            content=content,
+            files=convert_file_dict_to_httpx_tuples(remove_none_from_dict(files)) if files is not None else None,
+            timeout=timeout,
+        )
+
+        max_retries: int = request_options.get("max_retries", 0) if request_options is not None else 0
+        if _should_retry(response=response):
+            if max_retries > retries:
+                time.sleep(_retry_timeout(response=response, retries=retries))
+                return self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                )
+
+        return response
+
+    @contextmanager
+    def stream(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+    ) -> typing.Iterator[httpx.Response]:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout
+        )
+
+        with self.httpx_client.stream(
+            method=method,
+            url=urllib.parse.urljoin(f"{base_url}/", path),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self.base_headers,
+                        **(headers if headers is not None else {}),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
+            json=maybe_filter_request_body(json, request_options, omit),
+            data=maybe_filter_request_body(data, request_options, omit),
+            content=content,
+            files=convert_file_dict_to_httpx_tuples(remove_none_from_dict(files)) if files is not None else None,
+            timeout=timeout,
+        ) as stream:
+            yield stream
+
+
+class AsyncHttpClient:
+    def __init__(
+        self,
+        *,
+        httpx_client: httpx.AsyncClient,
+        base_timeout: typing.Optional[float],
+        base_headers: typing.Dict[str, str],
+        base_url: typing.Optional[str] = None,
+    ):
+        self.base_url = base_url
+        self.base_timeout = base_timeout
+        self.base_headers = base_headers
+        self.httpx_client = httpx_client
+
+    def get_base_url(self, maybe_base_url: typing.Optional[str]) -> str:
+        base_url = self.base_url if maybe_base_url is None else maybe_base_url
+        if base_url is None:
+            raise ValueError("A base_url is required to make this request, please provide one and try again.")
+        return base_url
+
+    async def request(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+    ) -> httpx.Response:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout
+        )
+
+        # Add the input to each of these and do None-safety checks
+        response = await self.httpx_client.request(
+            method=method,
+            url=urllib.parse.urljoin(f"{base_url}/", path),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self.base_headers,
+                        **(headers if headers is not None else {}),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
+            json=maybe_filter_request_body(json, request_options, omit),
+            data=maybe_filter_request_body(data, request_options, omit),
+            content=content,
+            files=convert_file_dict_to_httpx_tuples(remove_none_from_dict(files)) if files is not None else None,
+            timeout=timeout,
+        )
+
+        max_retries: int = request_options.get("max_retries", 0) if request_options is not None else 0
+        if _should_retry(response=response):
+            if max_retries > retries:
+                await asyncio.sleep(_retry_timeout(response=response, retries=retries))
+                return await self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                )
+        return response
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+    ) -> typing.AsyncIterator[httpx.Response]:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout
+        )
+
+        async with self.httpx_client.stream(
+            method=method,
+            url=urllib.parse.urljoin(f"{base_url}/", path),
+            headers=jsonable_encoder(
+                remove_none_from_dict(
+                    {
+                        **self.base_headers,
+                        **(headers if headers is not None else {}),
+                        **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                    }
+                )
+            ),
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit=omit,
+                        )
+                    )
+                )
+            ),
+            json=maybe_filter_request_body(json, request_options, omit),
+            data=maybe_filter_request_body(data, request_options, omit),
+            content=content,
+            files=convert_file_dict_to_httpx_tuples(remove_none_from_dict(files)) if files is not None else None,
+            timeout=timeout,
+        ) as stream:
+            yield stream

label_studio_sdk/core/jsonable_encoder.py

@@ -0,0 +1,99 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import dataclasses
+import datetime as dt
+from collections import defaultdict
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+
+from .datetime_utils import serialize_datetime
+from .pydantic_utilities import pydantic_v1
+
+SetIntStr = Set[Union[int, str]]
+DictIntStrAny = Dict[Union[int, str], Any]
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]]
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic_v1.json.ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, pydantic_v1.BaseModel):
+        encoder = getattr(obj.__config__, "json_encoders", {})
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dt.datetime):
+        return serialize_datetime(obj)
+    if isinstance(obj, dt.date):
+        return str(obj)
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        for key, value in obj.items():
+            if key in allowed_keys:
+                encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
+                encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
+        return encoded_list
+
+    if type(obj) in pydantic_v1.json.ENCODERS_BY_TYPE:
+        return pydantic_v1.json.ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: List[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(data, custom_encoder=custom_encoder)

label_studio_sdk/core/pagination.py

@@ -0,0 +1,87 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from typing_extensions import Self
+
+from .pydantic_utilities import pydantic_v1
+
+# Generic to represent the underlying type of the results within a page
+T = typing.TypeVar("T")
+
+# SDKs implement a Page ABC per-pagination request, the endpoint then retuns a pager that wraps this type
+# for example, an endpoint will return SyncPager[UserPage] where UserPage implements the Page ABC. ex:
+#
+# SyncPager<InnerListType>(
+#     has_next=response.list_metadata.after is not None,
+#     items=response.data,
+#     # This should be the outer function that returns the SyncPager again
+#     get_next=lambda: list(..., cursor: response.cursor) (or list(..., offset: offset + 1))
+# )
+class BasePage(pydantic_v1.BaseModel, typing.Generic[T]):
+    has_next: bool
+    items: typing.Optional[typing.List[T]]
+
+
+class SyncPage(BasePage, typing.Generic[T]):
+    get_next: typing.Optional[typing.Callable[[], typing.Optional[Self]]]
+
+
+class AsyncPage(BasePage, typing.Generic[T]):
+    get_next: typing.Optional[typing.Callable[[], typing.Awaitable[typing.Optional[Self]]]]
+
+
+# ----------------------------
+
+
+class SyncPager(SyncPage[T], typing.Generic[T]):
+    # Here we type ignore the iterator to avoid a mypy error
+    # caused by the type conflict with Pydanitc's __iter__ method
+    # brought in by extending the base model
+    def __iter__(self) -> typing.Iterator[T]:  # type: ignore
+        for page in self.iter_pages():
+            if page.items is not None:
+                for item in page.items:
+                    yield item
+
+    def iter_pages(self) -> typing.Iterator[SyncPage[T]]:
+        page: typing.Union[SyncPager[T], None] = self
+        while True:
+            if page is not None:
+                yield page
+                if page.has_next and page.get_next is not None:
+                    page = page.get_next()
+                    if page is None or page.items is None or len(page.items) == 0:
+                        return
+                else:
+                    return
+            else:
+                return
+
+    def next_page(self) -> typing.Optional[SyncPage[T]]:
+        return self.get_next() if self.get_next is not None else None
+
+
+class AsyncPager(AsyncPage[T], typing.Generic[T]):
+    async def __aiter__(self) -> typing.AsyncIterator[T]:  # type: ignore
+        async for page in self.iter_pages():
+            if page.items is not None:
+                for item in page.items:
+                    yield item
+
+    async def iter_pages(self) -> typing.AsyncIterator[AsyncPage[T]]:
+        page: typing.Union[AsyncPager[T], None] = self
+        while True:
+            if page is not None:
+                yield page
+                if page is not None and page.has_next and page.get_next is not None:
+                    page = await page.get_next()
+                    if page is None or page.items is None or len(page.items) == 0:
+                        return
+                else:
+                    return
+            else:
+                return
+
+    async def next_page(self) -> typing.Optional[AsyncPage[T]]:
+        return await self.get_next() if self.get_next is not None else None

label_studio_sdk/core/pydantic_utilities.py

@@ -0,0 +1,28 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic_v1  # type: ignore  # nopycln: import
+else:
+    import pydantic as pydantic_v1  # type: ignore  # nopycln: import
+
+
+def deep_union_pydantic_dicts(
+    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
+) -> typing.Dict[str, typing.Any]:
+    for key, value in source.items():
+        if isinstance(value, dict):
+            node = destination.setdefault(key, {})
+            deep_union_pydantic_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+__all__ = ["pydantic_v1"]

label_studio_sdk/core/query_encoder.py

@@ -0,0 +1,33 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from collections import ChainMap
+from typing import Any, Dict, Optional
+
+from .pydantic_utilities import pydantic_v1
+
+
+# Flattens dicts to be of the form {"key[subkey][subkey2]": value} where value is not a dict
+def traverse_query_dict(dict_flat: Dict[str, Any], key_prefix: Optional[str] = None) -> Dict[str, Any]:
+    result = {}
+    for k, v in dict_flat.items():
+        key = f"{key_prefix}[{k}]" if key_prefix is not None else k
+        if isinstance(v, dict):
+            result.update(traverse_query_dict(v, key))
+        else:
+            result[key] = v
+    return result
+
+
+def single_query_encoder(query_key: str, query_value: Any) -> Dict[str, Any]:
+    if isinstance(query_value, pydantic_v1.BaseModel) or isinstance(query_value, dict):
+        if isinstance(query_value, pydantic_v1.BaseModel):
+            obj_dict = query_value.dict(by_alias=True)
+        else:
+            obj_dict = query_value
+        return traverse_query_dict(obj_dict, query_key)
+
+    return {query_key: query_value}
+
+
+def encode_query(query: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    return dict(ChainMap(*[single_query_encoder(k, v) for k, v in query.items()])) if query is not None else None