immich 1.2.1__py3-none-any.whl

immich/client/models/system_config_generated_image_dto.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from immich.client.models.image_format import ImageFormat
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigGeneratedImageDto(BaseModel):
+    """
+    SystemConfigGeneratedImageDto
+    """  # noqa: E501
+
+    format: ImageFormat
+    quality: Annotated[int, Field(le=100, strict=True, ge=1)]
+    size: Annotated[int, Field(strict=True, ge=1)]
+    __properties: ClassVar[List[str]] = ["format", "quality", "size"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigGeneratedImageDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigGeneratedImageDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "format": obj.get("format"),
+                "quality": obj.get("quality"),
+                "size": obj.get("size"),
+            }
+        )
+        return _obj

immich/client/models/system_config_image_dto.py

@@ -0,0 +1,124 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List
+from immich.client.models.colorspace import Colorspace
+from immich.client.models.system_config_generated_fullsize_image_dto import (
+    SystemConfigGeneratedFullsizeImageDto,
+)
+from immich.client.models.system_config_generated_image_dto import (
+    SystemConfigGeneratedImageDto,
+)
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigImageDto(BaseModel):
+    """
+    SystemConfigImageDto
+    """  # noqa: E501
+
+    colorspace: Colorspace
+    extract_embedded: StrictBool = Field(alias="extractEmbedded")
+    fullsize: SystemConfigGeneratedFullsizeImageDto
+    preview: SystemConfigGeneratedImageDto
+    thumbnail: SystemConfigGeneratedImageDto
+    __properties: ClassVar[List[str]] = [
+        "colorspace",
+        "extractEmbedded",
+        "fullsize",
+        "preview",
+        "thumbnail",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigImageDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of fullsize
+        if self.fullsize:
+            _dict["fullsize"] = self.fullsize.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of preview
+        if self.preview:
+            _dict["preview"] = self.preview.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of thumbnail
+        if self.thumbnail:
+            _dict["thumbnail"] = self.thumbnail.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigImageDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "colorspace": obj.get("colorspace"),
+                "extractEmbedded": obj.get("extractEmbedded"),
+                "fullsize": SystemConfigGeneratedFullsizeImageDto.from_dict(
+                    obj["fullsize"]
+                )
+                if obj.get("fullsize") is not None
+                else None,
+                "preview": SystemConfigGeneratedImageDto.from_dict(obj["preview"])
+                if obj.get("preview") is not None
+                else None,
+                "thumbnail": SystemConfigGeneratedImageDto.from_dict(obj["thumbnail"])
+                if obj.get("thumbnail") is not None
+                else None,
+            }
+        )
+        return _obj

immich/client/models/system_config_job_dto.py

