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

beetkeeper_api_client/models/clean_slate_preview.py

@@ -0,0 +1,147 @@
+# 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, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CleanSlatePreview(BaseModel):
+    """
+    The dry run of a clean-slate import: what removing the library entry and importing its source would do.  Produced read-only by `core.clean_slate.preview` for the API/UI preview, and again by the worker as the guard before it removes anything. `errors` lists the conditions that block the job outright; `warnings` are worth a look but do not block. `needs_confirmation` is set when the source folder holds fewer audio files than the entry currently has on disk — proceeding would delete files the source cannot replace, so the caller must opt in explicitly (`allow_fewer_files`).
+    """ # noqa: E501
+    subject: StrictStr
+    beets_id: StrictInt
+    label: StrictStr = Field(description="`albumartist - album` for an album, `artist - title` for a standalone track.")
+    item_count: StrictInt = Field(description="Library rows the entry holds (1 for a standalone track).")
+    files_present: StrictInt = Field(description="How many of those rows still have their file on disk.")
+    missing_paths: Optional[List[StrictStr]] = Field(default=None, description="Library paths whose file is gone.")
+    expected_tracks: Optional[StrictInt] = Field(default=None, description="Track total the album's tags claim (beets' `albumtotal`), when known.")
+    files_to_delete: Optional[List[StrictStr]] = Field(default=None, description="Library files the removal deletes (inside the beets directory).")
+    files_kept_outside_library: Optional[List[StrictStr]] = Field(default=None, description="Entry files left on disk because they live outside the beets directory.")
+    art_to_delete: Optional[StrictStr] = Field(default=None, description="The album art file the removal deletes, if any.")
+    flexible_attributes_lost: Optional[List[StrictStr]] = Field(default=None, description="Flexible attribute names on the entry that a clean slate does not keep (`fields_preserved` aside).")
+    fields_preserved: Optional[Dict[str, StrictStr]] = Field(default=None, description="The entry's flexible attributes named as keys of the `downloader_hook.beet_field_to_dl_search_field` config, with their values: re-applied to the fresh import via beets' `--set`.")
+    source_path: StrictStr
+    source_audio_files: Optional[StrictInt] = Field(default=0, description="Readable audio files found under the source path.")
+    source_album_groups: Optional[StrictInt] = Field(default=0, description="Album folders beets would import from the source.")
+    warnings: Optional[List[StrictStr]] = None
+    errors: Optional[List[StrictStr]] = None
+    needs_confirmation: Optional[StrictBool] = Field(default=False, description="The source has fewer audio files than the entry has on disk and `allow_fewer_files` was not set.")
+    ok: StrictBool = Field(description="Whether the clean slate may run as previewed (no blocking error and no outstanding confirmation).")
+    files_missing: StrictInt = Field(description="How many of the entry's rows point at a file that no longer exists.")
+    __properties: ClassVar[List[str]] = ["subject", "beets_id", "label", "item_count", "files_present", "missing_paths", "expected_tracks", "files_to_delete", "files_kept_outside_library", "art_to_delete", "flexible_attributes_lost", "fields_preserved", "source_path", "source_audio_files", "source_album_groups", "warnings", "errors", "needs_confirmation", "ok", "files_missing"]
+
+    @field_validator('subject')
+    def subject_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['album', 'track']):
+            raise ValueError("must be one of enum values ('album', 'track')")
+        return value
+
+    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 CleanSlatePreview 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([
+            "ok",
+            "files_missing",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if expected_tracks (nullable) is None
+        # and model_fields_set contains the field
+        if self.expected_tracks is None and "expected_tracks" in self.model_fields_set:
+            _dict['expected_tracks'] = None
+
+        # set to None if art_to_delete (nullable) is None
+        # and model_fields_set contains the field
+        if self.art_to_delete is None and "art_to_delete" in self.model_fields_set:
+            _dict['art_to_delete'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CleanSlatePreview from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "subject": obj.get("subject"),
+            "beets_id": obj.get("beets_id"),
+            "label": obj.get("label"),
+            "item_count": obj.get("item_count"),
+            "files_present": obj.get("files_present"),
+            "missing_paths": obj.get("missing_paths"),
+            "expected_tracks": obj.get("expected_tracks"),
+            "files_to_delete": obj.get("files_to_delete"),
+            "files_kept_outside_library": obj.get("files_kept_outside_library"),
+            "art_to_delete": obj.get("art_to_delete"),
+            "flexible_attributes_lost": obj.get("flexible_attributes_lost"),
+            "fields_preserved": obj.get("fields_preserved"),
+            "source_path": obj.get("source_path"),
+            "source_audio_files": obj.get("source_audio_files") if obj.get("source_audio_files") is not None else 0,
+            "source_album_groups": obj.get("source_album_groups") if obj.get("source_album_groups") is not None else 0,
+            "warnings": obj.get("warnings"),
+            "errors": obj.get("errors"),
+            "needs_confirmation": obj.get("needs_confirmation") if obj.get("needs_confirmation") is not None else False,
+            "ok": obj.get("ok"),
+            "files_missing": obj.get("files_missing")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/clean_slate_submit_request.py

@@ -0,0 +1,116 @@
+# 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, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CleanSlateSubmitRequest(BaseModel):
+    """
+    Body for starting a clean-slate import: remove the named library entry — its rows, the files inside the beets directory and the album art, like `beet remove -d` — then import `source_path` afresh as an ordinary path import (decisions, abort, quiet mode all apply). Nothing is carried over from the old entry — not its flexible attributes, not its added-date — except the flexible attributes named as keys of the `downloader_hook.beet_field_to_dl_search_field` config, whose values are re-applied to the fresh import via `set_fields` (winning over a `set_fields` entry of the same name). Option defaults come from the `beets.config` values.  The removal happens before the import starts; skipping or aborting the import afterwards leaves the entry removed and the source files where they are. Preview first with `GET /api/import/clean_slate/preview`.
+    """ # noqa: E501
+    beets_album_id: Optional[StrictInt] = Field(default=None, description="The beets library id of an album. Mutually exclusive with `beets_item_id`.")
+    beets_item_id: Optional[StrictInt] = Field(default=None, description="The beets library id of an item (track). Mutually exclusive with `beets_album_id`.")
+    source_path: Annotated[str, Field(min_length=1, strict=True)] = Field(description="The entry's raw (pre-import) source folder, under beetkeeper's `downloads_path`; for a standalone track, the audio file itself or a folder holding just that file.")
+    allow_fewer_files: Optional[StrictBool] = Field(default=False, description="Proceed even when the source holds fewer audio files than the entry currently has on disk (the clean slate would then delete files the source cannot replace). Off by default.")
+    quiet: Optional[StrictBool] = Field(default=None, description="Run non-interactively (like `beet import -q`). See `ImportSubmitRequest.quiet`.")
+    logpath: Optional[StrictStr] = Field(default=None, description="Corresponds to the `-l` option, or the config's `import.log` option.")
+    set_fields: Optional[Dict[str, StrictStr]] = Field(default=None, description="Corresponds to the `--set field=value` option for beets' `import` CLI command.")
+    __properties: ClassVar[List[str]] = ["beets_album_id", "beets_item_id", "source_path", "allow_fewer_files", "quiet", "logpath", "set_fields"]
+
+    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 CleanSlateSubmitRequest 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 beets_album_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.beets_album_id is None and "beets_album_id" in self.model_fields_set:
+            _dict['beets_album_id'] = None
+
+        # set to None if beets_item_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.beets_item_id is None and "beets_item_id" in self.model_fields_set:
+            _dict['beets_item_id'] = 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CleanSlateSubmitRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "beets_album_id": obj.get("beets_album_id"),
+            "beets_item_id": obj.get("beets_item_id"),
+            "source_path": obj.get("source_path"),
+            "allow_fewer_files": obj.get("allow_fewer_files") if obj.get("allow_fewer_files") is not None else False,
+            "quiet": obj.get("quiet"),
+            "logpath": obj.get("logpath"),
+            "set_fields": obj.get("set_fields")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/current_beets_subject_state.py

@@ -0,0 +1,140 @@
+# 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
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Optional
+from beetkeeper_api_client.models.api_album import APIAlbum
+from beetkeeper_api_client.models.api_track import APITrack
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+CURRENTBEETSSUBJECTSTATE_ANY_OF_SCHEMAS = ["APIAlbum", "APITrack"]
+
+class CurrentBeetsSubjectState(BaseModel):
+    """
+    Current state of the event's subject (Album or Item). Null if subject no longer exists.
+    """
+
+    # data type: APIAlbum
+    anyof_schema_1_validator: Optional[APIAlbum] = None
+    # data type: APITrack
+    anyof_schema_2_validator: Optional[APITrack] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[Union[APIAlbum, APITrack]] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = { "APIAlbum", "APITrack" }
+
+    model_config = {
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    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])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_anyof(cls, v):
+        if v is None:
+            return v
+
+        instance = CurrentBeetsSubjectState.model_construct()
+        error_messages = []
+        # validate data type: APIAlbum
+        if not isinstance(v, APIAlbum):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `APIAlbum`")
+        else:
+            return v
+
+        # validate data type: APITrack
+        if not isinstance(v, APITrack):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `APITrack`")
+        else:
+            return v
+
+        if error_messages:
+            # no match
+            raise ValueError("No match found when setting the actual_instance in CurrentBeetsSubjectState with anyOf schemas: APIAlbum, APITrack. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Dict[str, Any]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        if json_str is None:
+            return instance
+
+        error_messages = []
+        # anyof_schema_1_validator: Optional[APIAlbum] = None
+        try:
+            instance.actual_instance = APIAlbum.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+             error_messages.append(str(e))
+        # anyof_schema_2_validator: Optional[APITrack] = None
+        try:
+            instance.actual_instance = APITrack.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+             error_messages.append(str(e))
+
+        if error_messages:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into CurrentBeetsSubjectState with anyOf schemas: APIAlbum, APITrack. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    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):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], APIAlbum, APITrack]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

