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 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)
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
