def __init__(self, token=None, secret=None): self.token = token self.secret = secret self.url = None # Set unique user-agent user_agent = 'turntabler/0.1' # Instantiate discogs_client obj if token and secret: self.discogsclient = discogs_client.Client( user_agent, token=token, secret=secret, consumer_key=Config.DISCOGS_CONSUMER_KEY, consumer_secret=Config.DISCOGS_CONSUMER_SECRET) else: self.discogsclient = discogs_client.Client( user_agent, consumer_key=Config.DISCOGS_CONSUMER_KEY, consumer_secret=Config.DISCOGS_CONSUMER_SECRET) # Prepare the client with API consumer data # self.discogsclient.set_consumer_key(Config.DISCOGS_CONSUMER_KEY, Config.DISCOGS_CONSUMER_SECRET) # TODO: add callback_url when not using localhost self.user = None
def configure(): config_file = str(Path.home()) + "/.discognition-conf.yaml" if args.generateconfig is not None: # generate configuration data = { 'token': args.generateconfig[0], 'directory': args.generateconfig[1] } with open(config_file, 'w') as outfile: yaml.dump(data, outfile, default_flow_style=False) print('created file: ' + config_file) try: config = yaml.safe_load(open(config_file)) client = discogs_client.Client('discognition/' + __version__, user_token=config['token']) except: print( 'You need to set your configuration file at "~/.discogs_conf.yaml"' ) print( 'You can do this by running "discognition -g TOKEN /PATH/TO/MUSIC/LIBRARY"' ) exit() return { 'config': config, 'client': client, }
def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Discogs sensor.""" import discogs_client token = config[CONF_TOKEN] name = config[CONF_NAME] try: discogs_client = discogs_client.Client(SERVER_SOFTWARE, user_token=token) discogs_data = { 'user': discogs_client.identity().name, 'folders': discogs_client.identity().collection_folders, 'collection_count': discogs_client.identity().num_collection, 'wantlist_count': discogs_client.identity().num_wantlist } except discogs_client.exceptions.HTTPError: _LOGGER.error("API token is not valid") return sensors = [] for sensor_type in config.get(CONF_MONITORED_CONDITIONS): sensors.append(DiscogsSensor(discogs_data, name, sensor_type)) add_entities(sensors, True)
def __init__(self): """ Initializer. Create Discogs Client """ self.peppy_player_user_agent = "PeppyPlayer +https://github.com/project-owner/Peppy" self.peppy_player_token = "RtZmsbvvoXVQxBwXtYDkbNIOXWkeGILJeyriGmDL" self.client = discogs_client.Client(self.peppy_player_user_agent, user_token=self.peppy_player_token)
def setUp(self): """ Setup process. """ client = discogs_client.Client('ExampleApplication/0.1', user_token="wuYMABvmUDdOMXerFacIXQBQJJphFkPgtivGgfLW") self.processor = process.ProcessMap(client, "test_countries.txt")
def get_discogs_client(): user_token = os.environ.get('DISCOGS_USER_TOKEN') if not user_token: msg = 'You must set DISCOGS_USER_TOKEN value in your environment variables' cprint(msg, 'red') return return discogs_client.Client('JazzGraph/0.1', user_token=user_token)
def scrape(query): mbid = query['mbid'] artist = query['artist'] title = query['recording'] if not artist or not title: raise Exception("Artist and recording strings are required") print("Scraping recording information for", mbid, "-", artist, "-", title) title_simple = re.sub(r'\W+', '', title.lower()) data = None try: d = discogs_client.Client('AB_Discogs/0.1', user_token=DISCOGS_KEY) results = d.search(artist=artist, track=title) data = [] #i = 0 for r in results: #i += 1 for t in r.tracklist: track_simple = re.sub(r'\W+', '', t.data['title'].lower()) #print i, track_simple, "-->", title_simple, "MATCH" if title_simple == track_simple else "" if title_simple == track_simple: data.append(r.data) break except ApiException as ex: raise if data: return data, TYPE
def upload_view(request): if not request.user.is_authenticated: return render(request, 'registration/login_error.html') discogs = discogs_client.Client( 'ExampleApplication/0.1', user_token="FLDeuZyRaYLvakXhVNTUgMfTWmBnlabfrBFhGvaM") current_user = request.user if request.method == "POST": song_info = mutagen.File(request.FILES["mysong"]) artist = "".join(song_info["TPE1"].text) results = discogs.search(artist.split("/")[0], type='artist') band_pic = results[0].images[0]["uri"] song = Song.objects.create(title="".join(song_info["TIT2"].text), artist="".join(song_info["TPE1"].text), album="".join(song_info["TALB"].text), path=request.FILES["mysong"], tracknumber="".join(song_info["TRCK"].text), picture=band_pic) song.user.add(current_user) song.save() redirect("upload") return render(request, "song_upload.html")
def scrape(query): mbid = query['mbid'] artist = query['artist'] release = query['release'] year = query['year'] if not artist or not release or not year: raise Exception( "Artist, release, and year information is required. Query: %s" % json.dumps(query)) print "Scraping recording information for", mbid + ":", artist, "-", release, "-", year artist = artist.decode('utf8') release = release.decode('utf8') release_simple = re.sub(r'\W+', '', release.lower()) year = year.split('-')[0] data = None try: d = discogs_client.Client('AB_Discogs/0.1', user_token=DISCOGS_KEY) results = d.search(artist=artist, release_title=release) data = [ r.data for r in results if 'year' in r.data and r.data['year'] == year ] except ApiException as ex: raise return data, TYPE
def save_data(filename): """ Saves requested data to filename :param filename: filename where data will be saved :return: None """ with open(filename, "w") as file: file.write("style\n") # creating client client = discogs_client.Client( 'ExampleApplication/0.1', user_token="wuYMABvmUDdOMXerFacIXQBQJJphFkPgtivGgfLW") a = process.ProcessMap(client, "countries.txt") # saving additional data a.request_additional(type="release", year=2016) result = [] for element in a._elements: result.append(element.additional) file.write("{}\n".format(str(result))) print(result) # reading key elements with open("styles.txt", "r") as file: styles = [line.strip() for line in file.readlines()] # saving main data for style in styles: a.request_values("", type="release", year=2016, style=style) result = [] for element in a._elements: result.append(element.value) file.write("{}\t{}\n".format(style, result)) print("{} {}".format(style, result))
def get_discogs_api_object(self): if self.discogs_api: return self.discogs_api else: self.discogs_api = discogs_client.Client( 'ExampleApplication/0.1', user_token=self.DISCOGS_KEY) return self.discogs_api
def build_mapchart(): client = discogs_client.Client( 'ExampleApplication/0.1', user_token="wuYMABvmUDdOMXerFacIXQBQJJphFkPgtivGgfLW") type = request.args.get('type', 0, type=str) style = request.args.get('style', 0, type=str) year = int(request.args.get('year', 0, type=int)) is_percentage = request.args.get("percentage", 0, type=str) process = map_process.ProcessMap(client, "countries.txt") process.request_values("", read_file="style-countries.txt", type=type, style=style, year=year) if is_percentage == "true": process.request_additional("", read_file="style-countries.txt", type=type, year=year) data = process.percentage_list() data.insert(0, ["Country", "Percentage"]) else: data = process.values_list() data.insert(0, ["Country", "Releases"]) print(data) return jsonify(result=data)
def setup_platform( hass: HomeAssistant, config: ConfigType, add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the Discogs sensor.""" token = config[CONF_TOKEN] name = config[CONF_NAME] try: _discogs_client = discogs_client.Client(SERVER_SOFTWARE, user_token=token) discogs_data = { "user": _discogs_client.identity().name, "folders": _discogs_client.identity().collection_folders, "collection_count": _discogs_client.identity().num_collection, "wantlist_count": _discogs_client.identity().num_wantlist, } except discogs_client.exceptions.HTTPError: _LOGGER.error("API token is not valid") return monitored_conditions = config[CONF_MONITORED_CONDITIONS] entities = [ DiscogsSensor(discogs_data, name, description) for description in SENSOR_TYPES if description.key in monitored_conditions ] add_entities(entities, True)
def new_client_authorization(): CONSUMER_KEY = 'dRWuEIUFudONhVsYyoPa' CONSUMER_SECRET = 'YBREVPKyCdoUBUdvYerSHruZMMcENONj' d = discogs_client.Client(USER_AGENT) d.set_consumer_key(CONSUMER_KEY, CONSUMER_SECRET) token, secret, url = d.get_authorize_url() print(' ==Request Token== ') print(f' * ouath_token = {token}') print(f' * ouath_token_secret = {secret}') print() print(f'Retrieve authentication token from: {url}') accepted = '' while accepted.lower() != 'y': print() accepted = input('Token ready? [y/n] :') oauth_verifier = input('Verification code: ') try: access_token, access_secret = d.get_access_token(oauth_verifier) except HTTPError: print('Unable to authenticate.') sys.exit(1) return d
def request_review(self, album_name): # connect to Discogs d = discogs_client.Client(self.app_name, user_token=self.user_token) # search Discogs for album results = d.search(album_name, type='release') search_results = [] if len(results) == 0: print("Could not find album.") else: # extract artist's name artist = results[0].artists[0] artist_name = artist.name try: # search Pitchfork for review p = pitchfork.search(artist_name, album_name) search_results.append(artist_name) search_results.append(p.album()) search_results.append(p.label()) search_results.append(p.score()) except Exception: print("Album not found in Pitchfork.") pass return search_results
def connect_to_api(self): d = discogs_client.Client( 'MusicApp', user_token='lYZxOrAPASUOlpDrZMPaMdnWZczHZVoAoECIBjTM') results = d.search(artist=self.artist, track=self.title, type='master', format='album') return results
def __init__(self, t): """ Initializer. Create Discogs Client :param t: token """ self.peppy_player_user_agent = "PeppyPlayer +https://github.com/project-owner/Peppy" self.client = discogs_client.Client(self.peppy_player_user_agent, user_token=t)
def init_client(self, token): """ Initialize Discogs Client :param token: the API token """ self.client = discogs_client.Client(self.peppy_player_user_agent, user_token=token)
def Init(self): if filename: with open(filename, 'r') as f: data = json.load(f) self.key = data["discogskey"] self.secret = data["discogssecret"] self.token = data["discogstoken"] self.d = discogs_client.Client('Bot', user_token=self.token)
def _build_discogs_instance(): DEVELOPER_KEY = read_credentials(CREDENTIALS_FILE) discogs = discogs_client.Client('SpinYoRecords', user_token=DEVELOPER_KEY) return discogs
def make_client(): """Initialise single-user authorised discogs client.""" user_token = os.environ.get('DISCOGS_USER_TOKEN') if user_token is None: user_token = DISCOGS_USER_TOKEN if user_token is None: raise ValueError('You must specify a valid discogs user token') return discogs_client.Client(DISCOGS_USER_AGENT, user_token=user_token)
def fetchMatching(request, record_name): #d = discogs.Client('ExampleApplication/0.1') d = discogs.Client('ExampleApplication/0.1', user_token="kjSzomrwGYmaghjNUbTnTCLtEwlpETrtDkLTKAnF") results = d.search(record_name, type='release') response = '{"data":[{ "name": "' + results[ 0].title + '", "artist": "' + results[0].artists[ 0].name + '", "year": "' + str(results[0].year) + '" }]}' return HttpResponse(response)
def list(self, request): d = discogs_client.Client( 'Fullstack/0.1 +@:[email protected]', user_token="EMIDOqyOnyXKSDQGfzjhruBlRDBvBVaZnIDcaTOd") release_id = self.request.query_params.get("release", None) results = d.release(release_id) print(results) return Response(results.data)
def get_releases(): try: discogs_cl = discogs_client.Client("PricelistDiscogs/0.9.1", user_token=developer_token) return discogs_cl.user(user).collection_folders[0] except HTTPError: print( 'paste your user/token in arguments or edit "lib/credentials.py"') quit()
def index(request): d = discogs.Client('ExampleApplication/0.1') d = discogs.Client('ExampleApplication/0.1', user_token="kjSzomrwGYmaghjNUbTnTCLtEwlpETrtDkLTKAnF") results = d.search('Stockholm By Night', type='release') print(results.pages) sivut = results.pages artist = results[0].artists[0] nimi = artist.name print(artist.name) master_release = d.master(120735) print(artist.id) print(master_release.main_release) print(master_release.title) print(master_release.tracklist) return HttpResponse( "Hello, world. You're at the discogs index. Artisti on " + nimi)
def __init__(self): self.discogsclient = discogs_client.Client(user_agent, user_token=consumer_token) # fetch the identity object for the current logged in user. user = self.discogsclient.identity() print() print(' == User ==') print(' * username = {0}'.format(user.username))
def __init__(self, instance): super(Discogs, self).__init__(instance) # https://github.com/discogs/discogs_client self.d = discogs_client.Client( user_agent, consumer_key=self.oauth.consumer_key, consumer_secret=self.oauth.consumer_secret, token=self.oauth.resource_owner_key, secret=self.oauth.resource_owner_secret)
def main_find(self): d = discogs_client.Client('JMoney/0.1', user_token=self.var_token) results = d.search(self.var_name, artist=self.var_artist, album=self.var_album, type=self.var_type, country=self.var_country) self.var_result = results.page(1) if self.PRINT_RESULT == 1: print(self.var_result)
def get_discogs_client(): """gets authed discogs client Returns: authed discogs client """ discogs = discogs_client.Client( user_agent=current_app.config['APP_NAME'], user_token=current_app.config['DISCOGS_USER_TOKEN']) return discogs
def __init__(self, dummy_response): # we need a dummy client here ;-( client = discogs.Client('Dummy Client - just for unit testing') self.dummy_response = dummy_response self.content = self.convert(json.loads(dummy_response.content)) self.release = discogs.Release(client, self.content['resp']['release']) DiscogsAlbum.__init__(self, self.release)