@@ -0,0 +1,194 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from immich.client.models.job_settings_dto import JobSettingsDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigJobDto(BaseModel):
+    """
+    SystemConfigJobDto
+    """  # noqa: E501
+
+    background_task: JobSettingsDto = Field(alias="backgroundTask")
+    face_detection: JobSettingsDto = Field(alias="faceDetection")
+    library: JobSettingsDto
+    metadata_extraction: JobSettingsDto = Field(alias="metadataExtraction")
+    migration: JobSettingsDto
+    notifications: JobSettingsDto
+    ocr: JobSettingsDto
+    search: JobSettingsDto
+    sidecar: JobSettingsDto
+    smart_search: JobSettingsDto = Field(alias="smartSearch")
+    thumbnail_generation: JobSettingsDto = Field(alias="thumbnailGeneration")
+    video_conversion: JobSettingsDto = Field(alias="videoConversion")
+    workflow: JobSettingsDto
+    __properties: ClassVar[List[str]] = [
+        "backgroundTask",
+        "faceDetection",
+        "library",
+        "metadataExtraction",
+        "migration",
+        "notifications",
+        "ocr",
+        "search",
+        "sidecar",
+        "smartSearch",
+        "thumbnailGeneration",
+        "videoConversion",
+        "workflow",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigJobDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of background_task
+        if self.background_task:
+            _dict["backgroundTask"] = self.background_task.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of face_detection
+        if self.face_detection:
+            _dict["faceDetection"] = self.face_detection.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of library
+        if self.library:
+            _dict["library"] = self.library.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of metadata_extraction
+        if self.metadata_extraction:
+            _dict["metadataExtraction"] = self.metadata_extraction.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of migration
+        if self.migration:
+            _dict["migration"] = self.migration.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of notifications
+        if self.notifications:
+            _dict["notifications"] = self.notifications.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of ocr
+        if self.ocr:
+            _dict["ocr"] = self.ocr.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of search
+        if self.search:
+            _dict["search"] = self.search.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of sidecar
+        if self.sidecar:
+            _dict["sidecar"] = self.sidecar.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of smart_search
+        if self.smart_search:
+            _dict["smartSearch"] = self.smart_search.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of thumbnail_generation
+        if self.thumbnail_generation:
+            _dict["thumbnailGeneration"] = self.thumbnail_generation.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of video_conversion
+        if self.video_conversion:
+            _dict["videoConversion"] = self.video_conversion.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of workflow
+        if self.workflow:
+            _dict["workflow"] = self.workflow.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigJobDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "backgroundTask": JobSettingsDto.from_dict(obj["backgroundTask"])
+                if obj.get("backgroundTask") is not None
+                else None,
+                "faceDetection": JobSettingsDto.from_dict(obj["faceDetection"])
+                if obj.get("faceDetection") is not None
+                else None,
+                "library": JobSettingsDto.from_dict(obj["library"])
+                if obj.get("library") is not None
+                else None,
+                "metadataExtraction": JobSettingsDto.from_dict(
+                    obj["metadataExtraction"]
+                )
+                if obj.get("metadataExtraction") is not None
+                else None,
+                "migration": JobSettingsDto.from_dict(obj["migration"])
+                if obj.get("migration") is not None
+                else None,
+                "notifications": JobSettingsDto.from_dict(obj["notifications"])
+                if obj.get("notifications") is not None
+                else None,
+                "ocr": JobSettingsDto.from_dict(obj["ocr"])
+                if obj.get("ocr") is not None
+                else None,
+                "search": JobSettingsDto.from_dict(obj["search"])
+                if obj.get("search") is not None
+                else None,
+                "sidecar": JobSettingsDto.from_dict(obj["sidecar"])
+                if obj.get("sidecar") is not None
+                else None,
+                "smartSearch": JobSettingsDto.from_dict(obj["smartSearch"])
+                if obj.get("smartSearch") is not None
+                else None,
+                "thumbnailGeneration": JobSettingsDto.from_dict(
+                    obj["thumbnailGeneration"]
+                )
+                if obj.get("thumbnailGeneration") is not None
+                else None,
+                "videoConversion": JobSettingsDto.from_dict(obj["videoConversion"])
+                if obj.get("videoConversion") is not None
+                else None,
+                "workflow": JobSettingsDto.from_dict(obj["workflow"])
+                if obj.get("workflow") is not None
+                else None,
+            }
+        )
+        return _obj

immich/client/models/system_config_library_dto.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from immich.client.models.system_config_library_scan_dto import (
+    SystemConfigLibraryScanDto,
+)
+from immich.client.models.system_config_library_watch_dto import (
+    SystemConfigLibraryWatchDto,
+)
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigLibraryDto(BaseModel):
+    """
+    SystemConfigLibraryDto
+    """  # noqa: E501
+
+    scan: SystemConfigLibraryScanDto
+    watch: SystemConfigLibraryWatchDto
+    __properties: ClassVar[List[str]] = ["scan", "watch"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of scan
+        if self.scan:
+            _dict["scan"] = self.scan.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of watch
+        if self.watch:
+            _dict["watch"] = self.watch.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "scan": SystemConfigLibraryScanDto.from_dict(obj["scan"])
+                if obj.get("scan") is not None
+                else None,
+                "watch": SystemConfigLibraryWatchDto.from_dict(obj["watch"])
+                if obj.get("watch") is not None
+                else None,
+            }
+        )
+        return _obj

immich/client/models/system_config_library_scan_dto.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigLibraryScanDto(BaseModel):
+    """
+    SystemConfigLibraryScanDto
+    """  # noqa: E501
+
+    cron_expression: StrictStr = Field(alias="cronExpression")
+    enabled: StrictBool
+    __properties: ClassVar[List[str]] = ["cronExpression", "enabled"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryScanDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryScanDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"cronExpression": obj.get("cronExpression"), "enabled": obj.get("enabled")}
+        )
+        return _obj

immich/client/models/system_config_library_watch_dto.py

@@ -0,0 +1,82 @@
+# coding: utf-8
+
+"""
+Immich
+
+Immich API
+
+The version of the OpenAPI document: 2.4.1
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SystemConfigLibraryWatchDto(BaseModel):
+    """
+    SystemConfigLibraryWatchDto
+    """  # noqa: E501
+
+    enabled: StrictBool
+    __properties: ClassVar[List[str]] = ["enabled"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryWatchDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SystemConfigLibraryWatchDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"enabled": obj.get("enabled")})
+        return _obj