searx.engines.radio_browser Namespace Reference

Functions
	init (_)
list[str]	server_list ()
	request (query, params)
	response (resp)
	fetch_traits (EngineTraits engine_traits)

Variables
	logger = logging.getLogger()
dict	about
bool	paging = True
list	categories = ['music', 'radio']
int	number_of_results = 10
list	station_filters = []

Detailed Description

Search radio stations from RadioBrowser by `Advanced station search API`_.

.. _Advanced station search API:
   https://de1.api.radio-browser.info/#Advanced_station_search

Function Documentation

fetch_traits()

searx.engines.radio_browser.fetch_traits

(

EngineTraits

engine_traits

)

Fetch languages and countrycodes from RadioBrowser

- ``traits.languages``: `list of languages API`_
- ``traits.custom['countrycodes']``: `list of countries API`_

.. _list of countries API: https://de1.api.radio-browser.info/#List_of_countries
.. _list of languages API: https://de1.api.radio-browser.info/#List_of_languages

Definition at line 175 of file radio_browser.py.

def fetch_traits(engine_traits: EngineTraits):
    """Fetch languages and countrycodes from RadioBrowser
 
    - ``traits.languages``: `list of languages API`_
    - ``traits.custom['countrycodes']``: `list of countries API`_
 
    .. _list of countries API: https://de1.api.radio-browser.info/#List_of_countries
    .. _list of languages API: https://de1.api.radio-browser.info/#List_of_languages
    """
    # pylint: disable=import-outside-toplevel
 
    init(None)
    from babel.core import get_global
 
    babel_reg_list = get_global("territory_languages").keys()
 
    server = server_list()[0]
    language_list = get(f'{server}/json/languages').json()  # type: ignore
    country_list = get(f'{server}/json/countries').json()  # type: ignore
 
    for lang in language_list:
 
        babel_lang = lang.get('iso_639')
        if not babel_lang:
            # the language doesn't have any iso code, and hence can't be parsed
            # print(f"ERROR: lang - no iso code in {lang}")
            continue
        try:
            sxng_tag = language_tag(babel.Locale.parse(babel_lang, sep="-"))
        except babel.UnknownLocaleError:
            # print(f"ERROR: language tag {babel_lang} is unknown by babel")
            continue
 
        eng_tag = lang['name']
        conflict = engine_traits.languages.get(sxng_tag)
        if conflict:
            if conflict != eng_tag:
                print("CONFLICT: babel %s --> %s, %s" % (sxng_tag, conflict, eng_tag))
            continue
        engine_traits.languages[sxng_tag] = eng_tag
 
    countrycodes = set()
    for region in country_list:
        # country_list contains duplicates that differ only in upper/lower case
        _reg = region['iso_3166_1'].upper()
        if _reg not in babel_reg_list:
            print(f"ERROR: region tag {region['iso_3166_1']} is unknown by babel")
            continue
        countrycodes.add(_reg)
 
    countrycodes = list(countrycodes)
    countrycodes.sort()
    engine_traits.custom['countrycodes'] = countrycodes

References init(), and server_list().

Here is the call graph for this function:

init()

searx.engines.radio_browser.init

(

_

)

Definition at line 68 of file radio_browser.py.

def init(_):
    global CACHE  # pylint: disable=global-statement
    CACHE = EngineCache("radio_browser")
    server_list()
 
 

References server_list().

Referenced by fetch_traits().

Here is the call graph for this function:

Here is the caller graph for this function:

request()

searx.engines.radio_browser.request	(		query,
			params )

Definition at line 95 of file radio_browser.py.

def request(query, params):
 
    servers = server_list()
    if not servers:
        logger.error("Fetched server list is empty!")
        params["url"] = None
        return
 
    server = random.choice(servers)
 
    args = {
        'name': query,
        'order': 'votes',
        'offset': (params['pageno'] - 1) * number_of_results,
        'limit': number_of_results,
        'hidebroken': 'true',
        'reverse': 'true',
    }
 
    if 'language' in station_filters:
        lang = traits.get_language(params['searxng_locale'])  # type: ignore
        if lang:
            args['language'] = lang
 
    if 'countrycode' in station_filters:
        if len(params['searxng_locale'].split('-')) > 1:
            countrycode = params['searxng_locale'].split('-')[-1].upper()
            if countrycode in traits.custom['countrycodes']:  # type: ignore
                args['countrycode'] = countrycode
 
    params['url'] = f"{server}/json/stations/search?{urlencode(args)}"
 
 

References server_list().

Here is the call graph for this function:

response()

searx.engines.radio_browser.response

(

resp

)

Definition at line 128 of file radio_browser.py.

def response(resp):
    results = []
 
    json_resp = resp.json()
 
    for result in json_resp:
        url = result['homepage']
        if not url:
            url = result['url_resolved']
 
        content = []
        tags = ', '.join(result.get('tags', '').split(','))
        if tags:
            content.append(tags)
        for x in ['state', 'country']:
            v = result.get(x)
            if v:
                v = str(v).strip()
                content.append(v)
 
        metadata = []
        codec = result.get('codec')
        if codec and codec.lower() != 'unknown':
            metadata.append(f'{codec} ' + gettext('radio'))
        for x, y in [
            (gettext('bitrate'), 'bitrate'),
            (gettext('votes'), 'votes'),
            (gettext('clicks'), 'clickcount'),
        ]:
            v = result.get(y)
            if v:
                v = str(v).strip()
                metadata.append(f"{x} {v}")
        results.append(
            {
                'url': url,
                'title': result['name'],
                'thumbnail': result.get('favicon', '').replace("http://", "https://"),
                'content': ' | '.join(content),
                'metadata': ' | '.join(metadata),
                'iframe_src': result['url_resolved'].replace("http://", "https://"),
            }
        )
 
    return results
 
 

server_list()

list[str] searx.engines.radio_browser.server_list

(

)

Definition at line 74 of file radio_browser.py.

def server_list() -> list[str]:
 
    servers = CACHE.get("servers", [])
    if servers:
        return servers
 
    # hint: can take up to 40sec!
    ips = socket.getaddrinfo("all.api.radio-browser.info", 80, 0, 0, socket.IPPROTO_TCP)
    for ip_tuple in ips:
        _ip: str = ip_tuple[4][0]  # type: ignore
        url = socket.gethostbyaddr(_ip)[0]
        srv = "https://" + url
        if srv not in servers:
            servers.append(srv)
 
    # update server list once in 24h
    CACHE.set(key="servers", value=servers, expire=60 * 60 * 24)
 
    return servers
 
 

Referenced by fetch_traits(), init(), and request().

Here is the caller graph for this function:

Variable Documentation

about

dict searx.engines.radio_browser.about

Initial value:

=  {
    "website": 'https://www.radio-browser.info/',
    "wikidata_id": 'Q111664849',
    "official_api_documentation": 'https://de1.api.radio-browser.info/',
    "use_official_api": True,
    "require_api_key": False,
    "results": 'JSON',
}

Definition at line 29 of file radio_browser.py.

categories

list searx.engines.radio_browser.categories = ['music', 'radio']

Definition at line 38 of file radio_browser.py.

logger

searx.engines.radio_browser.logger = logging.getLogger()

Definition at line 25 of file radio_browser.py.

number_of_results

int searx.engines.radio_browser.number_of_results = 10

Definition at line 40 of file radio_browser.py.

paging

bool searx.engines.radio_browser.paging = True

Definition at line 37 of file radio_browser.py.

station_filters

list searx.engines.radio_browser.station_filters = []

Definition at line 42 of file radio_browser.py.