mycelium-ai 0.5.0__py3-none-any.whl

mycelium/api/generated_sources/server_schemas/models/scan_library_response.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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, Field, StrictInt, StrictStr, ConfigDict
+
+class ScanLibraryResponse(BaseModel):
+    """
+    ScanLibraryResponse
+    """
+    message: StrictStr = Field(...)
+    total_tracks: StrictInt = Field(...)
+    new_tracks: StrictInt = Field(...)
+    updated_tracks: StrictInt = Field(...)
+    scan_timestamp: StrictStr = Field(...)
+    __properties = ["message", "total_tracks", "new_tracks", "updated_tracks", "scan_timestamp"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ScanLibraryResponse:
+        """Create an instance of ScanLibraryResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ScanLibraryResponse:
+        """Create an instance of ScanLibraryResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ScanLibraryResponse.model_validate(obj)
+
+        _obj = ScanLibraryResponse.model_validate({
+            "message": obj.get("message"),
+            "total_tracks": obj.get("total_tracks"),
+            "new_tracks": obj.get("new_tracks"),
+            "updated_tracks": obj.get("updated_tracks"),
+            "scan_timestamp": obj.get("scan_timestamp")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/search_result_response.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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 typing import Union
+from pydantic import BaseModel, Field, StrictFloat, StrictInt, ConfigDict
+from mycelium.api.generated_sources.server_schemas.models.track_response import TrackResponse
+
+class SearchResultResponse(BaseModel):
+    """
+    SearchResultResponse
+    """
+    track: TrackResponse = Field(...)
+    similarity_score: Union[StrictFloat, StrictInt] = Field(...)
+    distance: Union[StrictFloat, StrictInt] = Field(...)
+    __properties = ["track", "similarity_score", "distance"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> SearchResultResponse:
+        """Create an instance of SearchResultResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of track
+        if self.track:
+            _dict['track'] = self.track.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> SearchResultResponse:
+        """Create an instance of SearchResultResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return SearchResultResponse.model_validate(obj)
+
+        _obj = SearchResultResponse.model_validate({
+            "track": TrackResponse.from_dict(obj.get("track")) if obj.get("track") is not None else None,
+            "similarity_score": obj.get("similarity_score"),
+            "distance": obj.get("distance")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/server_section.py

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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, Field, StrictInt, ConfigDict
+
+class ServerSection(BaseModel):
+    """
+    ServerSection
+    """
+    gpu_batch_size: StrictInt = Field(...)
+    __properties = ["gpu_batch_size"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ServerSection:
+        """Create an instance of ServerSection from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ServerSection:
+        """Create an instance of ServerSection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ServerSection.model_validate(obj)
+
+        _obj = ServerSection.model_validate({
+            "gpu_batch_size": obj.get("gpu_batch_size")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/stop_processing_response.py

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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 typing import Optional
+from pydantic import BaseModel, Field, StrictInt, StrictStr, ConfigDict
+
+class StopProcessingResponse(BaseModel):
+    """
+    StopProcessingResponse
+    """
+    message: StrictStr = Field(...)
+    type: Optional[StrictStr] = None
+    cleared_tasks: Optional[StrictInt] = None
+    __properties = ["message", "type", "cleared_tasks"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> StopProcessingResponse:
+        """Create an instance of StopProcessingResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> StopProcessingResponse:
+        """Create an instance of StopProcessingResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return StopProcessingResponse.model_validate(obj)
+
+        _obj = StopProcessingResponse.model_validate({
+            "message": obj.get("message"),
+            "type": obj.get("type"),
+            "cleared_tasks": obj.get("cleared_tasks")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/task_status_response.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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 typing import List, Optional
+from pydantic import BaseModel, Field, StrictStr, conlist, ConfigDict
+from mycelium.api.generated_sources.server_schemas.models.search_result_response import SearchResultResponse
+
+class TaskStatusResponse(BaseModel):
+    """
+    TaskStatusResponse
+    """
+    task_id: StrictStr = Field(...)
+    status: StrictStr = Field(...)
+    track_id: Optional[StrictStr] = None
+    started_at: Optional[StrictStr] = None
+    completed_at: Optional[StrictStr] = None
+    error_message: Optional[StrictStr] = None
+    search_results: Optional[conlist(SearchResultResponse)] = None
+    __properties = ["task_id", "status", "track_id", "started_at", "completed_at", "error_message", "search_results"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> TaskStatusResponse:
+        """Create an instance of TaskStatusResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in search_results (list)
+        _items = []
+        if self.search_results:
+            for _item in self.search_results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['search_results'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TaskStatusResponse:
+        """Create an instance of TaskStatusResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TaskStatusResponse.model_validate(obj)
+
+        _obj = TaskStatusResponse.model_validate({
+            "task_id": obj.get("task_id"),
+            "status": obj.get("status"),
+            "track_id": obj.get("track_id"),
+            "started_at": obj.get("started_at"),
+            "completed_at": obj.get("completed_at"),
+            "error_message": obj.get("error_message"),
+            "search_results": [SearchResultResponse.from_dict(_item) for _item in obj.get("search_results")] if obj.get("search_results") is not None else None
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/track_database_stats.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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 typing import Optional, Union
+from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, ConfigDict
+
+class TrackDatabaseStats(BaseModel):
+    """
+    TrackDatabaseStats
+    """
+    total_tracks: StrictInt = Field(...)
+    processed_tracks: StrictInt = Field(...)
+    unprocessed_tracks: StrictInt = Field(...)
+    progress_percentage: Union[StrictFloat, StrictInt] = Field(...)
+    is_processing: Optional[StrictBool] = None
+    __properties = ["total_tracks", "processed_tracks", "unprocessed_tracks", "progress_percentage", "is_processing"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> TrackDatabaseStats:
+        """Create an instance of TrackDatabaseStats from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TrackDatabaseStats:
+        """Create an instance of TrackDatabaseStats from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TrackDatabaseStats.model_validate(obj)
+
+        _obj = TrackDatabaseStats.model_validate({
+            "total_tracks": obj.get("total_tracks"),
+            "processed_tracks": obj.get("processed_tracks"),
+            "unprocessed_tracks": obj.get("unprocessed_tracks"),
+            "progress_percentage": obj.get("progress_percentage"),
+            "is_processing": obj.get("is_processing")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/track_response.py

@@ -0,0 +1,77 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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, Field, StrictStr, ConfigDict
+
+class TrackResponse(BaseModel):
+    """
+    TrackResponse
+    """
+    artist: StrictStr = Field(...)
+    album: StrictStr = Field(...)
+    title: StrictStr = Field(...)
+    filepath: StrictStr = Field(...)
+    media_server_rating_key: StrictStr = Field(...)
+    media_server_type: StrictStr = Field(...)
+    __properties = ["artist", "album", "title", "filepath", "media_server_rating_key", "media_server_type"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> TrackResponse:
+        """Create an instance of TrackResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TrackResponse:
+        """Create an instance of TrackResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TrackResponse.model_validate(obj)
+
+        _obj = TrackResponse.model_validate({
+            "artist": obj.get("artist"),
+            "album": obj.get("album"),
+            "title": obj.get("title"),
+            "filepath": obj.get("filepath"),
+            "media_server_rating_key": obj.get("media_server_rating_key"),
+            "media_server_type": obj.get("media_server_type")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/tracks_list_response.py

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+"""
+    Mycelium API
+
+    Plex music collection and recommendation system using CLAP embeddings
+
+    The version of the OpenAPI document: 0.1.0
+    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 typing import List
+from pydantic import BaseModel, Field, StrictInt, conlist, ConfigDict
+from mycelium.api.generated_sources.server_schemas.models.track_response import TrackResponse
+
+class TracksListResponse(BaseModel):
+    """
+    TracksListResponse
+    """
+    tracks: conlist(TrackResponse) = Field(...)
+    total_count: StrictInt = Field(...)
+    page: StrictInt = Field(...)
+    limit: StrictInt = Field(...)
+    __properties = ["tracks", "total_count", "page", "limit"]
+
+    model_config = {"populate_by_name": True, "validate_assignment": True}
+    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(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> TracksListResponse:
+        """Create an instance of TracksListResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.model_dump(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in tracks (list)
+        _items = []
+        if self.tracks:
+            for _item in self.tracks:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['tracks'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> TracksListResponse:
+        """Create an instance of TracksListResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return TracksListResponse.model_validate(obj)
+
+        _obj = TracksListResponse.model_validate({
+            "tracks": [TrackResponse.from_dict(_item) for _item in obj.get("tracks")] if obj.get("tracks") is not None else None,
+            "total_count": obj.get("total_count"),
+            "page": obj.get("page"),
+            "limit": obj.get("limit")
+        })
+        return _obj
+
+