Question

need help to complete the task:

• app.py is the Python server-side application.
  • It includes a class for representing the list of albums. You need to complete the missing parts such that it loads data from the data/albums.txt and data/tracks.txt files. You can decide what internal data structure you want to use for storing the data.
  • It is already implemented that a single instance of the Albums class is used, so that loading from the files happens only once (and not for each request).

heres the code:

from flask import Flask, request, g
	app = Flask(__name__)
	class Albums():
	"""Class representing a collection of albums."""
	def __init__(self, albums_file, tracks_file):
	self.__albums = {}
	self.__load_albums(albums_file)
	self.__load_tracks(tracks_file)
	def __load_albums(self, albums_file):
	"""Loads a list of albums from a file."""
	# TODO complete
	pass
	def __load_tracks(self, tracks_file):
	"""Loads a list of tracks from a file."""
	# TODO complete
	pass
	def get_albums(self):
	"""Returns a list of all albums, with album_id, artist and title."""
	# TODO complete
	return None
	def get_album(self, album_id):
	"""Returns all details of an album."""
	# TODO complete
	return None
	# the Albums class is instantiated and stored in a config variable
	# it's not the cleanest thing ever, but makes sure that the we load the text files only once
	app.config["albums"] = Albums("data/albums.txt", "data/tracks.txt")
	@app.route("/albums")
	def albums():
	"""Returns a list of albums (with album_id, author, and title) in JSON."""
	albums = app.config["albums"]
	# TODO complete (return albums.get_albums() in JSON format)
	return ""
	@app.route("/albuminfo")
	def albuminfo():
	albums = app.config["albums"]
	album_id = request.args.get("album_id", None)
	if album_id:
	# TODO complete (return albums.get_album(album_id) in JSON format)
	return ""
	return ""
	@app.route("/sample")
	def sample():
	return app.send_static_file("index_static.html")
	@app.route("/")
	def index():
	return app.send_static_file("index.html")
	if __name__ == "__main__":
	app.run()

i have to textfiles:

tracks.txt:

1   Politik   5:18
1   In My Place   3:48
1   God Put a Smile upon Your Face   4:57
1   The Scientist   5:09
1   Clocks   5:07
1   Daylight   5:27
1   Green Eyes   3:43
1   Warning Sign   5:31
1   A Whisper   3:58
1   A Rush of Blood to the Head   5:51
1   Amsterdam   5:19
2   Right Next Door to Hell   3:02
2   Dust N' Bones   4:58
2   Live and Let Die   3:04
2   Don't Cry   4:44
2   Perfect Crime   2:23
2   You Ain't the First   2:36
2   Bad Obsession   5:28
2   Back Off Btch   5:03
2   Double Talkin' Jive   3:23
2   November Rain   8:57
2   The Garden   5:22
2   Garden of Eden   2:41
2   Don't Dam Me   5:18
2   Bad Apples   4:28
2   Dead Horse   4:17
2   Coma   10:13

albums.txt:

1   Coldplay   A Rush of Blood to the Head   Coldplay-ARushofBlood.jpg
2   Guns N' Roses   Use Your Illusion I   GnR-UseYourIllusion1.jpg

Answer 1

Below is the Python code. I have tested it by hitting the API request through a Postman client and it is working. I have put inline comments in code for explanation. Note that I have assumed that the data in albums.txt and tracks.txt is tab delimited.

from flask import Flask, request, jsonify

app = Flask(__name__)

class Albums():
   """Class representing a collection of albums."""
   def __init__(self, albums_file, tracks_file):
       self.__albums = {}
       self.__load_albums(albums_file)
       self.__load_tracks(tracks_file)

   def __load_albums(self, albums_file):
       """Loads a list of albums from a file."""
       with open(albums_file, "r") as f:
           data = f.read()

       # Read each line by splitting data with '\n'
       for line in data.split("\n"):

           # Assuming that the file is delimited with tabs ('\t'),
           # get the album details from the line by splitting with '\t' and add it to `self.__albums`
           # We create an empty list per album under the key "tracks" that will be populated later in __load_tracks function
           album_id, artist, title, image = line.split("\t")
           self.__albums[album_id] = {
               "artist": artist,
               "title": title,
               "tracks": []
           }

   def __load_tracks(self, tracks_file):
       """Loads a list of tracks from a file."""
       with open(tracks_file, "r") as f:
           data = f.read()

       # Read each line by splitting data with '\n'
       for line in data.split("\n"):

           # Assuming that the file is delimited with tabs ('\t'),
           # get the track details from the line by splitting with '\t'
           album_id, song, duration = line.split("\t")
           track_details = {
               "song": song,
               "duration": duration
           }

           # Add the track details to self.__albums under the corresponding album_id
           self.__albums[album_id]["tracks"].append(track_details)

   def get_albums(self):
       """Returns a list of all albums, with album_id, artist and title."""
       album_details = []
       for album_id, album_info in self.__albums.items():
           album_details.append({
               "album_id": album_id,
               "artist": album_info["artist"],
               "title": album_info["title"]
           })
       return album_details

   def get_album(self, album_id):
       """Returns all details of an album."""
       return self.__albums[album_id]

# the Albums class is instantiated and stored in a config variable
# it's not the cleanest thing ever, but makes sure that the we load the text files only once
app.config["albums"] = Albums("data/albums.txt", "data/tracks.txt")

@app.route("/albums")
def albums():
   """Returns a list of albums (with album_id, author, and title) in JSON."""
   albums = app.config["albums"]
   return jsonify({"albums": albums.get_albums()})

@app.route("/albuminfo")
def albuminfo():
   albums = app.config["albums"]
   album_id = request.args.get("album_id", None)
   if album_id:
       return jsonify(albums.get_album(album_id))
   return jsonify({})

@app.route("/sample")
def sample():
   return app.send_static_file("index_static.html")

@app.route("/")
def index():
   return app.send_static_file("index.html")

if __name__ == "__main__":
   app.run()