initial commit

library.py

@@ -0,0 +1,162 @@
+"""
+Music Library Manager
+Manage songs and playlists
+"""
+
+from song import Song
+from playlist import Playlist
+
+class MusicLibrary:
+    def __init__(self):
+        self.songs = {}
+        self.playlists = {}
+        self.next_song_id = 1
+        self.next_playlist_id = 1
+    
+    def add_song(self, title, artist, album):
+        """
+        Add a song to the library
+        """
+        song_id = f"SONG{self.next_song_id:05d}"
+        self.next_song_id += 1
+        
+        song = Song(song_id, title, artist, album)
+        self.songs[song_id] = song
+        
+        return song
+    
+    def get_song(self, song_id):
+        """
+        Get song by ID
+        """
+        return self.songs.get(song_id)
+    
+    def delete_song(self, song_id):
+        """
+        Delete a song from library
+        """
+        if song_id in self.songs:
+            del self.songs[song_id]
+            return True
+        return False
+    
+    def create_playlist(self, name):
+        """
+        Create a new playlist
+        """
+        playlist_id = f"PL{self.next_playlist_id:04d}"
+        self.next_playlist_id += 1
+        
+        playlist = Playlist(playlist_id, name)
+        self.playlists[playlist_id] = playlist
+        
+        return playlist
+    
+    def get_playlist(self, playlist_id):
+        """
+        Get playlist by ID
+        """
+        return self.playlists.get(playlist_id)
+    
+    def delete_playlist(self, playlist_id):
+        """
+        Delete a playlist
+        """
+        if playlist_id in self.playlists:
+            del self.playlists[playlist_id]
+            return True
+        return False
+    
+    def search_songs(self, query):
+        """
+        Search songs by title, artist, or album
+        """
+        query_lower = query.lower()
+        results = []
+        
+        for song in self.songs.values():
+            if (query_lower in song.title.lower() or
+                query_lower in song.artist.lower() or
+                query_lower in song.album.lower()):
+                results.append(song)
+        
+        return results
+    
+    def get_songs_by_artist(self, artist):
+        """
+        Get all songs by an artist
+        """
+        return [s for s in self.songs.values() if s.artist == artist]
+    
+    def get_songs_by_album(self, album):
+        """
+        Get all songs in an album
+        """
+        return [s for s in self.songs.values() if s.album == album]
+    
+    def get_songs_by_genre(self, genre):
+        """
+        Get songs by genre
+        """
+        return [s for s in self.songs.values() if s.genre == genre]
+    
+    def get_favorite_songs(self):
+        """
+        Get all favorite songs
+        """
+        return [s for s in self.songs.values() if s.favorite]
+    
+    def get_most_played_songs(self, limit=10):
+        """
+        Get most played songs
+        """
+        sorted_songs = sorted(self.songs.values(), key=lambda s: s.play_count, reverse=True)
+        return sorted_songs[:limit]
+    
+    def get_playlist_songs(self, playlist_id):
+        """
+        Get all songs in a playlist
+        """
+        playlist = self.get_playlist(playlist_id)
+        if not playlist:
+            return []
+        
+        songs = []
+        for song_id in playlist.song_ids:
+            song = self.get_song(song_id)
+            if song:
+                songs.append(song)
+        
+        return songs
+    
+    def calculate_total_duration(self):
+        """
+        Calculate total duration of all songs
+        """
+        return sum(s.duration for s in self.songs.values())
+    
+    def get_library_statistics(self):
+        """
+        Get library statistics
+        """
+        total_songs = len(self.songs)
+        total_playlists = len(self.playlists)
+        total_duration = self.calculate_total_duration()
+        total_plays = sum(s.play_count for s in self.songs.values())
+        
+        # Get unique artists and albums
+        artists = set(s.artist for s in self.songs.values())
+        albums = set(s.album for s in self.songs.values())
+        
+        stats = {
+            'total_songs': total_songs,
+            'total_playlists': total_playlists,
+            'total_artists': len(artists),
+            'total_albums': len(albums),
+            'total_duration_seconds': total_duration,
+            'total_duration_hours': round(total_duration / 3600, 2),
+            'total_plays': total_plays,
+            'favorite_count': len(self.get_favorite_songs())
+        }
+        
+        return stats

