Update src/streamlit_app.py

src/streamlit_app.py

@@ -12,69 +12,42 @@ st.set_page_config(
 
 @st.cache_resource
 def get_snowflake_connection():
-    """Create and cache Snowflake connection using private key"""
+    """Create and cache Snowflake connection using password"""
     try:
         # Get credentials from environment variables (Hugging Face secrets)
         user = os.environ.get("SNOWFLAKE_USER")
+        password = os.environ.get("SNOWFLAKE_PASSWORD")
         account = os.environ.get("SNOWFLAKE_ACCOUNT") 
         warehouse = os.environ.get("SNOWFLAKE_WAREHOUSE")
-        #private_key_string = os.environ.get("SNOWFLAKE_PRIVATE_KEY")
-        private_key_passphrase = os.environ.get("SNOWFLAKE_PASSPHRASE")
         
         # Debug: Show what we found (without exposing sensitive data)
         st.write("🔍 Debug Info:")
         st.write(f"- User found: {'✅' if user else '❌'}")
+        st.write(f"- Password found: {'✅' if password else '❌'}")
         st.write(f"- Account found: {'✅' if account else '❌'}")
         st.write(f"- Warehouse found: {'✅' if warehouse else '❌'}")
-        st.write(f"- Private key found: {'✅' if private_key_string else '❌'}")
         
-        if not all([user, account, warehouse, private_key_string]):
+        if not all([user, password, account, warehouse]):
             missing = []
             if not user: missing.append("SNOWFLAKE_USER")
+            if not password: missing.append("SNOWFLAKE_PASSWORD")
             if not account: missing.append("SNOWFLAKE_ACCOUNT")
             if not warehouse: missing.append("SNOWFLAKE_WAREHOUSE")
-            if not private_key_string: missing.append("SNOWFLAKE_PRIVATE_KEY")
             
             st.error(f"❌ Missing environment variables: {', '.join(missing)}")
             st.info("💡 Please add these as Repository Secrets in your Hugging Face Space settings.")
             return None
         
-        # Import crypto libraries for private key handling
-        from cryptography.hazmat.primitives import serialization
-        from cryptography.hazmat.primitives.serialization import load_pem_private_key
-        
-        # Convert the private key string to bytes and load it
-        private_key_bytes = private_key_string.encode('utf-8')
-        
-        # Load the private key (with or without passphrase)
-        if private_key_passphrase:
-            private_key = load_pem_private_key(
-                private_key_bytes,
-                password=private_key_passphrase.encode('utf-8')
-            )
-        else:
-            private_key = load_pem_private_key(
-                private_key_bytes,
-                password=None
-            )
-        
-        # Serialize the private key to DER format for Snowflake
-        private_key_der = private_key.private_bytes(
-            encoding=serialization.Encoding.DER,
-            format=serialization.PrivateFormat.PKCS8,
-            encryption_algorithm=serialization.NoEncryption()
-        )
-        
         st.write("🔑 Attempting Snowflake connection...")
         
-        # Connect using private key authentication
+        # Connect using password authentication
         conn = snowflake.connector.connect(
             user=user,
+            password=password,
             account=account,
             warehouse=warehouse,
             database="sennos_interview_prep",
-            schema="public",
-            private_key=private_key_der
+            schema="public"
         )
         
         st.success("✅ Successfully connected to Snowflake!")
@@ -83,10 +56,10 @@ def get_snowflake_connection():
     except Exception as e:
         st.error(f"❌ Failed to connect to Snowflake: {str(e)}")
         st.write("**Possible issues:**")
-        st.write("- Check that your private key is correctly formatted")
+        st.write("- Check that your password is correct")
         st.write("- Verify your Snowflake account identifier")
         st.write("- Ensure the user has proper permissions")
-        st.write("- Check if the warehouse is running")
+        st.write("- Check if the warehouse exists and is accessible")
         return None
 
 def make_prediction(batch_id, temp_mean, temp_std, ph_mean, ph_std,