Upload 19 files

.gitattributes

@@ -0,0 +1,3 @@
+Backend/data/scaled_df.csv filter=lfs diff=lfs merge=lfs -text
+Backend/data/tracks.csv filter=lfs diff=lfs merge=lfs -text
+Backend/ml_models/label_encoder_album.joblib filter=lfs diff=lfs merge=lfs -text

Backend/.flaskenv

@@ -0,0 +1,2 @@
+FLASK_APP=run
+FLASK_ENV=development

Backend/.gitignore

@@ -0,0 +1,216 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+Chat
+
+New Conversation
+🤓 Explain a complex thing
+
+Explain Artificial Intelligence so that I can explain it to my six-year-old child.
+
+
+🧠 Get suggestions and create new ideas
+
+Please give me the best 10 travel ideas around the world
+
+
+💭 Translate, summarize, fix grammar and more…
+
+Translate "I love you into" French
+
+
+coin image
+10
+Upgrade
+
+
+gpt image
+GPT-3.5
+Ask me anything...
+
+
+Make a Review & Earn Credit ❤
+Chat
+Ask
+Search
+Write
+Image
+ChatPDF
+Vision
+Full Page
+Invite & Earn
+
+

Backend/app/__init__.py

@@ -0,0 +1,20 @@
+from flask import Flask
+from flask_cors import CORS
+from config import Config
+import logging
+
+def create_app(config_class=Config):
+    app = Flask(__name__)
+    app.config.from_object(config_class)
+    
+    # Configure CORS
+    CORS(app, resources={r"/*": {"origins": "*"}}, supports_credentials=True)
+    
+    # Configure logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # Register blueprints
+    from app.routes.recommendation import bp as recommendation_bp
+    app.register_blueprint(recommendation_bp)
+    
+    return app

Backend/app/models/ml_models.py

