def __init__(self, username=None): self.auth = False self.keyring_failed = False self.username = username musicbrainzngs.set_hostname(options.server) musicbrainzngs.set_useragent(AGENT_NAME, __version__, "http://github.com/JonnyJD/musicbrainz-isrcsubmit")
def __init__(self): log = logging.getLogger('util.importer.Importer.__init__') musicbrainzngs.set_useragent("NRG Processor", "0.01", "http://anorg.net/") musicbrainzngs.set_rate_limit(MUSICBRAINZ_RATE_LIMIT) if MUSICBRAINZ_HOST: musicbrainzngs.set_hostname(MUSICBRAINZ_HOST)
def configure(): """Set up the python-musicbrainz-ngs module according to settings from the beets configuration. This should be called at startup. """ musicbrainzngs.set_hostname(config["musicbrainz"]["host"].get(unicode)) musicbrainzngs.set_rate_limit( config["musicbrainz"]["ratelimit_interval"].as_number(), config["musicbrainz"]["ratelimit"].get(int) )
def __init__(self): musicbrainzngs.set_useragent("NRG Processor", "0.01", "http://anorg.net/") musicbrainzngs.set_rate_limit(MUSICBRAINZ_RATE_LIMIT) self.file_metadata = None if MUSICBRAINZ_HOST: musicbrainzngs.set_hostname(MUSICBRAINZ_HOST)
def __init__(self): musicbrainzngs.set_useragent("NRG Processor", "0.01", "http://anorg.net/") musicbrainzngs.set_rate_limit(MUSICBRAINZ_RATE_LIMIT) self.pp = pprint.PrettyPrinter(indent=4) self.pp.pprint = lambda d: None if MUSICBRAINZ_HOST: musicbrainzngs.set_hostname(MUSICBRAINZ_HOST)
def configure(): """Set up the python-musicbrainz-ngs module according to settings from the beets configuration. This should be called at startup. """ hostname = config['musicbrainz']['host'].as_str() musicbrainzngs.set_hostname(hostname) musicbrainzngs.set_rate_limit( config['musicbrainz']['ratelimit_interval'].as_number(), config['musicbrainz']['ratelimit'].get(int), )
def main(): server = config.Config().get_musicbrainz_server() musicbrainzngs.set_hostname(server) # Find whipper's plugins paths (local paths have higher priority) plugins_p = [directory.data_path('plugins')] # local path (in $HOME) if hasattr(sys, 'real_prefix'): # no getsitepackages() in virtualenv plugins_p.append( get_python_lib(plat_specific=False, standard_lib=False, prefix='/usr/local') + '/whipper/plugins') plugins_p.append(get_python_lib(plat_specific=False, standard_lib=False) + '/whipper/plugins') else: plugins_p += [x + '/whipper/plugins' for x in site.getsitepackages()] # register plugins with pkg_resources distributions, _ = pkg_resources.working_set.find_plugins( pkg_resources.Environment(plugins_p) ) list(map(pkg_resources.working_set.add, distributions)) try: cmd = Whipper(sys.argv[1:], os.path.basename(sys.argv[0]), None) ret = cmd.do() except SystemError as e: logger.critical("SystemError: %s", e) if (isinstance(e, common.EjectError) and cmd.options.eject in ('failure', 'always')): eject_device(e.device) return 255 except RuntimeError as e: print(e) return 1 except KeyboardInterrupt: return 2 except ImportError as e: raise except task.TaskException as e: if isinstance(e.exception, ImportError): raise ImportError(e.exception) elif isinstance(e.exception, common.MissingDependencyException): logger.critical('missing dependency "%s"', e.exception.dependency) return 255 if isinstance(e.exception, common.EmptyError): logger.debug("EmptyError: %s", e.exception) logger.critical('could not create encoded file') return 255 # in python3 we can instead do `raise e.exception` as that would show # the exception's original context logger.critical(e.exceptionMessage) return 255 return ret if ret else 0
def __init__(self, option_config_json): # If you plan to submit data, authenticate # musicbrainzngs.auth(option_config_json.get('MediaBrainz','User').strip(), # option_config_json.get('MediaBrainz','Password').strip()) musicbrainzngs.set_useragent("MediaKraken_Server", common_version.APP_VERSION, "[email protected] " "https://https://github.com/MediaKraken/MediaKraken_Deployment") # If you are connecting to a development server if option_config_json['MusicBrainz']['Host'] is not None: if option_config_json['MusicBrainz']['Host'] != 'Docker': musicbrainzngs.set_hostname(option_config_json['MusicBrainz']['Host'] + ':' + option_config_json['MusicBrainz']['Port']) else: musicbrainzngs.set_hostname('mkmusicbrainz:5000')
def startmb(): mbuser = None mbpass = None if headphones.CONFIG.MIRROR == "musicbrainz.org": mbhost = "musicbrainz.org" mbport = 80 sleepytime = 1 elif headphones.CONFIG.MIRROR == "custom": mbhost = headphones.CONFIG.CUSTOMHOST mbport = int(headphones.CONFIG.CUSTOMPORT) mbuser = headphones.CONFIG.CUSTOMUSER mbpass = headphones.CONFIG.CUSTOMPASS sleepytime = int(headphones.CONFIG.CUSTOMSLEEP) elif headphones.CONFIG.MIRROR == "headphones": mbhost = "musicbrainz.codeshy.com" mbport = 80 mbuser = headphones.CONFIG.HPUSER mbpass = headphones.CONFIG.HPPASS sleepytime = 0 else: return False musicbrainzngs.set_useragent("headphones", "0.0", "https://github.com/rembo10/headphones") musicbrainzngs.set_hostname(mbhost + ":" + str(mbport)) # Their rate limiting should be redundant to our lock if sleepytime == 0: musicbrainzngs.set_rate_limit(False) else: # calling it with an it ends up blocking all requests after the first musicbrainzngs.set_rate_limit(limit_or_interval=float(sleepytime)) mb_lock.minimum_delta = sleepytime # Add headphones credentials if headphones.CONFIG.MIRROR == "headphones" or headphones.CONFIG.CUSTOMAUTH: if not mbuser or not mbpass: logger.warn("No username or password set for MusicBrainz server") else: musicbrainzngs.hpauth(mbuser, mbpass) # Let us know if we disable custom authentication if not headphones.CONFIG.CUSTOMAUTH and headphones.CONFIG.MIRROR == "custom": musicbrainzngs.disable_hpauth() logger.debug( "Using the following server values: MBHost: %s, MBPort: %i, Sleep Interval: %i", mbhost, mbport, sleepytime ) return True
def __init__(self): log = logging.getLogger('util.importer.__init__') musicbrainzngs.set_useragent("NRG Processor", "0.01", "http://anorg.net/") musicbrainzngs.set_rate_limit(MUSICBRAINZ_RATE_LIMIT) if MUSICBRAINZ_HOST: musicbrainzngs.set_hostname(MUSICBRAINZ_HOST) self.pp = pprint.PrettyPrinter(indent=4) self.pp.pprint = lambda d: None self.mb_completed = []
def __init__(self, simplecache=None): '''Initialize - optionaly provide simplecache object''' if not simplecache: from simplecache import SimpleCache self.cache = SimpleCache() else: self.cache = simplecache import musicbrainzngs as mbrainz mbrainz.set_useragent( "script.skin.helper.service", "1.0.0", "https://github.com/marcelveldt/script.skin.helper.service") mbrainz.set_rate_limit(limit_or_interval=2.0, new_requests=1) addon = xbmcaddon.Addon(ADDON_ID) if addon.getSetting("music_art_mb_mirror"): mbrainz.set_hostname(addon.getSetting("music_art_mb_mirror")) del addon self.mbrainz = mbrainz
def startmb(): mbuser = None mbpass = None if headphones.MIRROR == "musicbrainz.org": mbhost = "musicbrainz.org" mbport = 80 sleepytime = 1 elif headphones.MIRROR == "custom": mbhost = headphones.CUSTOMHOST mbport = int(headphones.CUSTOMPORT) sleepytime = int(headphones.CUSTOMSLEEP) elif headphones.MIRROR == "headphones": mbhost = "144.76.94.239" mbport = 8181 mbuser = headphones.HPUSER mbpass = headphones.HPPASS sleepytime = 0 else: return False musicbrainzngs.set_useragent("headphones","0.0","https://github.com/rembo10/headphones") musicbrainzngs.set_hostname(mbhost + ":" + str(mbport)) if sleepytime == 0: musicbrainzngs.set_rate_limit(False) else: #calling it with an it ends up blocking all requests after the first musicbrainzngs.set_rate_limit(limit_or_interval=float(sleepytime)) # Add headphones credentials if headphones.MIRROR == "headphones": if not mbuser and mbpass: logger.warn("No username or password set for VIP server") else: musicbrainzngs.hpauth(mbuser,mbpass) logger.debug('Using the following server values: MBHost: %s, MBPort: %i, Sleep Interval: %i', mbhost, mbport, sleepytime) return True
def main(*argv): m.set_useragent("applicatiason", "0.201", "http://recabal.com") m.set_hostname("localhost:8080") m.auth("vm", "musicbrainz") f = open(sys.argv[1],'r') for line in f.xreadlines(): line = line.strip(); lifeSpanString = "false,false" art_dict = m.search_artists(artist=line,limit=1,strict=True,tag="jazz") if art_dict['artist-count']!=0: lifeSpanString = getLifeSpan(art_dict) else: art_dict = m.search_artists(artist=line,limit=1,strict=True) if art_dict['artist-count']!=0: lifeSpanString = getLifeSpan(art_dict) print line+","+lifeSpanString f.close()
def status_view(request): bar = 25 output = '' hostname = '192.168.54.101:5000' musicbrainzngs.set_hostname(hostname) musicbrainzngs.auth("user", "password") musicbrainzngs.set_useragent( 'c3sbrainz', '0.1a', '*****@*****.**' ) artistid = "952a4205-023d-4235-897c-6fdb6f58dfaa" #import pdb #pdb.set_trace() print(dir(musicbrainzngs)) #output = dir(musicbrainzngs) output = musicbrainzngs.get_artist_by_id(artistid) print musicbrainzngs.get_artist_by_id(artistid) return { 'foo': 'foo', 'bar': bar, 'hostname': hostname, 'output': output }
def init(app_name, app_version, hostname=None): # We need to identify our application to access the MusicBrainz webservice. # See https://python-musicbrainzngs.readthedocs.org/en/latest/usage/#identification for more info. musicbrainzngs.set_useragent(app_name, app_version) if hostname: musicbrainzngs.set_hostname(hostname)
import shutil import random import functools32 import json import string import Levenshtein import re import compmusic.file import compmusic.musicbrainz import musicbrainzngs as mb mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(False) mb.set_hostname("sitar.s.upf.edu:8090") class MakamScore(object): mapping = collections.defaultdict(list) targetdir = "results" def __init__(self, scores, pdfs, midis, audio): self.scores = scores self.pdfs = pdfs self.midis = midis self.audio = audio if self.audio: self.map_files_to_recording(self.audio) def map_files_to_recording(self, source_dir):
def create_app(debug=None): app = CustomFlask( import_name=__name__, use_flask_uuid=True, ) # Configuration load_config(app) if debug is not None: app.debug = debug if app.debug and app.config['SECRET_KEY']: app.init_debug_toolbar() # Logging app.init_loggers(file_config=app.config.get('LOG_FILE'), email_config=app.config.get('LOG_EMAIL'), sentry_config=app.config.get('LOG_SENTRY') ) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Cache if 'REDIS_HOST' in app.config and\ 'REDIS_PORT' in app.config and\ 'REDIS_NAMESPACE' in app.config and\ 'REDIS_NS_VERSIONS_LOCATION' in app.config: if not os.path.exists(app.config['REDIS_NS_VERSIONS_LOCATION']): os.makedirs(app.config['REDIS_NS_VERSIONS_LOCATION']) from brainzutils import cache cache.init( host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], namespace=app.config['REDIS_NAMESPACE'], ns_versions_loc=app.config['REDIS_NS_VERSIONS_LOCATION']) else: raise Exception('One or more redis cache configuration options are missing from config.py') # Extensions from flask_uuid import FlaskUUID FlaskUUID(app) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # Static files import static_manager static_manager.read_manifest() # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime app.context_processor(lambda: dict(get_static_path=static_manager.get_static_path)) _register_blueprints(app) # Admin section from flask_admin import Admin from webserver.admin import views as admin_views admin = Admin(app, index_view=admin_views.HomeView(name='Admin')) admin.add_view(admin_views.AdminsView(name='Admins')) @ app.before_request def before_request_gdpr_check(): # skip certain pages, static content and the API if request.path == url_for('index.gdpr_notice') \ or request.path == url_for('login.logout') \ or request.path.startswith('/_debug') \ or request.path.startswith('/static') \ or request.path.startswith(API_PREFIX): return # otherwise if user is logged in and hasn't agreed to gdpr, # redirect them to agree to terms page. elif current_user.is_authenticated and current_user.gdpr_agreed is None: return redirect(url_for('index.gdpr_notice', next=request.full_path)) return app
with open('./.client_secret.json', 'r') as f: jsondata = json.loads( f.read() ) user_name = jsondata['user_name'] user_pass = jsondata['user_pass'] app_name = jsondata['app_name'] app_version = jsondata['app_version'] app_url = jsondata['app_url'] host_url = jsondata['host_url'] # Login mb.auth(user_name, user_pass) # Set up an app mb.set_useragent(app_name, app_version, app_url) # Sign a host engine to search from mb.set_hostname(host_url) #==================================================================== #>>>>>>>>>>>>>>>>>>>>>>>[ SEARCH API ]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #==================================================================== # Search artist artists = mb.search_artists(artist="bigbang", type="group", country="NO") for a in artists['artist-list']: if 'country' in a.keys(): print( a['name'],'\t',a['country'] )
import pprint __author__ = "Paul Harrison'" __title__ = "Music Brainz utilities" __description__ = "Various utilities using the musicbrainzngs python bindings to access the MB database" __version__ = "0.2" debug = False musicbrainzngs.set_useragent( "MythTV", "32.0", "https://www.mythtv.org", ) musicbrainzngs.set_hostname("musicbrainz.org") def log(debug, txt): if debug: print(txt) def convert_etree(etostr): """lxml.etree.tostring is a bytes object in python3, and a str in python2. """ return (etostr.decode()) def search_releases(artist, album, limit): from lxml import etree
$ ./recordingSearch.py "the beatles" revolver Revolver, by The Beatles Released 1966-08-08 (Official) MusicBrainz ID: b4b04cbf-118a-3944-9545-38a0a88ff1a2 """ import musicbrainzngs import sys import difflib musicbrainzngs.set_useragent( "python-musicbrainzngs-example", "0.1", "https://github.com/alastair/python-musicbrainzngs/", ) musicbrainzngs.set_hostname("localhost:5000") def similar(seq1, seq2): return difflib.SequenceMatcher(a=seq1.lower(), b=seq2.lower()).ratio() def fetch_recording(artist, title, **kwarg): """fetch recording from musicBrainz """ result = musicbrainzngs.search_recordings(query='', limit=10, offset=None, strict=False, artist = artist, release = title) seq2 =' '.join([title, artist]) high_score = 0 idx = 0 for i in range(0,10): seq1 = ' '.join([result['recording-list'][i]['title'], result['recording-list'][i]['artist-credit-phrase']]) similarity_score = similar(seq1,seq2) if similarity_score > high_score and 'instrumental' not in seq1 and (not 'disambiguation' in result['recording-list'][i] or \
# # This program is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A # PARTICULAR PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along with # this program. If not, see http://www.gnu.org/licenses/ from log import log import urllib2 import xml.etree.ElementTree as etree import musicbrainzngs as mb mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(False) mb.set_hostname("musicbrainz.s.upf.edu") MUSICBRAINZ_COLLECTION_CARNATIC = "" MUSICBRAINZ_COLLECTION_HINDUSTANI = "" MUSICBRAINZ_COLLECTION_MAKAM = "" def ws_ids(xml): ids = [] tree = etree.fromstring(xml) count = int(list(list(tree)[0])[2].attrib["count"]) for rel in list(list(list(tree)[0])[2]): ids.append(rel.attrib["id"]) return (count, ids) def get_releases_in_collection(collection):
def create_app(debug=None, config_path=None): app = CustomFlask(import_name=__name__, use_flask_uuid=True, use_debug_toolbar=True) # Configuration root_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..") app.config.from_pyfile(os.path.join(root_path, 'default_config.py')) app.config.from_pyfile(os.path.join(root_path, 'custom_config.py'), silent=True) if config_path: app.config.from_pyfile(config_path) if debug is not None: app.debug = debug # Logging from webserver.loggers import init_loggers init_loggers(app) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Memcached if 'MEMCACHED_SERVERS' in app.config: from db import cache cache.init(app.config['MEMCACHED_SERVERS'], app.config['MEMCACHED_NAMESPACE'], debug=1 if app.debug else 0) # Extensions from flask_uuid import FlaskUUID FlaskUUID(app) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # Static files import static_manager static_manager.read_manifest() # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime app.context_processor( lambda: dict(get_static_path=static_manager.get_static_path)) _register_blueprints(app) # Admin section from flask_admin import Admin from webserver.admin import views as admin_views admin = Admin(app, index_view=admin_views.HomeView(name='Admin')) admin.add_view(admin_views.AdminsView(name='Admins')) return app
def tearDown(self): musicbrainz.set_rate_limit(True) musicbrainzngs.set_hostname("musicbrainz.org", use_https=True)
def create_app(): app = Flask(__name__) # Configuration sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")) import config app.config.from_object(config) # Logging from webserver.loggers import init_loggers init_loggers(app) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Memcached if 'MEMCACHED_SERVERS' in app.config: from db import cache cache.init(app.config['MEMCACHED_SERVERS'], app.config['MEMCACHED_NAMESPACE'], debug=1 if app.debug else 0) # Extensions from flask_uuid import FlaskUUID FlaskUUID(app) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime # Blueprints from webserver.views.index import index_bp from webserver.views.data import data_bp from webserver.views.api import api_bp from webserver.views.stats import stats_bp from webserver.views.login import login_bp from webserver.views.user import user_bp from webserver.views.datasets import datasets_bp app.register_blueprint(index_bp) app.register_blueprint(data_bp) app.register_blueprint(api_bp) app.register_blueprint(stats_bp) app.register_blueprint(login_bp, url_prefix='/login') app.register_blueprint(user_bp, url_prefix='/user') app.register_blueprint(datasets_bp, url_prefix='/datasets') return app
#!/usr/bin/env python from __future__ import print_function import os import uuid import eyed3 import musicbrainzngs as mb from dashboard import makam_importer from data.models import Collection mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(False) mb.set_hostname("musicbrainz.org") '''Script for uploading audio files on Makam collection and creating Recordings: take turkish-makam collection add new release, use this release when there is no release for the recording for each recording create an Recording and then call add_and_get_recording in release_importer.''' def main(path, fake_release_mbid): releases = {} # Get all the mbid of the recordings onlyfiles = [ f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) ] for i in onlyfiles: head, tail = os.path.split(i)
import musicbrainzngs from functools import wraps import json import redis rconn = redis.StrictRedis(host="localhost") musicbrainzngs.set_hostname("musicbrainz.s.upf.edu") musicbrainzngs.set_rate_limit(False) musicbrainzngs.set_useragent("test", "test") def cache(f): @wraps(f) def inner(*args, **kwargs): # TODO: understand args and kwargs # -- args[0] is mbid key = "%s:%s" % (f.__name__, args[0]) val = rconn.get(key) if not val: ret = f(*args, **kwargs) val = json.dumps(ret) rconn.set(key, val) else: ret = json.loads(val) return ret return inner @cache def get_recording(mbid):
from time import strftime import urllib.request import json import musicbrainzngs musicbrainzngs.auth("bherren", "DataIsDifficult") musicbrainzngs.set_hostname("test.musicbrainz.org") musicbrainzngs.set_useragent("Project to determine artist gender", "0.1", "*****@*****.**") # run musicbrainz api to get gender and type for each artist def assignGenderAndTypeToSongs(filename): with open(filename, encoding="utf-8") as json_file: billboard_chart_data = json.load(json_file) # traverse all songs count = 1 for year in range(1963, 2019): for song in billboard_chart_data[str(year)]: genres_fixed = False song_name = song['song'] artist_name = song['artist(s)'] mbid = song['mbid_artist_id'] try: mb_artist = musicbrainzngs.get_artist_by_id(mbid) # get gender if it exists if ("gender" in mb_artist["artist"]): song['artist_gender'] = mb_artist['artist']['gender'] print(artist_name + " is a " + song['artist_gender'])
def create_app(debug=None, config_path=None): app = create_app_with_configuration(config_path) if debug is not None: app.debug = debug if app.debug and app.config['SECRET_KEY']: app.init_debug_toolbar() # Logging from webserver.loggers import init_loggers init_loggers(app) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Cache if 'REDIS_HOST' in app.config and\ 'REDIS_PORT' in app.config and\ 'REDIS_NAMESPACE' in app.config and\ 'REDIS_NS_VERSIONS_LOCATION' in app.config: if not os.path.exists(app.config['REDIS_NS_VERSIONS_LOCATION']): os.makedirs(app.config['REDIS_NS_VERSIONS_LOCATION']) from brainzutils import cache cache.init(host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], namespace=app.config['REDIS_NAMESPACE'], ns_versions_loc=app.config['REDIS_NS_VERSIONS_LOCATION']) else: raise Exception( 'One or more redis cache configuration options are missing from custom_config.py' ) # Extensions from flask_uuid import FlaskUUID FlaskUUID(app) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # Static files import static_manager static_manager.read_manifest() # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime app.context_processor( lambda: dict(get_static_path=static_manager.get_static_path)) _register_blueprints(app) # Admin section from flask_admin import Admin from webserver.admin import views as admin_views admin = Admin(app, index_view=admin_views.HomeView(name='Admin')) admin.add_view(admin_views.AdminsView(name='Admins')) return app
import logging logger = logging.getLogger(__name__) def main(): # set user agent musicbrainzngs.set_useragent("whipper", whipper.__version__, "https://github.com/JoeLametta/whipper") try: server = config.Config().get_musicbrainz_server() except KeyError, e: sys.stderr.write('whipper: %s\n' % e.message) sys.exit() musicbrainzngs.set_hostname(server) # register plugins with pkg_resources distributions, _ = pkg_resources.working_set.find_plugins( pkg_resources.Environment([directory.data_path('plugins')]) ) map(pkg_resources.working_set.add, distributions) try: cmd = Whipper(sys.argv[1:], os.path.basename(sys.argv[0]), None) ret = cmd.do() except SystemError, e: sys.stderr.write('whipper: error: %s\n' % e) if (type(e) is common.EjectError and cmd.options.eject in ('failure', 'always')): eject_device(e.device) return 255 except RuntimeError, e:
def test_set_port(self): musicbrainzngs.set_hostname("localhost:8000", use_https=False) musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual("http://localhost:8000/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
def test_set_https(self): musicbrainzngs.set_hostname("mbmirror.org", use_https=True) musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual("https://mbmirror.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
__author__ = "Paul Harrison'" __title__ = "Music Brainz utilities" __description__ = "Various utilities using the musicbrainzngs python bindings to access the MB database" __version__ = "0.1" debug = False musicbrainzngs.set_useragent( "MythTV", "0.28", "https://www.mythtv.org", ) #musicbrainzngs.set_hostname("musicbrainz.org") #musicbrainzngs.set_hostname("music.peavers.com:5000") musicbrainzngs.set_hostname("musicbrainz-mirror.eu:5000") def log(debug, txt): if debug: print(txt) def search_releases(artist, album, limit): from lxml import etree root = etree.XML(u'<searchreleases></searchreleases>') result = musicbrainzngs.search_releases(artist=artist, release=album, country="GB", limit=limit) if not result['release-list']: etree.SubElement(root, "error").text = "No Releases found" log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True))
if len(list1)==len(list2): return [ list1[x]+list2[x] for x in xrange(list1)] print("Error: cannot add two lists who differ in length") return [] def getConfig(): return getFileContents('config') config = getConfig() mb.set_rate_limit() mb.set_useragent('Zarvox_Automated_DJ','Alpha',"KUPS' [email protected]") mbMultiplier = float(config['musicbrainz_multiplier']) if 'musicbrainz_hostname' in config: mbHostname = config['musicbrainz_hostname'] print("Setting musicbrainz hostname to "+mbHostname) mb.set_hostname(mbHostname) def whatquote(text): return text.replace('+','%2B') def mbquote(text): newText = text for badchar in '()[]^@/~=&"': newText = newText.replace(badchar, ' ') for badchar in '!': newText = newText.strip(badchar) return newText.strip() def bashEscape(s): return s.replace("'","'\"'\"'")
try: conn = psycopg2.connect(config.PG_CONNECT) conn2 = psycopg2.connect(config.PG_CONNECT) except psycopg2.OperationalError as err: print "Cannot connect to database: %s" % err sys.exit(-1) mbdata = "" def callme(data): global mbdata mbdata = data musicbrainzngs.set_useragent(config.USER_AGENT_STRING, config.USER_AGENT_VERSION, config.USER_AGENT_USER) musicbrainzngs.set_format(fmt='json') musicbrainzngs.set_parser(callme) musicbrainzngs.set_hostname("musicbrainz.org") #musicbrainzngs.set_hostname("musicb-1.us.archive.org:5060") #musicbrainzngs.set_rate_limit(False) offset = 0 while True: cur = conn.cursor() cur.execute("""SELECT mbid FROM match WHERE mbid IS NOT NULL AND mb_data IS NULL OFFSET %s LIMIT %s""", (offset, NUM_ROWS)) # if cur.rowcount == 0: # break
# # You should have received a copy of the GNU General Public License along with # this program. If not, see http://www.gnu.org/licenses/ import sys import os import argparse import collections import compmusic.file import compmusic.musicbrainz import musicbrainzngs as mb mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(False) mb.set_hostname("sitar.s.upf.edu:8090") import eyed3 import logging eyed3.utils.log.log.setLevel(logging.ERROR) class Stats(object): # How many recordings are done for each work # key is workid work_recording_counts = collections.Counter() # artists. could be artists of the release, or as release # rels, or as track rels artists = set() # releases
def test_set_http(self): musicbrainzngs.set_hostname("beta.musicbrainz.org") musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual("http://beta.musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
# this code needed if pycompmusic is copied (not installed as dependecy) in parent URI parentDir = os.path.abspath( os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), os.path.pardir, os.path.pardir)) pathPyCompMusic = os.path.join(parentDir, 'pycompmusic') if not pathPyCompMusic in sys.path: sys.path.append(pathPyCompMusic) import compmusic.file from compmusic.dunya.makam import download_mp3 from compmusic.dunya.conn import set_token mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(False) mb.set_hostname("musicbrainz.sb.upf.edu") set_token('0d8cd9be63c10c5dc67f70e1052acec836de29bd') def storeScoreAndAudio(symbTrNameNoExt, recIDs, rootTargetdir): ''' params symbTrNameNoExt ''' symbTrNameNoExt = os.path.basename(symbTrNameNoExt) targetDir = makeDir(symbTrNameNoExt, rootTargetdir) saveScores(symbTrNameNoExt, symbTrDir, targetDir) saveAudio(targetDir, recIDs)
# PARTICULAR PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along with # this program. If not, see http://www.gnu.org/licenses/ import urllib2 import urllib import json import cookielib import re import sys import compmusic import musicbrainzngs as mb mb.set_useragent("Dunya", "0.1") mb.set_rate_limit(True) mb.set_hostname("musicbrainz.org") domain = "https://musicbrainz.org" password = '******' username = '******' login_url = '/login' work_url = '/work/%s/edit' auth_token = "###" symbtrmu2_url = 'http://dunya.compmusic.upf.edu/document/by-id/%s/symbtrmu2' dunya_fuzzy_url = 'http://dunya.compmusic.upf.edu/api/makam/fuzzy' mb_cache = {} def get_symbtrmu2(work_mbid): # Get symbtrmu2 file and extract makam, form and usul
def create_app(): app = Flask(__name__) # Configuration sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "..")) import default_config app.config.from_object(default_config) import config app.config.from_object(config) # Logging from webserver.loggers import init_loggers init_loggers(app) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Memcached if 'MEMCACHED_SERVERS' in app.config: from db import cache cache.init(app.config['MEMCACHED_SERVERS'], app.config['MEMCACHED_NAMESPACE'], debug=1 if app.debug else 0) # Extensions from flask_uuid import FlaskUUID FlaskUUID(app) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # Static files import static_manager static_manager.read_manifest() # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime app.context_processor(lambda: dict(get_static_path=static_manager.get_static_path)) _register_blueprints(app) # Admin section from flask_admin import Admin from webserver.admin import views as admin_views admin = Admin(app, index_view=admin_views.HomeView(name='Admin')) admin.add_view(admin_views.AdminsView(name='Admins')) return app
def create_app(debug=None): app = CustomFlask( import_name=__name__, use_flask_uuid=True, ) # Configuration load_config(app) if debug is not None: app.debug = debug if app.debug and app.config['SECRET_KEY']: app.init_debug_toolbar() # Logging sentry_config = app.config.get('LOG_SENTRY') if sentry_config: sentry.init_sentry(**sentry_config) # Database connection from db import init_db_engine init_db_engine(app.config['SQLALCHEMY_DATABASE_URI']) # Cache if 'REDIS_HOST' in app.config and\ 'REDIS_PORT' in app.config and\ 'REDIS_NAMESPACE' in app.config: from brainzutils import cache cache.init(host=app.config['REDIS_HOST'], port=app.config['REDIS_PORT'], namespace=app.config['REDIS_NAMESPACE']) else: raise Exception( 'One or more redis cache configuration options are missing from config.py' ) # Add rate limiting support @app.after_request def after_request_callbacks(response): return inject_x_rate_headers(response) # check for ratelimit config values and set them if present if 'RATELIMIT_PER_IP' in app.config and 'RATELIMIT_WINDOW' in app.config: set_rate_limits(app.config['RATELIMIT_PER_IP'], app.config['RATELIMIT_PER_IP'], app.config['RATELIMIT_WINDOW']) # MusicBrainz import musicbrainzngs from db import SCHEMA_VERSION musicbrainzngs.set_useragent(app.config['MUSICBRAINZ_USERAGENT'], SCHEMA_VERSION) if app.config['MUSICBRAINZ_HOSTNAME']: musicbrainzngs.set_hostname(app.config['MUSICBRAINZ_HOSTNAME']) # OAuth from webserver.login import login_manager, provider login_manager.init_app(app) provider.init(app.config['MUSICBRAINZ_CLIENT_ID'], app.config['MUSICBRAINZ_CLIENT_SECRET']) # Error handling from webserver.errors import init_error_handlers init_error_handlers(app) # CSRF csrf = CSRFProtect(app) # Static files from . import static_manager # Template utilities app.jinja_env.add_extension('jinja2.ext.do') from webserver import utils app.jinja_env.filters['date'] = utils.reformat_date app.jinja_env.filters['datetime'] = utils.reformat_datetime # During development, built js and css assets don't have a hash, but in production we use # a manifest to map a name to name.hash.extension for caching/cache busting if app.debug: app.context_processor(lambda: dict(get_static_path=static_manager. development_get_static_path)) else: static_manager.read_manifest() app.context_processor(lambda: dict(get_static_path=static_manager. manifest_get_static_path)) _register_blueprints(app) # Admin section from flask_admin import Admin from webserver.admin import views as admin_views admin = Admin(app, index_view=admin_views.HomeView(name='Admin')) admin.add_view(admin_views.AdminsView(name='Admins')) @app.before_request def prod_https_login_redirect(): """ Redirect to HTTPS in production except for the API endpoints """ if six.moves.urllib.parse.urlsplit(request.url).scheme == 'http' \ and app.config['DEBUG'] == False \ and app.config['TESTING'] == False \ and request.blueprint not in ('api', 'api_v1_core', 'api_v1_datasets', 'api_v1_dataset_eval'): url = request.url[7:] # remove http:// from url return redirect('https://{}'.format(url), 301) @app.before_request def before_request_gdpr_check(): # skip certain pages, static content and the API if request.path == url_for('index.gdpr_notice') \ or request.path == url_for('login.logout') \ or request.path.startswith('/_debug') \ or request.path.startswith('/static') \ or request.path.startswith(API_PREFIX): return # otherwise if user is logged in and hasn't agreed to gdpr, # redirect them to agree to terms page. elif current_user.is_authenticated and current_user.gdpr_agreed is None: return redirect( url_for('index.gdpr_notice', next=request.full_path)) return app