immich 1.2.1__py3-none-any.whl

immich/client/models/queue_response_legacy_dto.py

@@ -0,0 +1,100 @@
+# 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.queue_statistics_dto import QueueStatisticsDto
+from immich.client.models.queue_status_legacy_dto import QueueStatusLegacyDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class QueueResponseLegacyDto(BaseModel):
+    """
+    QueueResponseLegacyDto
+    """  # noqa: E501
+
+    job_counts: QueueStatisticsDto = Field(alias="jobCounts")
+    queue_status: QueueStatusLegacyDto = Field(alias="queueStatus")
+    __properties: ClassVar[List[str]] = ["jobCounts", "queueStatus"]
+
+    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 QueueResponseLegacyDto 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 job_counts
+        if self.job_counts:
+            _dict["jobCounts"] = self.job_counts.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of queue_status
+        if self.queue_status:
+            _dict["queueStatus"] = self.queue_status.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of QueueResponseLegacyDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "jobCounts": QueueStatisticsDto.from_dict(obj["jobCounts"])
+                if obj.get("jobCounts") is not None
+                else None,
+                "queueStatus": QueueStatusLegacyDto.from_dict(obj["queueStatus"])
+                if obj.get("queueStatus") is not None
+                else None,
+            }
+        )
+        return _obj

immich/client/models/queue_statistics_dto.py

@@ -0,0 +1,103 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class QueueStatisticsDto(BaseModel):
+    """
+    QueueStatisticsDto
+    """  # noqa: E501
+
+    active: StrictInt
+    completed: StrictInt
+    delayed: StrictInt
+    failed: StrictInt
+    paused: StrictInt
+    waiting: StrictInt
+    __properties: ClassVar[List[str]] = [
+        "active",
+        "completed",
+        "delayed",
+        "failed",
+        "paused",
+        "waiting",
+    ]
+
+    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 QueueStatisticsDto 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 QueueStatisticsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "active": obj.get("active"),
+                "completed": obj.get("completed"),
+                "delayed": obj.get("delayed"),
+                "failed": obj.get("failed"),
+                "paused": obj.get("paused"),
+                "waiting": obj.get("waiting"),
+            }
+        )
+        return _obj

immich/client/models/queue_status_legacy_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
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class QueueStatusLegacyDto(BaseModel):
+    """
+    QueueStatusLegacyDto
+    """  # noqa: E501
+
+    is_active: StrictBool = Field(alias="isActive")
+    is_paused: StrictBool = Field(alias="isPaused")
+    __properties: ClassVar[List[str]] = ["isActive", "isPaused"]
+
+    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 QueueStatusLegacyDto 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 QueueStatusLegacyDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"isActive": obj.get("isActive"), "isPaused": obj.get("isPaused")}
+        )
+        return _obj

immich/client/models/queue_update_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, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Set
+from typing_extensions import Self
+
+
+class QueueUpdateDto(BaseModel):
+    """
+    QueueUpdateDto
+    """  # noqa: E501
+
+    is_paused: Optional[StrictBool] = Field(default=None, alias="isPaused")
+    __properties: ClassVar[List[str]] = ["isPaused"]
+
+    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 QueueUpdateDto 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 QueueUpdateDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"isPaused": obj.get("isPaused")})
+        return _obj

immich/client/models/queues_response_legacy_dto.py