@@ -0,0 +1,53 @@
+import pandas as pd
+from joblib import load
+import os
+import logging
+from config import Config
+
+logger = logging.getLogger(__name__)
+
+class MLModels:
+    _instance = None
+    _is_loaded = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(MLModels, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+            
+        self.tracks = None
+        self.scaled_df = None
+        self.scaler = None
+        self.kmeans = None
+        self.label_encoder_artists = None
+        self.label_encoder_genre = None
+        self._initialized = True
+    
+    def load_models(self):
+        """Load all required models and data if not already loaded"""
+        if not self._is_loaded:
+            try:
+                logger.info("Loading data and models...")
+                
+                # Use Config paths
+                self.tracks = pd.read_csv(os.path.join(Config.DATA_DIR, 'tracks.csv'))
+                self.scaled_df = pd.read_csv(os.path.join(Config.DATA_DIR, 'scaled_df.csv'))
+                self.scaler = load(os.path.join(Config.MODEL_DIR, 'scaler.joblib'))
+                self.kmeans = load(os.path.join(Config.MODEL_DIR, 'revibe.joblib'))
+                self.label_encoder_artists = load(os.path.join(Config.MODEL_DIR, 'label_encoder_artists.joblib'))
+                self.label_encoder_genre = load(os.path.join(Config.MODEL_DIR, 'label_encoder_genre.joblib'))
+                
+                self._is_loaded = True
+                logger.info("Data and models loaded successfully")
+            except Exception as e:
+                logger.error(f"Error loading models: {str(e)}")
+                raise
+    
+    @property
+    def is_loaded(self):
+        return self._is_loaded

Backend/app/routes/recommendation.py

@@ -0,0 +1,36 @@
+from flask import Blueprint, jsonify, request
+from app.services.recommendation import RecommendationService
+import logging
+
+bp = Blueprint('recommendation', __name__)
+logger = logging.getLogger(__name__)
+
+@bp.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({'status': 'healthy'}), 200
+
+@bp.route('/recommend', methods=['POST'])
+def recommend():
+    try:
+        data = request.get_json()
+        song_input = data.get('song', '').strip()
+        artist_input = data.get('artist', '').strip()
+        genre_input = data.get('genre', '').strip()
+        
+        recommendation_service = RecommendationService()
+        
+        if song_input:
+            recommendations = recommendation_service.get_recommendations_by_song(song_input)
+        elif artist_input and genre_input:
+            recommendations = recommendation_service.get_recommendations_by_artist_and_genre(artist_input, genre_input)
+        else:
+            return jsonify({'error': 'Invalid input. Please provide either a song or both artist and genre.'}), 400
+            
+        if isinstance(recommendations, dict) and 'error' in recommendations:
+            return jsonify(recommendations), 400
+            
+        return jsonify(recommendations)
+        
+    except Exception as e:
+        logger.error(f"An error occurred: {str(e)}", exc_info=True)
+        return jsonify({'error': str(e)}), 500

Backend/app/services/recommendation.py

@@ -0,0 +1,78 @@
+import pandas as pd
+from app.models.ml_models import MLModels
+
+class RecommendationService:
+    def __init__(self):
+        self.ml_models = MLModels()
+        # Ensure data is loaded
+        self.ml_models.load_models()
+    
+    def get_recommendations_by_song(self, song_input):
+        tracks = self.ml_models.tracks
+        scaled_df = self.ml_models.scaled_df
+        
+        parts = song_input.rsplit(' - ', 1)
+        if len(parts) != 2:
+            return {'error': "Invalid song input format. Please use 'Song Name - Artist Name'."}
+        
+        song_name, artist_from_input = parts
+        matching_songs = tracks[(tracks['track_name'].str.contains(song_name, case=False, na=False)) &
+                              (tracks['artists'].str.contains(artist_from_input, case=False, na=False))]
+        
+        if len(matching_songs) == 0:
+            return {'error': "No matching songs found."}
+            
+        selected_song_idx = matching_songs.index[0]
+        selected_song_cluster = scaled_df.loc[selected_song_idx, 'cluster']
+        cluster_songs = scaled_df[scaled_df['cluster'] == selected_song_cluster]
+        
+        recommendations = cluster_songs.sample(min(10, len(cluster_songs)))
+        recommendations = recommendations.sample(min(5, len(recommendations)))
+        
+        return self._format_recommendations(recommendations)
+    
+    def get_recommendations_by_artist_and_genre(self, artist_name, genre):
+        tracks = self.ml_models.tracks
+        scaled_df = self.ml_models.scaled_df
+        scaler = self.ml_models.scaler
+        kmeans = self.ml_models.kmeans
+        
+        matching_songs = tracks[(tracks['track_genre'].str.lower().str.contains(genre.lower(), na=False)) |
+                              (tracks['artists'].str.lower().str.contains(artist_name.lower(), na=False))]
+        
+        if len(matching_songs) == 0:
+            return {'error': "No matching songs found for the given artist or genre."}
+            
+        avg_features = matching_songs.loc[:, ['tempo', 'loudness', 'danceability', 'energy', 'acousticness',
+                                            'instrumentalness', 'speechiness', 'liveness', 'valence']].mean().values
+        
+        input_df = pd.DataFrame({
+            'tempo': [avg_features[0]],
+            'loudness': [avg_features[1]],
+            'track_genre_encoded': [tracks['track_genre_encoded'].mean()],
+            'artists_encoded': [tracks['artists_encoded'].mean()],
+            'danceability': [avg_features[2]],
+            'energy': [avg_features[3]],
+            'acousticness': [avg_features[4]],
+            'instrumentalness': [avg_features[5]],
+            'speechiness': [avg_features[6]],
+            'liveness': [avg_features[7]],
+            'valence': [avg_features[8]]
+        })
+        
+        input_features = scaler.transform(input_df)
+        closest_cluster = kmeans.predict(input_features)[0]
+        cluster_songs = scaled_df[scaled_df['cluster'] == closest_cluster]
+        
+        recommendations = cluster_songs.sample(min(10, len(cluster_songs)))
+        recommendations = recommendations.sample(min(5, len(recommendations)))
+        
+        return self._format_recommendations(recommendations)
+    
+    def _format_recommendations(self, recommendations):
+        tracks = self.ml_models.tracks
+        recommended_song_names = tracks.loc[recommendations.index, 'track_name']
+        recommended_artist_names = tracks.loc[recommendations.index, 'artists']
+        
+        return [{'song_name': song_name, 'artist': artist} 
+                for song_name, artist in zip(recommended_song_names, recommended_artist_names)]

Backend/commands.txt

@@ -0,0 +1,3 @@
+Backend\my_project_env\Scripts\activate
+cd C:\Users\garvi\Desktop\Website\Backend
+python index.py

Backend/config.py

@@ -0,0 +1,7 @@
+import os
+
+class Config:
+    DEBUG = os.environ.get('FLASK_DEBUG', 'False') == 'True'
+    PORT = int(os.environ.get('PORT', 5000))
+    DATA_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')
+    MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ml_models')

Backend/data/scaled_df.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f865fb27a3ea090a8605fb6f653179bd81783a3ce28c75e48d30b9da5b64f363
+size 24877337

Backend/data/tracks.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bf489cb06b71aded845531b012597943e64cc235c620368415ae3a6e9d95f12
+size 17551645

Backend/ml_models/label_encoder_album.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:249235edb343d58ffc9546ffcd993fe052d10d0cc077058365450bc4a17a8d6c
+size 1429578

Backend/run.py

@@ -0,0 +1,6 @@
+from app import create_app
+
+app = create_app()
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=app.config['PORT'])