mycelium-ai 0.5.0__py3-none-any.whl

mycelium/api/generated_sources/server_schemas/models/api_section.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 pydantic import BaseModel, Field, StrictBool, StrictInt, StrictStr, ConfigDict
+
+class APISection(BaseModel):
+    """
+    APISection
+    """
+    host: StrictStr = Field(...)
+    port: StrictInt = Field(...)
+    reload: StrictBool = Field(...)
+    __properties = ["host", "port", "reload"]
+
+    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) -> APISection:
+        """Create an instance of APISection 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) -> APISection:
+        """Create an instance of APISection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return APISection.model_validate(obj)
+
+        _obj = APISection.model_validate({
+            "host": obj.get("host"),
+            "port": obj.get("port"),
+            "reload": obj.get("reload")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,69 @@
+# 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 ChromaSection(BaseModel):
+    """
+    ChromaSection
+    """
+    collection_name: StrictStr = Field(...)
+    batch_size: StrictInt = Field(...)
+    __properties = ["collection_name", "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) -> ChromaSection:
+        """Create an instance of ChromaSection 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) -> ChromaSection:
+        """Create an instance of ChromaSection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ChromaSection.model_validate(obj)
+
+        _obj = ChromaSection.model_validate({
+            "collection_name": obj.get("collection_name"),
+            "batch_size": obj.get("batch_size")
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/clap_section.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
+from pydantic import BaseModel, Field, StrictInt, StrictStr, ConfigDict
+
+class ClapSection(BaseModel):
+    """
+    ClapSection
+    """
+    model_id: StrictStr = Field(...)
+    target_sr: StrictInt = Field(...)
+    chunk_duration_s: StrictInt = Field(...)
+    num_chunks: StrictInt = Field(...)
+    max_load_duration_s: Optional[StrictInt] = None
+    __properties = ["model_id", "target_sr", "chunk_duration_s", "num_chunks", "max_load_duration_s"]
+
+    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) -> ClapSection:
+        """Create an instance of ClapSection 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) -> ClapSection:
+        """Create an instance of ClapSection from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ClapSection.model_validate(obj)
+
+        _obj = ClapSection.model_validate({
+            "model_id": obj.get("model_id"),
+            "target_sr": obj.get("target_sr"),
+            "chunk_duration_s": obj.get("chunk_duration_s"),
+            "num_chunks": obj.get("num_chunks"),
+            "max_load_duration_s": obj.get("max_load_duration_s")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,79 @@
+# 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, StrictStr, ConfigDict
+
+class ComputeOnServer200Response(BaseModel):
+    """
+    ComputeOnServer200Response
+    """
+    message: Optional[StrictStr] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["message"]
+
+    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) -> ComputeOnServer200Response:
+        """Create an instance of ComputeOnServer200Response 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={
+                            "additional_properties"
+                          },
+                          exclude_none=True)
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ComputeOnServer200Response:
+        """Create an instance of ComputeOnServer200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ComputeOnServer200Response.model_validate(obj)
+
+        _obj = ComputeOnServer200Response.model_validate({
+            "message": obj.get("message")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/compute_on_server_request.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, StrictStr, ConfigDict
+
+class ComputeOnServerRequest(BaseModel):
+    """
+    ComputeOnServerRequest
+    """
+    track_id: StrictStr = Field(...)
+    __properties = ["track_id"]
+
+    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) -> ComputeOnServerRequest:
+        """Create an instance of ComputeOnServerRequest 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) -> ComputeOnServerRequest:
+        """Create an instance of ComputeOnServerRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ComputeOnServerRequest.model_validate(obj)
+
+        _obj = ComputeOnServerRequest.model_validate({
+            "track_id": obj.get("track_id")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,69 @@
+# 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 ComputeTextSearchRequest(BaseModel):
+    """
+    ComputeTextSearchRequest
+    """
+    query: StrictStr = Field(...)
+    n_results: Optional[StrictInt] = 10
+    __properties = ["query", "n_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) -> ComputeTextSearchRequest:
+        """Create an instance of ComputeTextSearchRequest 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) -> ComputeTextSearchRequest:
+        """Create an instance of ComputeTextSearchRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ComputeTextSearchRequest.model_validate(obj)
+
+        _obj = ComputeTextSearchRequest.model_validate({
+            "query": obj.get("query"),
+            "n_results": obj.get("n_results") if obj.get("n_results") is not None else 10
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/config_request.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 Any, Dict, Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+class ConfigRequest(BaseModel):
+    """
+    ConfigRequest
+    """
+    media_server: Dict[str, Any] = Field(...)
+    plex: Dict[str, Any] = Field(...)
+    api: Dict[str, Any] = Field(...)
+    chroma: Dict[str, Any] = Field(...)
+    clap: Dict[str, Any] = Field(...)
+    server: Dict[str, Any] = Field(...)
+    logging: Dict[str, Any] = Field(...)
+    database: Optional[Dict[str, Any]] = None
+    __properties = ["media_server", "plex", "api", "chroma", "clap", "server", "logging", "database"]
+
+    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) -> ConfigRequest:
+        """Create an instance of ConfigRequest 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) -> ConfigRequest:
+        """Create an instance of ConfigRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ConfigRequest.model_validate(obj)
+
+        _obj = ConfigRequest.model_validate({
+            "media_server": obj.get("media_server"),
+            "plex": obj.get("plex"),
+            "api": obj.get("api"),
+            "chroma": obj.get("chroma"),
+            "clap": obj.get("clap"),
+            "server": obj.get("server"),
+            "logging": obj.get("logging"),
+            "database": obj.get("database")
+        })
+        return _obj
+
+

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

@@ -0,0 +1,107 @@
+# 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, ConfigDict
+from mycelium.api.generated_sources.server_schemas.models.api_section import APISection
+from mycelium.api.generated_sources.server_schemas.models.chroma_section import ChromaSection
+from mycelium.api.generated_sources.server_schemas.models.clap_section import ClapSection
+from mycelium.api.generated_sources.server_schemas.models.logging_section import LoggingSection
+from mycelium.api.generated_sources.server_schemas.models.media_server_section import MediaServerSection
+from mycelium.api.generated_sources.server_schemas.models.plex_section import PlexSection
+from mycelium.api.generated_sources.server_schemas.models.server_section import ServerSection
+
+class ConfigResponse(BaseModel):
+    """
+    ConfigResponse
+    """
+    media_server: MediaServerSection = Field(...)
+    plex: PlexSection = Field(...)
+    server: ServerSection = Field(...)
+    api: APISection = Field(...)
+    chroma: ChromaSection = Field(...)
+    clap: ClapSection = Field(...)
+    logging: LoggingSection = Field(...)
+    __properties = ["media_server", "plex", "server", "api", "chroma", "clap", "logging"]
+
+    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) -> ConfigResponse:
+        """Create an instance of ConfigResponse 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 media_server
+        if self.media_server:
+            _dict['media_server'] = self.media_server.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of plex
+        if self.plex:
+            _dict['plex'] = self.plex.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of server
+        if self.server:
+            _dict['server'] = self.server.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of api
+        if self.api:
+            _dict['api'] = self.api.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of chroma
+        if self.chroma:
+            _dict['chroma'] = self.chroma.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of clap
+        if self.clap:
+            _dict['clap'] = self.clap.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of logging
+        if self.logging:
+            _dict['logging'] = self.logging.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ConfigResponse:
+        """Create an instance of ConfigResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ConfigResponse.model_validate(obj)
+
+        _obj = ConfigResponse.model_validate({
+            "media_server": MediaServerSection.from_dict(obj.get("media_server")) if obj.get("media_server") is not None else None,
+            "plex": PlexSection.from_dict(obj.get("plex")) if obj.get("plex") is not None else None,
+            "server": ServerSection.from_dict(obj.get("server")) if obj.get("server") is not None else None,
+            "api": APISection.from_dict(obj.get("api")) if obj.get("api") is not None else None,
+            "chroma": ChromaSection.from_dict(obj.get("chroma")) if obj.get("chroma") is not None else None,
+            "clap": ClapSection.from_dict(obj.get("clap")) if obj.get("clap") is not None else None,
+            "logging": LoggingSection.from_dict(obj.get("logging")) if obj.get("logging") is not None else None
+        })
+        return _obj
+
+

mycelium/api/generated_sources/server_schemas/models/create_playlist_request.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 List, Optional
+from pydantic import BaseModel, Field, StrictInt, StrictStr, conlist, ConfigDict
+
+class CreatePlaylistRequest(BaseModel):
+    """
+    CreatePlaylistRequest
+    """
+    name: StrictStr = Field(...)
+    track_ids: conlist(StrictStr) = Field(...)
+    batch_size: Optional[StrictInt] = 100
+    __properties = ["name", "track_ids", "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) -> CreatePlaylistRequest:
+        """Create an instance of CreatePlaylistRequest 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) -> CreatePlaylistRequest:
+        """Create an instance of CreatePlaylistRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return CreatePlaylistRequest.model_validate(obj)
+
+        _obj = CreatePlaylistRequest.model_validate({
+            "name": obj.get("name"),
+            "track_ids": obj.get("track_ids"),
+            "batch_size": obj.get("batch_size") if obj.get("batch_size") is not None else 100
+        })
+        return _obj
+
+