chore(deps): dependencies 2025-04-28 (generated)

algolia/api-clients-automation#4785

Co-authored-by: algolia-bot <[email protected]>
Co-authored-by: Algolia Bot <[email protected]>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: shortcuts <[email protected]>
Co-authored-by: Pierre Millot <[email protected]>

Author: 4 people

algoliasearch/ingestion/models/destination_index_name.py

@@ -6,95 +6,77 @@
 
 from __future__ import annotations
 
-from json import dumps
+from json import loads
 from sys import version_info
-from typing import Any, Dict, Optional, Set, Union
+from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, ValidationError, model_serializer
+from pydantic import BaseModel, ConfigDict
 
 if version_info >= (3, 11):
     from typing import Self
 else:
     from typing_extensions import Self
 
 
-from algoliasearch.ingestion.models.destination_index_name import DestinationIndexName
+from algoliasearch.ingestion.models.record_type import RecordType
+
+_ALIASES = {
+    "index_name": "indexName",
+    "record_type": "recordType",
+    "attributes_to_exclude": "attributesToExclude",
+}
+
+
+def _alias_generator(name: str) -> str:
+    return _ALIASES.get(name, name)
 
 
 class DestinationInput(BaseModel):
     """
     DestinationInput
     """
 
-    oneof_schema_1_validator: Optional[DestinationIndexName] = Field(default=None)
-
-    actual_instance: Union[DestinationIndexName, None] = None
-    one_of_schemas: Set[str] = {"DestinationIndexName"}
-
-    def __init__(self, *args, **kwargs) -> None:
-        if args:
-            if len(args) > 1:
-                raise ValueError(
-                    "If a position argument is used, only 1 is allowed to set `actual_instance`"
-                )
-            if kwargs:
-                raise ValueError(
-                    "If a position argument is used, keyword arguments cannot be used."
-                )
-            super().__init__(actual_instance=args[0])  # pyright: ignore
-        else:
-            super().__init__(**kwargs)
-
-    @model_serializer
-    def unwrap_actual_instance(self) -> Union[DestinationIndexName, Self, None]:
-        """
-        Unwraps the `actual_instance` when calling the `to_json` method.
-        """
-        return self.actual_instance if hasattr(self, "actual_instance") else self
+    index_name: str
+    """ Algolia index name (case-sensitive). """
+    record_type: Optional[RecordType] = None
+    attributes_to_exclude: Optional[List[str]] = None
+    """ Attributes from your source to exclude from Algolia records.  Not all your data attributes will be useful for searching. Keeping your Algolia records small increases indexing and search performance.  - Exclude nested attributes with `.` notation. For example, `foo.bar` indexes the `foo` attribute and all its children **except** the `bar` attribute. - Exclude attributes from arrays with `[i]`, where `i` is the index of the array element.   For example, `foo.[0].bar` only excludes the `bar` attribute from the first element of the `foo` array, but indexes the complete `foo` attribute for all other elements.   Use `*` as wildcard: `foo.[*].bar` excludes `bar` from all elements of the `foo` array.  """
+
+    model_config = ConfigDict(
+        strict=False,
+        use_enum_values=True,
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+        alias_generator=_alias_generator,
+        extra="allow",
+    )
+
+    def to_json(self) -> str:
+        return self.model_dump_json(by_alias=True, exclude_unset=True)
 
     @classmethod
-    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+    def from_json(cls, json_str: str) -> Optional[Self]:
         """Create an instance of DestinationInput from a JSON string"""
-        return cls.from_json(dumps(obj))
+        return cls.from_dict(loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias."""
+        return self.model_dump(
+            by_alias=True,
+            exclude_none=True,
+            exclude_unset=True,
+        )
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
-        """Returns the object represented by the json string"""
-        instance = cls.model_construct()
-        error_messages = []
-
-        try:
-            instance.actual_instance = DestinationIndexName.from_json(json_str)
-
-            return instance
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DestinationInput from a dict"""
+        if obj is None:
+            return None
 
-        raise ValueError(
-            "No match found when deserializing the JSON string into DestinationInput with oneOf schemas: DestinationIndexName. Details: "
-            + ", ".join(error_messages)
-        )
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
 
-    def to_json(self) -> str:
-        """Returns the JSON representation of the actual instance"""
-        if self.actual_instance is None:
-            return "null"
-
-        if hasattr(self.actual_instance, "to_json") and callable(
-            self.actual_instance.to_json  # pyright: ignore
-        ):
-            return self.actual_instance.to_json()  # pyright: ignore
-        else:
-            return dumps(self.actual_instance)
-
-    def to_dict(self) -> Optional[Union[Dict[str, Any], DestinationIndexName]]:
-        """Returns the dict representation of the actual instance"""
-        if self.actual_instance is None:
-            return None
+        obj["recordType"] = obj.get("recordType")
 
-        if hasattr(self.actual_instance, "to_dict") and callable(
-            self.actual_instance.to_dict  # pyright: ignore
-        ):
-            return self.actual_instance.to_dict()  # pyright: ignore
-        else:
-            return self.actual_instance  # pyright: ignore
+        return cls.model_validate(obj)

algoliasearch/ingestion/models/destination_input.py

@@ -23,7 +23,7 @@ async-timeout = ">= 4.0.3"
 pydantic = ">= 2"
 
 [tool.poetry.group.dev.dependencies]
-ruff = "== 0.9.6"
+ruff = "== 0.11.7"
 pyright = "== 1.1.391"
 
 [tool.ruff]