api/endpoints/constructors.py

from typing import Optional
from pydantic import BaseModel

"""
Karma
"""

class ValidKarmaUpdateRequest(BaseModel):
    """
    Requires authentication
    - **granter**: who updated the karma
    - **keyword**: keyword to update karma for
    - **flag**: either 0 (decrement) for --, or 1 (increment) for ++
    """

    granter: str
    keyword: str
    flag: int


class ValidKarmaRetrievalRequest(BaseModel):
    """
    - **keyword**: keyword to retrieve karma value of
    """

    keyword: str

class ValidTopKarmaRequest(BaseModel):
    """
    - **n**: Number of top results to return (default: 10)
    """
    n: Optional[int] = 10

"""
LastFM
"""

class LastFMException(Exception):
    pass

class ValidArtistSearchRequest(BaseModel):
    """
    - **a**: artist name
    """

    a: str
    
    model_config = {
    "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                }]
        }
    }
    
class ValidAlbumDetailRequest(BaseModel):
    """
    - **a**: artist name
    - **release**: album/release name (as sourced from here/LastFM)
    """

    a: str
    release: str

    model_config = {
    "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                    "release": "houdini",
                }]
        }
    }
                
class ValidTrackInfoRequest(BaseModel):
    """
    - **a**: artist name
    - **t**: track
    """

    a: str
    t: str
    
    model_config = {
    "json_schema_extra": {
            "examples": [
                {
                    "a": "eminem",
                    "t": "rap god",
                }]
        }
    }    
    
"""
Rand Msg
"""

class RandMsgRequest(BaseModel):
    """
    - **short**: Short randmsg?
    """

    short: Optional[bool] = False

"""
YT
"""

class ValidYTSearchRequest(BaseModel):
    """
    - **t**: title to search
    """

    t: str = "rick astley - never gonna give you up"

"""
XC
"""

class ValidXCRequest(BaseModel):
    """
    - **key**: valid XC API key
    - **bid**: bot id
    - **cmd**: bot command
    - **data**: command data
    """

    key: str
    bid: int
    cmd: str
    data: Optional[dict] 

"""
Transcriptions
"""

class ValidShowEpisodeListRequest(BaseModel):
    """
    - **s**: show id
    """

    s: int

class ValidShowEpisodeLineRequest(BaseModel):
    """
    - **s**: show id
    - **e**: episode id
    """

    s: int
    e: int

"""
Lyric Search
"""

class ValidLyricRequest(BaseModel):
    """
    - **a**: artist
    - **s**: song
    - **t**: track (artist and song combined) [used only if a & s are not used]
    - **extra**: include extra details in response [optional, default: false]
    - **lrc**: Request LRCs?
    - **sub**: text to search within lyrics, if found lyrics will begin at found verse [optional]
    - **src**: the script/utility which initiated the request
    - **excluded_sources**: sources to exclude (new only)
    """

    a: Optional[str] = None 
    s: Optional[str] = None
    t: Optional[str] = None
    sub: Optional[str] = None
    extra: Optional[bool] = False
    lrc: Optional[bool] = False
    src: str
    excluded_sources: Optional[list] = None

    model_config = {
        "json_schema_extra": {
                "examples": [
                    {
                        "a": "eminem",
                        "s": "rap god",
                        "src": "WEB",
                        "extra": True,
                        "lrc": False,
                        "excluded_sources": [],
                    }]
            }
        }

        
class ValidTypeAheadRequest(BaseModel):
    """
    - **query**: query string
    """
    pre_query: Optional[str] = None
    query: str

"""
Radio
"""

class RadioException(Exception):
    pass

class ValidRadioSongRequest(BaseModel):
    """
    - **key**: API Key
    - **artist**: artist to search
    - **song**: song to search
    - **artistsong**: may be used IN PLACE OF artist/song to perform a combined/string search in the format "artist - song"
    - **alsoSkip**: Whether to skip immediately to this track [not implemented]
    """
    key: str
    artist: Optional[str] = None
    song: Optional[str] = None
    artistsong: Optional[str] = None
    alsoSkip: Optional[bool] = False
    
class ValidRadioTypeaheadRequest(BaseModel):
    """
    - **query**: Typeahead query
    """
    query: str
        
    
class ValidRadioQueueGetRequest(BaseModel):
    """
    - **key**: API key (optional, needed if specifying a non-default limit)
    - **limit**: optional, default: 15k
    """
    
    key: Optional[str] = None
    limit: Optional[int] = 15_000
    
class ValidRadioNextRequest(BaseModel):
    """
    - **key**: API Key
    - **skipTo**: UUID to skip to [optional]
    """
    key: str
    skipTo: Optional[str] = None
    
class ValidRadioReshuffleRequest(ValidRadioNextRequest):
    """
    - **key**: API Key
    """
    
class ValidRadioQueueShiftRequest(BaseModel):
    """
    - **key**: API Key
    - **uuid**: UUID to shift 
    - **next**: Play next if true, immediately if false, default False
    """
    key: str
    uuid: str
    next: Optional[bool] = False
    
class ValidRadioQueueRemovalRequest(BaseModel):
    """
    - **key**: API Key
    - **uuid**: UUID to remove 
    """
    key: str
    uuid: str