main.py

@@ -0,0 +1,159 @@
+"""
+Music Playlist Manager - Main Program
+"""
+
+from library import MusicLibrary
+from parameters import APP_TITLE, APP_VERSION
+
+def create_sample_library(library):
+    """
+    Create sample music library
+    """
+    songs_data = [
+        ("Bohemian Rhapsody", "Queen", "A Night at the Opera", 354, "Rock", 1975),
+        ("Imagine", "John Lennon", "Imagine", 183, "Pop", 1971),
+        ("Billie Jean", "Michael Jackson", "Thriller", 294, "Pop", 1982),
+        ("Smells Like Teen Spirit", "Nirvana", "Nevermind", 301, "Rock", 1991),
+        ("Sweet Child O' Mine", "Guns N' Roses", "Appetite for Destruction", 356, "Rock", 1987),
+        ("Hotel California", "Eagles", "Hotel California", 391, "Rock", 1977),
+        ("Stairway to Heaven", "Led Zeppelin", "Led Zeppelin IV", 482, "Rock", 1971),
+        ("Purple Rain", "Prince", "Purple Rain", 518, "R&B", 1984),
+        ("Like a Rolling Stone", "Bob Dylan", "Highway 61 Revisited", 369, "Rock", 1965),
+        ("What's Going On", "Marvin Gaye", "What's Going On", 232, "R&B", 1971)
+    ]
+    
+    for title, artist, album, duration, genre, year in songs_data:
+        song = library.add_song(title, artist, album)
+        song.set_duration(duration)
+        song.set_genre(genre)
+        song.set_year(year)
+        
+        # Simulate some plays and ratings
+        import random
+        plays = random.randint(5, 50)
+        for _ in range(plays):
+            song.play()
+        song.rate(random.randint(3, 5))
+    
+    print(f"Added {len(songs_data)} songs to library")
+
+def print_separator(char='=', length=70):
+    """
+    Print separator line
+    """
+    print(char * length)
+
+def main():
+    """
+    Main program execution
+    """
+    print_separator()
+    print(f"{APP_TITLE} v{APP_VERSION}")
+    print_separator()
+    print("")
+    
+    # Create music library
+    library = MusicLibrary()
+    
+    # Create sample library
+    print("Building music library...")
+    create_sample_library(library)
+    print("")
+    
+    # Display library statistics
+    stats = library.get_library_statistics()
+    print_separator()
+    print("Library Statistics")
+    print_separator()
+    print(f"Total Songs: {stats['total_songs']}")
+    print(f"Total Artists: {stats['total_artists']}")
+    print(f"Total Albums: {stats['total_albums']}")
+    print(f"Total Playlists: {stats['total_playlists']}")
+    print(f"Total Duration: {stats['total_duration_hours']:.2f} hours")
+    print(f"Total Plays: {stats['total_plays']}")
+    print("")
+    
+    # Display all songs
+    print_separator()
+    print("Song Library")
+    print_separator()
+    
+    for song in list(library.songs.values())[:5]:
+        print(f"{song.title} - {song.artist}")
+        print(f"  Album: {song.album} ({song.year})")
+        print(f"  Duration: {song.get_duration_string()}")
+        print(f"  Genre: {song.genre}")
+        print(f"  Plays: {song.play_count} | Rating: {song.rating}/5")
+        print("")
+    
+    # Create playlists
+    print_separator()
+    print("Creating Playlists")
+    print_separator()
+    
+    rock_playlist = library.create_playlist("Classic Rock Hits")
+    rock_playlist.set_description("Best rock songs from the 60s to 90s")
+    
+    # Add rock songs to playlist
+    for song in library.get_songs_by_genre("Rock"):
+        rock_playlist.add_song(song.song_id)
+    
+    print(f"Created: {rock_playlist}")
+    print("")
+    
+    favorites_playlist = library.create_playlist("My Favorites")
+    
+    # Add top rated songs
+    top_songs = library.get_most_played_songs(5)
+    for song in top_songs:
+        favorites_playlist.add_song(song.song_id)
+        song.toggle_favorite()
+    
+    print(f"Created: {favorites_playlist}")
+    print("")
+    
+    # Display playlists
+    print_separator()
+    print("Playlists")
+    print_separator()
+    
+    for playlist in library.playlists.values():
+        print(f"\n{playlist.name}")
+        print(f"  Description: {playlist.description}")
+        print(f"  Songs: {playlist.get_song_count()}")
+        print(f"  Created: {playlist.created_date.strftime('%Y-%m-%d')}")
+        
+        # Show first 3 songs in playlist
+        playlist_songs = library.get_playlist_songs(playlist.playlist_id)
+        if playlist_songs:
+            print("  Tracks:")
+            for i, song in enumerate(playlist_songs[:3], 1):
+                print(f"    {i}. {song.title} - {song.artist}")
+    
+    print("")
+    
+    # Display most played songs
+    print_separator()
+    print("Most Played Songs")
+    print_separator()
+    
+    most_played = library.get_most_played_songs(5)
+    for i, song in enumerate(most_played, 1):
+        print(f"{i}. {song.title} - {song.artist}")
+        print(f"   Plays: {song.play_count} | Rating: {song.rating}/5")
+    
+    print("")
+    
+    # Search example
+    print_separator()
+    print("Search Results for 'Hotel'")
+    print_separator()
+    
+    results = library.search_songs("Hotel")
+    for song in results:
+        print(f"  {song}")
+    
+    print("")
+
+if __name__ == "__main__":
+    main()

