beetkeeper-api-client 0.12.0__py3-none-any.whl

beetkeeper_api_client/models/http_validation_error.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    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, Optional
+from beetkeeper_api_client.models.validation_error import ValidationError
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class HTTPValidationError(BaseModel):
+    """
+    HTTPValidationError
+    """ # noqa: E501
+    detail: Optional[List[ValidationError]] = None
+    __properties: ClassVar[List[str]] = ["detail"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of HTTPValidationError 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 each item in detail (list)
+        _items = []
+        if self.detail:
+            for _item_detail in self.detail:
+                _items.append(_item_detail.to_dict() if _item_detail is not None else None)
+            _dict['detail'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of HTTPValidationError from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "detail": [ValidationError.from_dict(_item) for _item in obj["detail"]] if obj.get("detail") is not None else None
+        })
+        return _obj
+
+

beetkeeper_api_client/models/import_action.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class ImportAction(str, Enum):
+    """
+    beetkeeper-side mirror of beets' import `action` choices (decoupled from beets internals).  `APPLY` imports with the chosen candidate's metadata, `ASIS` imports without changing tags, `SKIP` skips the task.
+    """
+
+    """
+    allowed enum values
+    """
+    APPLY = 'apply'
+    ASIS = 'asis'
+    SKIP = 'skip'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ImportAction from a JSON string"""
+        return cls(json.loads(json_str))
+
+

beetkeeper_api_client/models/import_candidate.py

@@ -0,0 +1,171 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ImportCandidate(BaseModel):
+    """
+    A serializable view of one beets match candidate, surfaced to the UI for selection.  Beyond the headline `label`/`similarity`, the optional release attributes below let the UI tell otherwise-identical candidates apart (e.g. different pressings/editions of the same album); `details` joins the populated ones into a single human-readable line for display.
+    """ # noqa: E501
+    index: StrictInt
+    label: StrictStr
+    similarity: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="1.0 - beets match distance, if available.")
+    data_source: Optional[StrictStr] = None
+    year: Optional[StrictInt] = None
+    country: Optional[StrictStr] = None
+    media: Optional[StrictStr] = None
+    record_label: Optional[StrictStr] = None
+    catalognum: Optional[StrictStr] = None
+    disambiguation: Optional[StrictStr] = None
+    track_count: Optional[StrictInt] = None
+    album_id: Optional[StrictStr] = Field(default=None, description="Source-specific release id (e.g. a MusicBrainz MBID).")
+    release_url: Optional[StrictStr] = Field(default=None, description="Web URL for the release, from the source plugin (beets' `AlbumInfo.data_url`).")
+    details: StrictStr = Field(description="One-line summary of the differentiating attributes (empty string when none are known).")
+    __properties: ClassVar[List[str]] = ["index", "label", "similarity", "data_source", "year", "country", "media", "record_label", "catalognum", "disambiguation", "track_count", "album_id", "release_url", "details"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ImportCandidate 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.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "details",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if similarity (nullable) is None
+        # and model_fields_set contains the field
+        if self.similarity is None and "similarity" in self.model_fields_set:
+            _dict['similarity'] = None
+
+        # set to None if data_source (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_source is None and "data_source" in self.model_fields_set:
+            _dict['data_source'] = None
+
+        # set to None if year (nullable) is None
+        # and model_fields_set contains the field
+        if self.year is None and "year" in self.model_fields_set:
+            _dict['year'] = None
+
+        # set to None if country (nullable) is None
+        # and model_fields_set contains the field
+        if self.country is None and "country" in self.model_fields_set:
+            _dict['country'] = None
+
+        # set to None if media (nullable) is None
+        # and model_fields_set contains the field
+        if self.media is None and "media" in self.model_fields_set:
+            _dict['media'] = None
+
+        # set to None if record_label (nullable) is None
+        # and model_fields_set contains the field
+        if self.record_label is None and "record_label" in self.model_fields_set:
+            _dict['record_label'] = None
+
+        # set to None if catalognum (nullable) is None
+        # and model_fields_set contains the field
+        if self.catalognum is None and "catalognum" in self.model_fields_set:
+            _dict['catalognum'] = None
+
+        # set to None if disambiguation (nullable) is None
+        # and model_fields_set contains the field
+        if self.disambiguation is None and "disambiguation" in self.model_fields_set:
+            _dict['disambiguation'] = None
+
+        # set to None if track_count (nullable) is None
+        # and model_fields_set contains the field
+        if self.track_count is None and "track_count" in self.model_fields_set:
+            _dict['track_count'] = None
+
+        # set to None if album_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.album_id is None and "album_id" in self.model_fields_set:
+            _dict['album_id'] = None
+
+        # set to None if release_url (nullable) is None
+        # and model_fields_set contains the field
+        if self.release_url is None and "release_url" in self.model_fields_set:
+            _dict['release_url'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ImportCandidate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "index": obj.get("index"),
+            "label": obj.get("label"),
+            "similarity": obj.get("similarity"),
+            "data_source": obj.get("data_source"),
+            "year": obj.get("year"),
+            "country": obj.get("country"),
+            "media": obj.get("media"),
+            "record_label": obj.get("record_label"),
+            "catalognum": obj.get("catalognum"),
+            "disambiguation": obj.get("disambiguation"),
+            "track_count": obj.get("track_count"),
+            "album_id": obj.get("album_id"),
+            "release_url": obj.get("release_url"),
+            "details": obj.get("details")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/import_decision.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from beetkeeper_api_client.models.import_action import ImportAction
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ImportDecision(BaseModel):
+    """
+    The user's answer to a `DecisionRequest` (posted back from the UI).
+    """ # noqa: E501
+    action: ImportAction
+    candidate_index: Optional[StrictInt] = Field(default=None, description="Required when `action` is APPLY.")
+    __properties: ClassVar[List[str]] = ["action", "candidate_index"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ImportDecision 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,
+        )
+        # set to None if candidate_index (nullable) is None
+        # and model_fields_set contains the field
+        if self.candidate_index is None and "candidate_index" in self.model_fields_set:
+            _dict['candidate_index'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ImportDecision from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "action": obj.get("action"),
+            "candidate_index": obj.get("candidate_index")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/import_job.py

@@ -0,0 +1,162 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from beetkeeper_api_client.models.decision_request import DecisionRequest
+from beetkeeper_api_client.models.import_job_status import ImportJobStatus
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ImportJob(BaseModel):
+    """
+    API-facing view of a single import job (the persisted record is `db.models.ImportJobRecord`).
+    """ # noqa: E501
+    id: StrictStr = Field(description="Unique job id (32 hex characters), the `job_id` of the per-job import routes.")
+    status: ImportJobStatus = Field(description="The job's lifecycle state.")
+    paths: List[StrictStr] = Field(description="The filesystem paths beets imports (for a clean slate, the removed entry's raw source folder).")
+    created_at: datetime = Field(description="When the job was submitted (naive UTC).")
+    error: Optional[StrictStr] = Field(default=None, description="Why the job FAILED, once it has; None otherwise.")
+    pending_decision: Optional[DecisionRequest] = Field(default=None, description="The decision the worker is parked on while AWAITING_DECISION; None otherwise.")
+    decision_submitted: Optional[StrictBool] = Field(default=False, description="True once the UI has answered the pending decision but the worker has not consumed it yet: the job is momentarily still AWAITING_DECISION, so keep polling instead of re-showing the prompt.")
+    output: Optional[StrictStr] = Field(default=None, description="Human-readable, append-only log of the import's progress.")
+    quiet: Optional[StrictBool] = Field(default=False, description="Non-interactive (`beet import -q`) mode: the worker auto-decides matches instead of prompting.")
+    logpath: Optional[StrictStr] = Field(default=None, description="The `beet import -l` log file path, if any.")
+    group_albums: Optional[StrictBool] = Field(default=False, description="The `beet import --group-albums` flag.")
+    flat: Optional[StrictBool] = Field(default=False, description="The `beet import --flat` flag.")
+    set_fields: Optional[Dict[str, StrictStr]] = Field(default=None, description="The `beet import --set` field values.")
+    clean_slate_album_id: Optional[StrictInt] = Field(default=None, description="The library album removed before `paths` (its source folder) is imported afresh.")
+    clean_slate_item_id: Optional[StrictInt] = Field(default=None, description="The standalone track removed before `paths` is imported afresh. At most one clean-slate id is set; both None means a plain path import.")
+    clean_slate_allow_fewer_files: Optional[StrictBool] = Field(default=False, description="The submitter's opt-in to a source holding fewer audio files than the entry has on disk (see `CleanSlatePreview.needs_confirmation`); the worker re-runs the preview with it before removing anything.")
+    is_clean_slate: StrictBool = Field(description="Whether this job removes an existing library entry before importing its source afresh.")
+    source_label: StrictStr = Field(description="Display name for the import source: the path basename(s), prefixed for a clean-slate import.")
+    __properties: ClassVar[List[str]] = ["id", "status", "paths", "created_at", "error", "pending_decision", "decision_submitted", "output", "quiet", "logpath", "group_albums", "flat", "set_fields", "clean_slate_album_id", "clean_slate_item_id", "clean_slate_allow_fewer_files", "is_clean_slate", "source_label"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ImportJob 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.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set([
+            "is_clean_slate",
+            "source_label",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of pending_decision
+        if self.pending_decision:
+            _dict['pending_decision'] = self.pending_decision.to_dict()
+        # set to None if error (nullable) is None
+        # and model_fields_set contains the field
+        if self.error is None and "error" in self.model_fields_set:
+            _dict['error'] = None
+
+        # set to None if pending_decision (nullable) is None
+        # and model_fields_set contains the field
+        if self.pending_decision is None and "pending_decision" in self.model_fields_set:
+            _dict['pending_decision'] = None
+
+        # set to None if output (nullable) is None
+        # and model_fields_set contains the field
+        if self.output is None and "output" in self.model_fields_set:
+            _dict['output'] = None
+
+        # set to None if logpath (nullable) is None
+        # and model_fields_set contains the field
+        if self.logpath is None and "logpath" in self.model_fields_set:
+            _dict['logpath'] = None
+
+        # set to None if clean_slate_album_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.clean_slate_album_id is None and "clean_slate_album_id" in self.model_fields_set:
+            _dict['clean_slate_album_id'] = None
+
+        # set to None if clean_slate_item_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.clean_slate_item_id is None and "clean_slate_item_id" in self.model_fields_set:
+            _dict['clean_slate_item_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ImportJob from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "status": obj.get("status"),
+            "paths": obj.get("paths"),
+            "created_at": obj.get("created_at"),
+            "error": obj.get("error"),
+            "pending_decision": DecisionRequest.from_dict(obj["pending_decision"]) if obj.get("pending_decision") is not None else None,
+            "decision_submitted": obj.get("decision_submitted") if obj.get("decision_submitted") is not None else False,
+            "output": obj.get("output"),
+            "quiet": obj.get("quiet") if obj.get("quiet") is not None else False,
+            "logpath": obj.get("logpath"),
+            "group_albums": obj.get("group_albums") if obj.get("group_albums") is not None else False,
+            "flat": obj.get("flat") if obj.get("flat") is not None else False,
+            "set_fields": obj.get("set_fields"),
+            "clean_slate_album_id": obj.get("clean_slate_album_id"),
+            "clean_slate_item_id": obj.get("clean_slate_item_id"),
+            "clean_slate_allow_fewer_files": obj.get("clean_slate_allow_fewer_files") if obj.get("clean_slate_allow_fewer_files") is not None else False,
+            "is_clean_slate": obj.get("is_clean_slate"),
+            "source_label": obj.get("source_label")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/import_job_status.py

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+"""
+    beetkeeper
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class ImportJobStatus(str, Enum):
+    """
+    Lifecycle states of an import job.
+    """
+
+    """
+    allowed enum values
+    """
+    PENDING = 'pending'
+    RUNNING = 'running'
+    AWAITING_DECISION = 'awaiting_decision'
+    COMPLETED = 'completed'
+    FAILED = 'failed'
+    ABORTED = 'aborted'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ImportJobStatus from a JSON string"""
+        return cls(json.loads(json_str))
+
+