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

beetkeeper_api_client/models/event_search_result.py

@@ -0,0 +1,107 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from beetkeeper_api_client.models.beets_event_type import BeetsEventType
+from beetkeeper_api_client.models.current_beets_subject_state import CurrentBeetsSubjectState
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class EventSearchResult(BaseModel):
+    """
+    A model with an aggregate of details for an event search match.
+    """ # noqa: E501
+    event_id: StrictInt = Field(description="The beetkeeper event ID associated with this match.")
+    event_type: BeetsEventType = Field(description="The type of beets event ( https://beets.readthedocs.io/en/stable/dev/plugins/events.html ).")
+    event_time: datetime = Field(description="The time of the event taking place.")
+    beets_id: StrictInt = Field(description="The beets ID of the event's subject (either beets Album ID or Item ID).")
+    current_beets_subject_state: Optional[CurrentBeetsSubjectState] = None
+    __properties: ClassVar[List[str]] = ["event_id", "event_type", "event_time", "beets_id", "current_beets_subject_state"]
+
+    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 EventSearchResult 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 current_beets_subject_state
+        if self.current_beets_subject_state:
+            _dict['current_beets_subject_state'] = self.current_beets_subject_state.to_dict()
+        # set to None if current_beets_subject_state (nullable) is None
+        # and model_fields_set contains the field
+        if self.current_beets_subject_state is None and "current_beets_subject_state" in self.model_fields_set:
+            _dict['current_beets_subject_state'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EventSearchResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "event_id": obj.get("event_id"),
+            "event_type": obj.get("event_type"),
+            "event_time": obj.get("event_time"),
+            "beets_id": obj.get("beets_id"),
+            "current_beets_subject_state": CurrentBeetsSubjectState.from_dict(obj["current_beets_subject_state"]) if obj.get("current_beets_subject_state") is not None else None
+        })
+        return _obj
+
+

beetkeeper_api_client/models/event_subject_summary.py

@@ -0,0 +1,100 @@
+# 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, StrictInt, StrictStr
+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 EventSubjectSummary(BaseModel):
+    """
+    One beets album or track referenced by a listener event: its beets id plus the name recorded at push time (the album/release name, or the track title). Either part can be missing: rows ingested before names were recorded have no name, and a singleton's release name has no beets album id.
+    """ # noqa: E501
+    beets_id: Optional[StrictInt] = None
+    name: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["beets_id", "name"]
+
+    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 EventSubjectSummary 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_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.beets_id is None and "beets_id" in self.model_fields_set:
+            _dict['beets_id'] = None
+
+        # set to None if name (nullable) is None
+        # and model_fields_set contains the field
+        if self.name is None and "name" in self.model_fields_set:
+            _dict['name'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EventSubjectSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "beets_id": obj.get("beets_id"),
+            "name": obj.get("name")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/events_list_response.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.listener_event_details import ListenerEventDetails
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class EventsListResponse(BaseModel):
+    """
+    Response payload for the events listing: recently ingested listener events, newest first.
+    """ # noqa: E501
+    events: Optional[List[ListenerEventDetails]] = None
+    __properties: ClassVar[List[str]] = ["events"]
+
+    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 EventsListResponse 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 events (list)
+        _items = []
+        if self.events:
+            for _item_events in self.events:
+                _items.append(_item_events.to_dict() if _item_events is not None else None)
+            _dict['events'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EventsListResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "events": [ListenerEventDetails.from_dict(_item) for _item in obj["events"]] if obj.get("events") is not None else None
+        })
+        return _obj
+
+

beetkeeper_api_client/models/find_missing_source_path_request.py

@@ -0,0 +1,100 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FindMissingSourcePathRequest(BaseModel):
+    """
+    Body of `POST /api/import/find_missing_source_path`: the entry to ask the downloader about.
+    """ # 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`.")
+    __properties: ClassVar[List[str]] = ["beets_album_id", "beets_item_id"]
+
+    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 FindMissingSourcePathRequest 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FindMissingSourcePathRequest 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")
+        })
+        return _obj
+
+

beetkeeper_api_client/models/find_missing_source_path_response.py

@@ -0,0 +1,108 @@
+# 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 import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FindMissingSourcePathResponse(BaseModel):
+    """
+    Response model for the `/find_missing_source_path` endpoint.
+    """ # noqa: E501
+    found_match: StrictBool = Field(description="True if the missing source path search returned a matching result.")
+    search_status_code: Optional[StrictInt] = Field(default=None, description="The HTTP status code of the downloader API search, when one was made.")
+    source_directory: Optional[StrictStr] = Field(default=None, description="The source directory (as mounted on the app container) from the matched search, if any.")
+    var_query_params: Optional[Dict[str, StrictStr]] = Field(default=None, description="The query params the search was made with (the renamed beets fields).", alias="query_params")
+    detail: Optional[StrictStr] = Field(default='', description="Why no match was found, when `found_match` is false.")
+    recorded_inference: Optional[StrictBool] = Field(default=False, description="True when the match was stored as the entry's *inferred* source path (shown as such on the search page; kept apart from source paths recorded from the beetkeeper plugin's events).")
+    __properties: ClassVar[List[str]] = ["found_match", "search_status_code", "source_directory", "query_params", "detail", "recorded_inference"]
+
+    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 FindMissingSourcePathResponse 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 search_status_code (nullable) is None
+        # and model_fields_set contains the field
+        if self.search_status_code is None and "search_status_code" in self.model_fields_set:
+            _dict['search_status_code'] = None
+
+        # set to None if source_directory (nullable) is None
+        # and model_fields_set contains the field
+        if self.source_directory is None and "source_directory" in self.model_fields_set:
+            _dict['source_directory'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FindMissingSourcePathResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "found_match": obj.get("found_match"),
+            "search_status_code": obj.get("search_status_code"),
+            "source_directory": obj.get("source_directory"),
+            "query_params": obj.get("query_params"),
+            "detail": obj.get("detail") if obj.get("detail") is not None else '',
+            "recorded_inference": obj.get("recorded_inference") if obj.get("recorded_inference") is not None else False
+        })
+        return _obj
+
+

beetkeeper_api_client/models/health_info.py

@@ -0,0 +1,101 @@
+# 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, StrictBool, StrictInt, StrictStr
+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 HealthInfo(BaseModel):
+    """
+    Per-process health snapshot.
+    """ # noqa: E501
+    process_pid: StrictInt
+    hostname: StrictStr
+    import_lock_holder: Optional[StrictStr]
+    is_import_leader: StrictBool
+    job_count: StrictInt
+    __properties: ClassVar[List[str]] = ["process_pid", "hostname", "import_lock_holder", "is_import_leader", "job_count"]
+
+    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 HealthInfo 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 import_lock_holder (nullable) is None
+        # and model_fields_set contains the field
+        if self.import_lock_holder is None and "import_lock_holder" in self.model_fields_set:
+            _dict['import_lock_holder'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of HealthInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "process_pid": obj.get("process_pid"),
+            "hostname": obj.get("hostname"),
+            "import_lock_holder": obj.get("import_lock_holder"),
+            "is_import_leader": obj.get("is_import_leader"),
+            "job_count": obj.get("job_count")
+        })
+        return _obj
+
+