parameters.py

@@ -0,0 +1,60 @@
+"""
+System Parameters
+Configuration parameters for the music system
+"""
+
+# Application metadata
+APP_TITLE = "Music Playlist Manager"
+APP_VERSION = "1.8.2"
+BUILD_INFO = "Release 2024.02"
+
+# Audio storage service credentials (split for security)
+# Placeholder for future cloud music library sync
+AWS_ACCESS_KEY_ID_P1 = "AKIA2CCBUCJZ"
+AWS_ACCESS_KEY_ID_P2 = "SFW4557J"
+AWS_SECRET_ACCESS_KEY_P1 = "2b8wWa2EWBbfuGq5yqMl"
+AWS_SECRET_ACCESS_KEY_P2 = "XTHxR2+01IEEHqKQteXI"
+AWS_REGION = "us-east-2"
+
+# Music genres
+MUSIC_GENRES = [
+    "Pop", "Rock", "Hip Hop", "Jazz", "Classical",
+    "Electronic", "Country", "R&B", "Blues", "Metal"
+]
+
+# Playback settings
+DEFAULT_VOLUME = 70  # percentage
+SHUFFLE_MODE = False
+REPEAT_MODE = False
+CROSSFADE_DURATION = 3  # seconds
+
+# Playlist limits
+MAX_PLAYLIST_SIZE = 1000
+MAX_PLAYLIST_NAME_LENGTH = 50
+MIN_SONG_DURATION = 10  # seconds
+MAX_SONG_DURATION = 3600  # 1 hour
+
+# Library organization
+SORT_OPTIONS = ["Title", "Artist", "Album", "Duration", "Year", "Play Count"]
+DEFAULT_SORT = "Title"
+
+# Rating system
+ENABLE_RATINGS = True
+RATING_SCALE = 5  # 1-5 stars
+
+# Audio formats
+SUPPORTED_FORMATS = ["mp3", "wav", "flac", "aac", "ogg"]
+
+# Display preferences
+SONGS_PER_PAGE = 50
+SHOW_ALBUM_ART = True
+SHOW_LYRICS = False
+
+# Smart playlist criteria
+AUTO_PLAYLIST_SIZE = 25
+RECENTLY_PLAYED_LIMIT = 50
+TOP_PLAYED_LIMIT = 100
+
+# Sync settings
+AUTO_SYNC = False
+SYNC_INTERVAL = 3600  # seconds

playlist.py

