diff --git a/src/imagekitio/types/metadata.py b/src/imagekitio/types/metadata.py index 87ac334..9e47cc5 100644 --- a/src/imagekitio/types/metadata.py +++ b/src/imagekitio/types/metadata.py @@ -1,6 +1,6 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Dict, List, Optional +from typing import TYPE_CHECKING, Dict, List, Optional from pydantic import Field as FieldInfo @@ -14,6 +14,8 @@ class ExifExif(BaseModel): aperture_value: Optional[float] = FieldInfo(alias="ApertureValue", default=None) + brightness_value: Optional[float] = FieldInfo(alias="BrightnessValue", default=None) + color_space: Optional[int] = FieldInfo(alias="ColorSpace", default=None) create_date: Optional[str] = FieldInfo(alias="CreateDate", default=None) @@ -42,7 +44,9 @@ class ExifExif(BaseModel): f_number: Optional[float] = FieldInfo(alias="FNumber", default=None) - focal_length: Optional[int] = FieldInfo(alias="FocalLength", default=None) + focal_length: Optional[float] = FieldInfo(alias="FocalLength", default=None) + + focal_length_in35mm_format: Optional[int] = FieldInfo(alias="FocalLengthIn35mmFormat", default=None) focal_plane_resolution_unit: Optional[int] = FieldInfo(alias="FocalPlaneResolutionUnit", default=None) @@ -54,30 +58,92 @@ class ExifExif(BaseModel): iso: Optional[int] = FieldInfo(alias="ISO", default=None) + lens_model: Optional[str] = FieldInfo(alias="LensModel", default=None) + + light_source: Optional[int] = FieldInfo(alias="LightSource", default=None) + + max_aperture_value: Optional[float] = FieldInfo(alias="MaxApertureValue", default=None) + metering_mode: Optional[int] = FieldInfo(alias="MeteringMode", default=None) scene_capture_type: Optional[int] = FieldInfo(alias="SceneCaptureType", default=None) + scene_type: Optional[str] = FieldInfo(alias="SceneType", default=None) + + sensing_method: Optional[int] = FieldInfo(alias="SensingMethod", default=None) + shutter_speed_value: Optional[float] = FieldInfo(alias="ShutterSpeedValue", default=None) sub_sec_time: Optional[str] = FieldInfo(alias="SubSecTime", default=None) + user_comment: Optional[str] = FieldInfo(alias="UserComment", default=None) + white_balance: Optional[int] = FieldInfo(alias="WhiteBalance", default=None) + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] + class ExifGps(BaseModel): """Object containing GPS information.""" + gps_altitude: Optional[float] = FieldInfo(alias="GPSAltitude", default=None) + + gps_altitude_ref: Optional[int] = FieldInfo(alias="GPSAltitudeRef", default=None) + + gps_date_stamp: Optional[str] = FieldInfo(alias="GPSDateStamp", default=None) + + gps_img_direction: Optional[float] = FieldInfo(alias="GPSImgDirection", default=None) + + gps_img_direction_ref: Optional[str] = FieldInfo(alias="GPSImgDirectionRef", default=None) + + gps_latitude: Optional[List[float]] = FieldInfo(alias="GPSLatitude", default=None) + + gps_latitude_ref: Optional[str] = FieldInfo(alias="GPSLatitudeRef", default=None) + + gps_longitude: Optional[List[float]] = FieldInfo(alias="GPSLongitude", default=None) + + gps_longitude_ref: Optional[str] = FieldInfo(alias="GPSLongitudeRef", default=None) + + gps_time_stamp: Optional[List[float]] = FieldInfo(alias="GPSTimeStamp", default=None) + gps_version_id: Optional[List[int]] = FieldInfo(alias="GPSVersionID", default=None) + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] + class ExifImage(BaseModel): """Object containing EXIF image information.""" + artist: Optional[str] = FieldInfo(alias="Artist", default=None) + + copyright: Optional[str] = FieldInfo(alias="Copyright", default=None) + exif_offset: Optional[int] = FieldInfo(alias="ExifOffset", default=None) gps_info: Optional[int] = FieldInfo(alias="GPSInfo", default=None) + image_description: Optional[str] = FieldInfo(alias="ImageDescription", default=None) + make: Optional[str] = FieldInfo(alias="Make", default=None) model: Optional[str] = FieldInfo(alias="Model", default=None) @@ -90,11 +156,23 @@ class ExifImage(BaseModel): software: Optional[str] = FieldInfo(alias="Software", default=None) - x_resolution: Optional[int] = FieldInfo(alias="XResolution", default=None) + x_resolution: Optional[float] = FieldInfo(alias="XResolution", default=None) y_cb_cr_positioning: Optional[int] = FieldInfo(alias="YCbCrPositioning", default=None) - y_resolution: Optional[int] = FieldInfo(alias="YResolution", default=None) + y_resolution: Optional[float] = FieldInfo(alias="YResolution", default=None) + + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] class ExifInteroperability(BaseModel): @@ -104,6 +182,18 @@ class ExifInteroperability(BaseModel): interop_version: Optional[str] = FieldInfo(alias="InteropVersion", default=None) + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] + class ExifThumbnail(BaseModel): """Object containing Thumbnail information.""" @@ -116,9 +206,21 @@ class ExifThumbnail(BaseModel): thumbnail_offset: Optional[int] = FieldInfo(alias="ThumbnailOffset", default=None) - x_resolution: Optional[int] = FieldInfo(alias="XResolution", default=None) + x_resolution: Optional[float] = FieldInfo(alias="XResolution", default=None) + + y_resolution: Optional[float] = FieldInfo(alias="YResolution", default=None) - y_resolution: Optional[int] = FieldInfo(alias="YResolution", default=None) + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] class Exif(BaseModel): @@ -139,6 +241,18 @@ class Exif(BaseModel): thumbnail: Optional[ExifThumbnail] = None """Object containing Thumbnail information.""" + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object] + class Metadata(BaseModel): """JSON object containing metadata.""" @@ -183,3 +297,15 @@ class Metadata(BaseModel): width: Optional[int] = None """The width of the image or video in pixels.""" + + if TYPE_CHECKING: + # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a + # value to this field, so for compatibility we avoid doing it at runtime. + __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] + + # Stub to indicate that arbitrary properties are accepted. + # To access properties that are not valid identifiers you can use `getattr`, e.g. + # `getattr(obj, '$type')` + def __getattr__(self, attr: str) -> object: ... + else: + __pydantic_extra__: Dict[str, object]