Upload app.py with huggingface_hub

app.py

@@ -1,13 +1,14 @@
 
+    
 import streamlit as st
 from streamlit_ace import st_ace
 import pandas as pd
 
 button_style = st.markdown('''
 <style>
-div.stButton > button:first-child {
+div.stButton > button:first-child {{
     background-color: #3A7EF1;
-}
+}}
 </style>''', unsafe_allow_html=True)
 
 left_co, cent_co,last_co = st.columns(3)
@@ -17,100 +18,76 @@ st.markdown("<h5 style='color: #707379;  text-align: center;'>School of AI by 10
 st.markdown('')
 
 
-def check_solution(instructor_code, student_code, function_name, test_cases):
+def check_solution(code, func_params):
     try:
+        exec(code)
         globals_dict = {}
-        exec(instructor_code, globals_dict)
-        instructor_function = globals_dict.get(function_name)
+        exec(code, globals_dict)
+        function_to_test = globals_dict.get(func_params.get('function_name'))
 
-        if not callable(instructor_function):
-            raise ValueError(f"{instructor_function} is not a callable function.")
-        
-        # Execute student's code
-        globals_dict = {}
-        exec(student_code, globals_dict)
-        student_function = globals_dict.get(function_name)
-
-        if not callable(student_function):
-            raise ValueError(f"{function_name} is not a callable function.")
+        if not callable(function_to_test):
+            raise ValueError(f"{{func_params.get('function_name')}} is not a callable function.")
 
         # Run the tests and populate the results table
         expected_result_list = []
         actual_result_list = []
         test_result = []
-        for test_case in test_cases:
-            expected_result = instructor_function(*test_case)
-            actual_result = student_function(*test_case)
-            expected_result_list.append(expected_result)
-            actual_result_list.append(actual_result)
-            test_result.append("Passed" if expected_result == actual_result else "Failed")
+        for input_params, expected_output in func_params["test_cases"]:
+            expected_result_list.append(expected_output)
+            result = function_to_test(*input_params)
+            actual_result_list.append(result)
+            test_result.append("Passed" if expected_result_list == actual_result_list else "Failed")
         result_df = pd.DataFrame({
-            "Expected": expected_result_list,
-            "Run": actual_result_list,
-            "Result": test_result
+                "Expected": expected_result_list,
+                "Run": actual_result_list,
+                "Result": test_result
         }, index=None)
         st.markdown(result_df.style.hide(axis="index").to_html(), unsafe_allow_html=True)
         st.markdown("<br>", unsafe_allow_html=True)
 
         # Check if all tests passed
-        if all(expected == actual for expected, actual in zip(expected_result_list, actual_result_list)):
+        if expected_result_list == actual_result_list:
             st.success("All tests passed!")
         else:
             st.error("Some tests failed.")
         return True
 
     except SyntaxError as e:
-        st.error(f"Error: {e}")
+        st.error(f"Error: {{e}}")
 
 
 def main():
-
+    
     with st.form('app'):
         st.markdown("<h2 style='color: #707379;'>Coding Challenge - Code Practice</h2>", unsafe_allow_html=True)
-
+    
         # Description of the challenge
         st.write("Create a function sum that meets the following criteria:")
-        st.write('''Create a function that sums any two values''')
-
-        func = 'sum'
-        def execute_instructor_code(params):
-            # Execute the instructor's code to get the result
-            globals_dict = {}
-            exec('''def sum(a,b):
-    return a+b''', globals_dict)
-            instructor_function = globals_dict.get(func)
-
-            if not callable(instructor_function):
-                raise ValueError(f"{func} is not a callable function.")
-
-            return instructor_function(*params)
-
-        # Generate sample examples dynamically by executing the instructor's code
-        test_cases = [(1, 2), (100, 200), (0, 3)]  
-        sample_examples = "\n".join([f"{func}({', '.join(map(str, params))}) -> {execute_instructor_code(params)}" for params in test_cases])
+        st.write('''Sum of two values''')
+        
+        # Display sample example for all test cases
+        sample_examples = "Sample"
         st.code(sample_examples, language="python")
         show_solution_button = st.form_submit_button("Show Solution")
         if show_solution_button:
             solution = '''def sum(a,b):
-    return a+b'''
+    return a+b '''
             if solution:
                 st.code('''def sum(a,b):
-    return a+b''', language="python")
+    return a+b ''', language="python")
             else:
                 st.error('No Solution Provided!')
-
+    
         # Code input area
         code = st_ace(value='''def sum(a,b):''', language="python", key="my_editor", theme='clouds', height=200)
         # Check solution button
         if st.form_submit_button("Check Solution"):
             if code:
                 # Check the solution
-                check_solution('''def sum(a,b):
-    return a+b''',
-                                code,
-                                'sum',
-                                [(1, 2), (100, 200), (0, 3)]
-                                )
+                check_solution(code, {
+                    "function_name": "sum",
+                    "test_cases": [((1, 2), 3), ((1, 0), 1), ((-1, -2), -3)]
+                })
             else:
                 st.error("Please provide a solution.")
 
@@ -118,3 +95,5 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+