@@ -0,0 +1,242 @@
+# 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.queue_response_legacy_dto import QueueResponseLegacyDto
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class QueuesResponseLegacyDto(BaseModel):
+    """
+    QueuesResponseLegacyDto
+    """  # noqa: E501
+
+    background_task: QueueResponseLegacyDto = Field(alias="backgroundTask")
+    backup_database: QueueResponseLegacyDto = Field(alias="backupDatabase")
+    duplicate_detection: QueueResponseLegacyDto = Field(alias="duplicateDetection")
+    face_detection: QueueResponseLegacyDto = Field(alias="faceDetection")
+    facial_recognition: QueueResponseLegacyDto = Field(alias="facialRecognition")
+    library: QueueResponseLegacyDto
+    metadata_extraction: QueueResponseLegacyDto = Field(alias="metadataExtraction")
+    migration: QueueResponseLegacyDto
+    notifications: QueueResponseLegacyDto
+    ocr: QueueResponseLegacyDto
+    search: QueueResponseLegacyDto
+    sidecar: QueueResponseLegacyDto
+    smart_search: QueueResponseLegacyDto = Field(alias="smartSearch")
+    storage_template_migration: QueueResponseLegacyDto = Field(
+        alias="storageTemplateMigration"
+    )
+    thumbnail_generation: QueueResponseLegacyDto = Field(alias="thumbnailGeneration")
+    video_conversion: QueueResponseLegacyDto = Field(alias="videoConversion")
+    workflow: QueueResponseLegacyDto
+    __properties: ClassVar[List[str]] = [
+        "backgroundTask",
+        "backupDatabase",
+        "duplicateDetection",
+        "faceDetection",
+        "facialRecognition",
+        "library",
+        "metadataExtraction",
+        "migration",
+        "notifications",
+        "ocr",
+        "search",
+        "sidecar",
+        "smartSearch",
+        "storageTemplateMigration",
+        "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 QueuesResponseLegacyDto 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 backup_database
+        if self.backup_database:
+            _dict["backupDatabase"] = self.backup_database.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of duplicate_detection
+        if self.duplicate_detection:
+            _dict["duplicateDetection"] = self.duplicate_detection.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 facial_recognition
+        if self.facial_recognition:
+            _dict["facialRecognition"] = self.facial_recognition.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 storage_template_migration
+        if self.storage_template_migration:
+            _dict["storageTemplateMigration"] = (
+                self.storage_template_migration.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 QueuesResponseLegacyDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "backgroundTask": QueueResponseLegacyDto.from_dict(
+                    obj["backgroundTask"]
+                )
+                if obj.get("backgroundTask") is not None
+                else None,
+                "backupDatabase": QueueResponseLegacyDto.from_dict(
+                    obj["backupDatabase"]
+                )
+                if obj.get("backupDatabase") is not None
+                else None,
+                "duplicateDetection": QueueResponseLegacyDto.from_dict(
+                    obj["duplicateDetection"]
+                )
+                if obj.get("duplicateDetection") is not None
+                else None,
+                "faceDetection": QueueResponseLegacyDto.from_dict(obj["faceDetection"])
+                if obj.get("faceDetection") is not None
+                else None,
+                "facialRecognition": QueueResponseLegacyDto.from_dict(
+                    obj["facialRecognition"]
+                )
+                if obj.get("facialRecognition") is not None
+                else None,
+                "library": QueueResponseLegacyDto.from_dict(obj["library"])
+                if obj.get("library") is not None
+                else None,
+                "metadataExtraction": QueueResponseLegacyDto.from_dict(
+                    obj["metadataExtraction"]
+                )
+                if obj.get("metadataExtraction") is not None
+                else None,
+                "migration": QueueResponseLegacyDto.from_dict(obj["migration"])
+                if obj.get("migration") is not None
+                else None,
+                "notifications": QueueResponseLegacyDto.from_dict(obj["notifications"])
+                if obj.get("notifications") is not None
+                else None,
+                "ocr": QueueResponseLegacyDto.from_dict(obj["ocr"])
+                if obj.get("ocr") is not None
+                else None,
+                "search": QueueResponseLegacyDto.from_dict(obj["search"])
+                if obj.get("search") is not None
+                else None,
+                "sidecar": QueueResponseLegacyDto.from_dict(obj["sidecar"])
+                if obj.get("sidecar") is not None
+                else None,
+                "smartSearch": QueueResponseLegacyDto.from_dict(obj["smartSearch"])
+                if obj.get("smartSearch") is not None
+                else None,
+                "storageTemplateMigration": QueueResponseLegacyDto.from_dict(
+                    obj["storageTemplateMigration"]
+                )
+                if obj.get("storageTemplateMigration") is not None
+                else None,
+                "thumbnailGeneration": QueueResponseLegacyDto.from_dict(
+                    obj["thumbnailGeneration"]
+                )
+                if obj.get("thumbnailGeneration") is not None
+                else None,
+                "videoConversion": QueueResponseLegacyDto.from_dict(
+                    obj["videoConversion"]
+                )
+                if obj.get("videoConversion") is not None
+                else None,
+                "workflow": QueueResponseLegacyDto.from_dict(obj["workflow"])
+                if obj.get("workflow") is not None
+                else None,
+            }
+        )
+        return _obj