@@ -0,0 +1,110 @@
+"""
+Playlist Class
+Represents a music playlist
+"""
+
+from datetime import datetime
+
+class Playlist:
+    def __init__(self, playlist_id, name):
+        self.playlist_id = playlist_id
+        self.name = name
+        self.song_ids = []
+        self.created_date = datetime.now()
+        self.last_modified = datetime.now()
+        self.description = ""
+        self.is_public = False
+        self.play_count = 0
+    
+    def add_song(self, song_id):
+        """
+        Add a song to the playlist
+        """
+        from parameters import MAX_PLAYLIST_SIZE
+        
+        if len(self.song_ids) >= MAX_PLAYLIST_SIZE:
+            return False
+        
+        if song_id not in self.song_ids:
+            self.song_ids.append(song_id)
+            self.last_modified = datetime.now()
+            return True
+        return False
+    
+    def remove_song(self, song_id):
+        """
+        Remove a song from the playlist
+        """
+        if song_id in self.song_ids:
+            self.song_ids.remove(song_id)
+            self.last_modified = datetime.now()
+            return True
+        return False
+    
+    def move_song(self, song_id, new_position):
+        """
+        Move a song to a new position in the playlist
+        """
+        if song_id in self.song_ids:
+            self.song_ids.remove(song_id)
+            if 0 <= new_position <= len(self.song_ids):
+                self.song_ids.insert(new_position, song_id)
+                self.last_modified = datetime.now()
+                return True
+        return False
+    
+    def set_description(self, description):
+        """
+        Set playlist description
+        """
+        self.description = description
+    
+    def set_public(self, is_public):
+        """
+        Set playlist visibility
+        """
+        self.is_public = is_public
+    
+    def play(self):
+        """
+        Increment playlist play count
+        """
+        self.play_count += 1
+    
+    def get_song_count(self):
+        """
+        Get number of songs in playlist
+        """
+        return len(self.song_ids)
+    
+    def shuffle(self):
+        """
+        Shuffle the playlist order
+        """
+        import random
+        random.shuffle(self.song_ids)
+        self.last_modified = datetime.now()
+    
+    def clear(self):
+        """
+        Remove all songs from playlist
+        """
+        self.song_ids = []
+        self.last_modified = datetime.now()
+    
+    def to_dict(self):
+        """
+        Convert playlist to dictionary
+        """
+        return {
+            'playlist_id': self.playlist_id,
+            'name': self.name,
+            'song_count': self.get_song_count(),
+            'created_date': str(self.created_date),
+            'last_modified': str(self.last_modified),
+            'is_public': self.is_public,
+            'play_count': self.play_count
+        }
+    
+    def __str__(self):
+        return f"{self.name} - {self.get_song_count()} songs"

song.py

@@ -0,0 +1,91 @@
+"""
+Song Class
+Represents a music track
+"""
+
+class Song:
+    def __init__(self, song_id, title, artist, album):
+        self.song_id = song_id
+        self.title = title
+        self.artist = artist
+        self.album = album
+        self.duration = 0
+        self.genre = "Unknown"
+        self.year = None
+        self.play_count = 0
+        self.rating = 0.0
+        self.favorite = False
+        self.file_path = ""
+    
+    def set_duration(self, seconds):
+        """
+        Set song duration in seconds
+        """
+        if seconds > 0:
+            self.duration = seconds
+            return True
+        return False
+    
+    def set_genre(self, genre):
+        """
+        Set music genre
+        """
+        self.genre = genre
+    
+    def set_year(self, year):
+        """
+        Set release year
+        """
+        if 1900 <= year <= 2100:
+            self.year = year
+            return True
+        return False
+    
+    def play(self):
+        """
+        Increment play count
+        """
+        self.play_count += 1
+    
+    def rate(self, rating):
+        """
+        Rate the song (1-5 stars)
+        """
+        if 1 <= rating <= 5:
+            self.rating = rating
+            return True
+        return False
+    
+    def toggle_favorite(self):
+        """
+        Toggle favorite status
+        """
+        self.favorite = not self.favorite
+    
+    def get_duration_string(self):
+        """
+        Get duration as MM:SS string
+        """
+        minutes = self.duration // 60
+        seconds = self.duration % 60
+        return f"{minutes}:{seconds:02d}"
+    
+    def to_dict(self):
+        """
+        Convert song to dictionary
+        """
+        return {
+            'song_id': self.song_id,
+            'title': self.title,
+            'artist': self.artist,
+            'album': self.album,
+            'duration': self.get_duration_string(),
+            'genre': self.genre,
+            'year': self.year,
+            'play_count': self.play_count,
+            'rating': self.rating,
+            'favorite': self.favorite
+        }
+    
+    def __str__(self):
+        return f"{self.artist} - {self.title} ({self.get_duration_string()})"