beetkeeper_api_client/models/decision_request.py

@@ -0,0 +1,104 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from beetkeeper_api_client.models.import_action import ImportAction
+from beetkeeper_api_client.models.import_candidate import ImportCandidate
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class DecisionRequest(BaseModel):
+    """
+    Published when the importer needs a user choice for a task; the matching `ImportDecision` unblocks it.
+    """ # noqa: E501
+    job_id: StrictStr
+    task_id: StrictStr
+    prompt: StrictStr
+    candidates: Optional[List[ImportCandidate]] = None
+    allowed_actions: Optional[List[ImportAction]] = None
+    __properties: ClassVar[List[str]] = ["job_id", "task_id", "prompt", "candidates", "allowed_actions"]
+
+    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 DecisionRequest 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 candidates (list)
+        _items = []
+        if self.candidates:
+            for _item_candidates in self.candidates:
+                _items.append(_item_candidates.to_dict() if _item_candidates is not None else None)
+            _dict['candidates'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DecisionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "job_id": obj.get("job_id"),
+            "task_id": obj.get("task_id"),
+            "prompt": obj.get("prompt"),
+            "candidates": [ImportCandidate.from_dict(_item) for _item in obj["candidates"]] if obj.get("candidates") is not None else None,
+            "allowed_actions": obj.get("allowed_actions")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/event_search_response.py

@@ -0,0 +1,97 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from beetkeeper_api_client.models.event_search_result import EventSearchResult
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class EventSearchResponse(BaseModel):
+    """
+    Response model for the `GET /api/events/(album|track)/{id}` and `GET /api/events/{event_id}` search routes.
+    """ # noqa: E501
+    results: Optional[List[EventSearchResult]] = None
+    errors: Optional[List[StrictStr]] = Field(default=None, description="Any error messages from the event search.")
+    __properties: ClassVar[List[str]] = ["results", "errors"]
+
+    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 EventSearchResponse 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 results (list)
+        _items = []
+        if self.results:
+            for _item_results in self.results:
+                _items.append(_item_results.to_dict() if _item_results is not None else None)
+            _dict['results'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EventSearchResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "results": [EventSearchResult.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None,
+            "errors": obj.get("errors")
+        })
+        return _obj
+
+