ss

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,27 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E402" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N806" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="trx_clus" />
+          <option value="matrix_demand_transfer" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/weather_prediction_tutorial.iml" filepath="$PROJECT_DIR$/.idea/weather_prediction_tutorial.iml" />
+    </modules>
+  </component>
+</project>

.idea/sonarlint/issuestore/7/a/7a2c12d43e65ce1671e4eb01543ea4fda34bdcf3

@@ -0,0 +1,4 @@
+
+tpython:S1192F"\Define a constant instead of duplicating this literal 'Solar Power Generation (kW)' 3 times.(���
+spython:S117)"WRename this local variable "X_test" to match the regular expression ^[_a-z][a-z0-9_]*$.(��Џ�����

+tpython:S117)"XRename this local variable "X_train" to match the regular expression ^[_a-z][a-z0-9_]*$.(��Џ�����

.idea/sonarlint/issuestore/8/7/87caad19f17efd4c3e8264659f523744ffa94ed8

@@ -0,0 +1,2 @@
+
+Gpython:S1066"/Merge this if statement with the enclosing one.(����

.idea/sonarlint/issuestore/index.pb

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

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/weather_prediction_tutorial.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.sessions/chandra_irugalbandara/level.txt

@@ -0,0 +1 @@
+0

.sessions/johndoe/level.txt

@@ -0,0 +1 @@
+3

0_Introduction.py

@@ -0,0 +1,32 @@
+import streamlit as st
+from utils.levels import complete_level, initialize_level, render_page, get_level
+from utils.login import initialize_login
+
+initialize_login()
+initialize_level()
+
+LEVEL=0
+
+def intro_page():
+    st.header("Weather Forecasting")
+    st.subheader("Introduction")
+
+    st.write("""Welcome to the interactive tutorial on creating your very own Weather Forecasting Application!""")
+
+    st.image(
+        "https://www.beckwithweather.com/wp-content/uploads/sites/1134/2020/06/860_main_weather_and_prediction.png",
+        use_column_width=True,
+    )
+
+    st.write(
+        """
+        In this tutorial, you will learn how to build a simple application that can forecast weather conditions to make informed decisions. Weather forecasting plays a pivotal role in our daily lives, influencing our travel plans, agricultural activities, energy consumption, and overall decision-making.
+    """
+    )
+
+    st.info(f"Click on the button below to start the tutorial!")
+
+    if st.button("I am Ready!"):
+        complete_level(LEVEL)
+
+render_page(intro_page, LEVEL)

README.md

@@ -5,7 +5,7 @@ colorFrom: indigo
 colorTo: blue
 sdk: streamlit
 sdk_version: 1.21.0
-app_file: app.py
+app_file: 0_Introduction.py
 pinned: false
 license: openrail
 ---

assets/quiz.json

@@ -0,0 +1,92 @@
+[
+    {
+        "question": "Which of the following best describes emotion detection?",
+        "options": [
+            "Teaching computers to understand human emotions",
+            "Teaching humans to understand computer languages",
+            "Teaching computers to create video games",
+            "Teaching humans to recognize facial features"
+        ],
+        "answer": "Teaching computers to understand human emotions"
+    },
+    {
+        "question": "What programming language is commonly used in developing emotion detection applications?",
+        "options": [
+            "Python",
+            "Java",
+            "C++",
+            "Ruby"
+        ],
+        "answer": "Python"
+    },
+    {
+        "question": "What is the purpose of OpenCV in an emotion detection application?",
+        "options": [
+            "To analyze and manipulate images and videos",
+            "To recognize and understand human emotions",
+            "To create graphical user interfaces",
+            "To generate statistical reports"
+        ],
+        "answer": "To analyze and manipulate images and videos"
+    },
+    {
+        "question": "Why is it important to have a diverse dataset when training an emotion detection model?",
+        "options": [
+            "It helps the model better understand different facial expressions",
+            "It improves the performance of the computer's processor",
+            "It makes the application run faster",
+            "It reduces the training time for the model"
+        ],
+        "answer": "It helps the model better understand different facial expressions"
+    },
+    {
+        "question": "What is the final step after training the model in an emotion detection application?",
+        "options": [
+            "Collect more data for training",
+            "Test the model's accuracy and performance",
+            "Install additional software plugins",
+            "Optimize the application's user interface"
+        ],
+        "answer": "Test the model's accuracy and performance"
+    },
+    {
+        "question": "How does the inference process work in an emotion detection application?",
+        "options": [
+            "It analyzes facial features and predicts the associated emotion",
+            "It collects user feedback and improves the model's accuracy",
+            "It converts emotions into numerical values for analysis",
+            "It adjusts the application's settings based on user preferences"
+        ],
+        "answer": "It analyzes facial features and predicts the associated emotion"
+    },
+    {
+        "question": "What is an example of a real-world application of emotion detection technology?",
+        "options": [
+            "Virtual reality gaming",
+            "Weather forecasting",
+            "Online shopping",
+            "Recipe suggestions"
+        ],
+        "answer": "Virtual reality gaming"
+    },
+    {
+        "question": "What is the importance of ethical considerations in emotion detection applications?",
+        "options": [
+            "Ensuring privacy and consent when collecting data",
+            "Optimizing the application's performance",
+            "Reducing the complexity of the model",
+            "Enhancing the visual appearance of the application"
+        ],
+        "answer": "Ensuring privacy and consent when collecting data"
+    },
+    {
+        "question": "What can students do to further explore and improve their emotion detection application?",
+        "options": [
+            "Experiment with different image preprocessing techniques",
+            "Rewrite the entire code from scratch",
+            "Avoid using real-time video feeds for testing",
+            "Skip the testing phase and move directly to deployment"
+        ],
+        "answer": "Experiment with different image preprocessing techniques"
+    }
+]

pages/1_Weather Forecasting and It's Applications.py

@@ -0,0 +1,58 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+LEVEL = 1
+
+initialize_level()
+
+def step1_page():
+    st.header("Weather Forecasting and It's Applications")
+    st.markdown(
+    """
+    ### What is weather forecasting?
+    Weather forecasting is an application of science and advanced technology that is used to predict the atmospheric condition 
+    for an upcoming point of time and a given location. 
+
+    Our day to day life is directly or indirectly depends on the weather in terms of economy and environment, 
+    it affects us with various factors as events, timing, duration, location, etc. In consideration of these factors, 
+    weather forecasting works with the parameters temperature, humidity, and wind speed. 
+    
+    ### Applications of weather forecasting
+    Weather forecasting has numerous real-world applications across various industries and sectors. 
+    Its impact extends beyond personal planning and extends to critical decision-making processes in sectors that heavily rely on weather conditions. 
+    Here are some key applications of weather forecasting in the real world:
+    
+    1. **Aviation Industry**: Weather forecasting plays a vital role in aviation, enabling pilots and airlines to plan safe flight routes, avoid turbulence, and make decisions regarding takeoff, landing, and flight diversions based on current and predicted weather conditions.
+
+    2. **Agriculture and Farming**: Farmers use weather forecasts to optimize irrigation schedules, plan planting and harvesting activities, and protect crops from adverse weather conditions, such as frost, drought, or excessive rainfall.
+
+    3. **Energy and Utilities**: Weather forecasts are crucial for energy and utility companies to anticipate electricity demand, especially for renewable energy sources like solar and wind power, which are highly dependent on weather patterns.
+
+    4. **Transportation and Logistics**: Weather forecasts help transportation and logistics companies plan routes, manage schedules, and anticipate potential disruptions due to adverse weather conditions, ensuring efficient and reliable services.
+
+    5. **Disaster Management and Emergency Response**: Accurate weather predictions aid disaster management agencies in preparing for and responding to natural disasters like hurricanes, floods, and wildfires. It allows for timely evacuations and resource allocation to mitigate the impact of extreme weather events.
+
+    6. **Tourism and Hospitality**: The tourism industry relies on weather forecasts to manage tourist activities, plan outdoor events, and optimize resource allocation for hotels and resorts based on expected weather conditions.
+
+    7. **Construction Industry**: Weather forecasts are essential for construction companies to plan construction schedules, especially for outdoor projects that are susceptible to weather-related delays and safety risks.
+
+    8. **Retail and Sales**: Weather predictions impact consumer behavior, influencing purchases of seasonal items like clothing, outdoor equipment, and home appliances.
+
+    9. **Public Health**: Weather forecasts help public health agencies anticipate and prepare for weather-related health risks, such as heatwaves, air pollution, and disease outbreaks.
+
+    10. **Environmental Monitoring**: Weather forecasting is essential for monitoring and understanding weather-related environmental changes, including climate trends, sea-level rise, and extreme weather occurrences.
+
+    11. **Sports and Events**: Weather forecasts play a significant role in organizing outdoor sports events, concerts, and festivals, ensuring the safety and comfort of participants and attendees.
+
+    12. **Media and News Reporting**: Weather forecasts are frequently featured in media to keep the public informed about upcoming weather conditions and potential weather-related impacts.
+
+    Throughout the tutorial, you will learn how weather forecasting works and will have the opportunity to implement a robust weather forecasting application by yourself!. 
+    Step by step, we will guide you through the process, ensuring that you gain a deep understanding of each concept and its practical implementation.
+    """
+    )
+
+    st.info("Click on the button below to continue!")
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+render_page(step1_page, LEVEL)

pages/2_Technology Behind It.py

@@ -0,0 +1,52 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+
+initialize_level()
+
+LEVEL = 2
+
+def step2_page():
+    st.header("Technology Behind It")
+    st.markdown(
+    """
+    ### How machine learning is used for accurate weather forecasting?
+    Traditional numerical weather prediction models have been the cornerstone of meteorology for decades, relying on 
+    complex physical equations and extensive observational data. 
+    
+    However, the rise of machine learning has brought a paradigm shift to weather forecasting, unlocking new possibilities and enhanced accuracy in predicting atmospheric phenomena. 
+    Machine learning techniques leverage the power of algorithms to identify patterns and relationships within vast and complex weather datasets. 
+    By learning from historical weather data, machine learning models can capture hidden patterns and non-linear relationships that might be 
+    challenging to represent using traditional methods. This empowers meteorologists and researchers to create highly sophisticated and 
+    precise forecasting models that can make predictions for various temporal scales, from short-term weather conditions to long-term climate trends.
+
+    Here's how it works:
+    1. **Data Collection**: The first step is to collect large amounts of historical weather data, which includes various atmospheric parameters like temperature, humidity, wind speed, pressure, solar irradiance, and more. This data is typically obtained from weather stations, satellites, radars, and other sources.
+
+    2. **Data Preprocessing**: The collected data needs to be preprocessed to handle missing values, outliers, and inconsistencies. It may involve data cleaning, imputation, and scaling to ensure that the data is suitable for training machine learning models.
+    
+    3. **Feature Engineering:**: In weather forecasting, relevant features play a crucial role in accurate predictions. Engineers and meteorologists work together to extract meaningful features from the raw data, which could include time-based features (e.g., day of the week, month), lagged values (to capture temporal dependencies), geographic features (latitude, longitude), and more.
+    
+    4. **Data Splitting**: The preprocessed data is split into training and testing sets. The training set is used to train the machine learning model, and the testing set is used to evaluate its performance.
+    
+    5. **Model Selection**:  Different machine learning algorithms can be used for weather forecasting, such as regression models (e.g., linear regression), time series models (e.g., ARIMA, SARIMA), and more advanced models like decision trees, random forests, gradient boosting, and neural networks. The choice of model depends on the characteristics of the data and the forecasting task.
+    
+    6. **Model Training**: The selected machine learning model is trained on the training data. During training, the model learns from the historical data and tries to capture patterns and relationships between the input features (e.g., temperature, humidity) and the target variable (e.g., future temperature).
+    
+    7. **Model Evaluation**: After training, the model's performance is evaluated using the testing data. Common evaluation metrics for weather forecasting include mean absolute error (MAE), mean squared error (MSE), root mean squared error (RMSE), and correlation coefficients.
+    
+    8. **Forecasting**: Once the model is trained and evaluated, it can be used to make predictions for future weather conditions based on new input data. For example, given current weather conditions and historical data, the model can forecast the weather for the next few hours or days.
+    
+    9. **Updating and Re-training**: Weather data is constantly changing, so the forecasting model needs to be updated regularly with new data. Periodic re-training of the model ensures that it stays up-to-date and continues to make accurate predictions.
+    
+    """
+    )
+
+    st.image(
+        "https://miro.medium.com/v2/resize:fit:720/format:webp/1*mRpdRbCta8VWlTrx12WNOQ.jpeg",
+        use_column_width=True,
+    )
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+render_page(step2_page, LEVEL)

pages/3_Training the Model.py

@@ -0,0 +1,192 @@
+import time
+from utils.levels import complete_level, render_page, initialize_level
+from utils.login import get_login, initialize_login
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import r2_score
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import RandomizedSearchCV
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import RendererAgg
+_lock = RendererAgg.lock
+import base64
+from io import BytesIO
+from PIL import Image, ImageFilter
+import lightgbm as lgb
+
+initialize_login()
+initialize_level()
+
+LEVEL = 3
+
+File_PATH = 'datasets/Building_forcasting.csv'
+
+def process_file(csv_file):
+    data = pd.read_csv(csv_file, index_col='Timestamp')
+    data.index = pd.to_datetime(data.index)
+    data = data.fillna(0)
+    return data
+
+
+def model_predict(data, model_choice, train_size, tune_model):
+    if model_choice == 'LightGBM':
+        model = lgb.LGBMRegressor() if not tune_model else lgb.LGBMRegressor(**tuned_parameters('lgbm'))
+    elif model_choice == 'Random Forest':
+        model = RandomForestRegressor(n_estimators=100, random_state=42) if not tune_model else RandomForestRegressor(**tuned_parameters('rf'))
+
+    X, y = create_model_inputs(data, 288, 288)
+
+    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=train_size/100, random_state=42, shuffle=False)
+
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+
+    return y_test, y_pred, model
+
+
+def create_model_inputs(data, lag, mean_period):
+    df_processed = data.copy()
+    df_processed['PV_Output_lag'] = df_processed['PV_Output'].shift(lag)
+    df_processed['PV_Output_mean'] = df_processed['PV_Output'].rolling(window=mean_period).mean()
+
+    X = df_processed[['Solar_Irradiance', 'Temperature', 'Rain_Fall', 'Wind_speed', 'PV_Output_lag', 'PV_Output_mean']].dropna()
+    y = df_processed[['PV_Output']].loc[X.index]
+
+    return X, y
+
+
+def show_output(y_test, y_pred):
+    st.sidebar.subheader("Model Performance")
+    st.sidebar.write(f"Test R2 score: {r2_score(y_test, y_pred):.2f}")
+
+    fig, axs = plt.subplots(3, figsize=(12, 18))
+    axs[0].plot(y_test.index, y_pred/1000, label='Predicted')
+    axs[0].plot(y_test.index, y_test['PV_Output']/1000, label='Actual')
+    axs[0].legend()
+    axs[0].set_title('Prediction vs Actual (Solar Power Generation)')
+    axs[0].set_xlabel('Date')
+    axs[0].set_ylabel('Solar Power Generation (kW)')
+
+    axs[1].plot(y_test.index, y_pred/1000, label='Predicted')
+    axs[1].set_title('Predicted Solar Power Generation')
+    axs[1].set_xlabel('Date')
+    axs[1].set_ylabel('Solar Power Generation (kW)')
+
+    axs[2].plot(y_test.index, y_test['PV_Output']/1000, label='Actual')
+    axs[2].set_title('Actual Solar Power Generation')
+    axs[2].set_xlabel('Date')
+    axs[2].set_ylabel('Solar Power Generation (kW)')
+
+    fig.tight_layout()
+    with _lock:
+        st.pyplot(fig)
+
+    return fig
+
+
+def download_link(y_test, y_pred):
+    y_pred_df = pd.DataFrame({'Timestamp': y_test.index, 'Predicted_Power': y_pred, 'Actual_Total_Power_(kW)': y_test['PV_Output']})
+    csv = y_pred_df.to_csv(index=False)
+    b64 = base64.b64encode(csv.encode()).decode()
+    href = f'<a href="data:file/csv;base64,{b64}" download="Predicted_Solar_Power.csv">Download Predicted Power CSV File</a>'
+    st.sidebar.markdown(href, unsafe_allow_html=True)
+
+
+def feature_importance_plot(model, feature_names):
+    # Get feature importances
+    importance = model.feature_importances_
+    # Normalize by the sum of all importances
+    importance = 100.0 * (importance / importance.sum())
+    plt.figure(figsize=(10, 6))
+    plt.bar(feature_names, importance)
+    plt.title('Feature Importance')
+    plt.xlabel('Features')
+    plt.ylabel('Importance (%)')
+    return plt.gcf()
+
+
+def download_plot(fig):
+    tmpfile = BytesIO()
+    fig.savefig(tmpfile, format='png')
+    encoded = base64.b64encode(tmpfile.getvalue()).decode('utf-8')
+
+    href = f'<a href="data:image/png;base64,{encoded}" download="plot.png">Download Result Plot</a>'
+    st.sidebar.markdown(href, unsafe_allow_html=True)
+
+
+def tuned_parameters(model):
+    if model == 'lgbm':
+        params = {
+            'num_leaves': [10, 20, 30, 40, 50],
+            'max_depth': [-1, 3, 5, 10],
+            'learning_rate': [0.01, 0.05, 0.1],
+            'n_estimators': [100, 500, 1000]
+        }
+        return params
+
+    elif model == 'rf':
+        params = {
+            'n_estimators': [10, 100, 500, 1000],
+            'max_depth': [None, 10, 20, 30, 40, 50],
+            'min_samples_split': [2, 5, 10],
+            'min_samples_leaf': [1, 2, 4]
+        }
+        return params
+
+def step3_page():
+    st.header("Training the Model")
+    st.subheader("Exploring the data")
+    st.title("Solar Forecasting App")
+
+    # Display the image and information in a grid layout
+    col1 = st.columns([1])
+
+    with col1[0]:
+        data = {
+            'Timestamp': ['11/1/2022 0:20', '11/1/2022 0:25'],
+            'Total_Power (kW)': [37337, 44590],
+            'PV_Output': [296.6, 298.4],
+            'Solar_Irradiance': [0, 0],
+            'Temperature': [25.1, 24.7],
+            'Rain_Fall': [42.6, 42.6],
+            'Wind_Speed': [0.6, 0.4]
+        }
+        df = pd.DataFrame(data)
+        st.subheader("Example of CSV file DataFrame")
+        st.table(df)
+
+    csv_file = st.sidebar.file_uploader("Upload CSV", type=['csv'])
+
+    if csv_file is not None:
+        data = process_file(csv_file)
+
+        train_size = st.sidebar.slider("Select Train Dataset Size (%)", min_value=10, max_value=90, value=70)
+
+        models = ['LightGBM', 'Random Forest']
+        model_choice = st.sidebar.selectbox('Choose Model', models)
+
+        tune_model = st.sidebar.checkbox('Tune Hyperparameters')
+
+        y_test, y_pred, model = model_predict(data, model_choice, train_size, tune_model)
+
+        # Display feature importance
+        if st.sidebar.checkbox('Show feature importance'):
+            feature_names = ['Solar_Irradiance', 'Temperature', 'Rain_Fall', 'Wind_speed', 'PV_Output_lag',
+                             'PV_Output_mean']
+            fig = feature_importance_plot(model, feature_names)
+            with _lock:
+                st.pyplot(fig)
+
+        fig = show_output(y_test, y_pred)
+
+        download_link(y_test, y_pred)
+
+        download_plot(fig)
+
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+
+render_page(step3_page, LEVEL)

pages/4_Congratulations.py

@@ -0,0 +1,14 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+
+initialize_level()
+
+LEVEL = 4
+
+def step1_page():
+    st.header("Congratulations!")
+    st.subheader("You have completed the tutorial!")
+    st.write("You can now use this template to create your own tutorial.")
+    st.balloons()
+
+render_page(step1_page, LEVEL)

pages/4_Quiz.py

@@ -0,0 +1,51 @@
+import streamlit as st
+from utils.levels import complete_level, render_page, initialize_level
+from utils.login import initialize_login
+import random
+import json
+
+LEVEL = 3
+
+initialize_login()
+initialize_level()
+
+
+if "questions" not in st.session_state:
+    with open("assets/quiz.json") as f:
+        questions = json.load(f)
+
+    for i in range(len(questions)):
+        random.shuffle(questions[i]["options"])
+    random.shuffle(questions)
+
+    st.session_state["questions"] = questions
+
+
+def step_page():
+    st.header("Quiz")
+    st.markdown(
+        """Now that you've learned about how Face Recognition work, let's test your knowledge with a quiz!"""
+    )
+
+    for i in range(len(st.session_state["questions"])):
+        st.subheader(f"Question {i + 1}")
+        question = st.session_state["questions"][i]
+        st.markdown(question["question"])
+        answer = st.radio("Select an answer:", question["options"], key=f"radio{i}")
+
+        if st.session_state.get("EVALUATE", False):
+            if answer == question["answer"]:
+                st.success("Correct!")
+            else:
+                st.error("Incorrect! Try Again")
+
+    if st.button("Evaluate"):
+        st.session_state["EVALUATE"] = True
+        st.experimental_rerun()
+
+    st.info("Click on the button below to complete the tutorial!")
+    if st.button("Complete"):
+        complete_level(LEVEL)
+
+
+render_page(step_page, LEVEL)

requirements.txt

@@ -0,0 +1,6 @@
+firebase_admin
+scikit-learn
+lightgbm
+matplotlib
+streamlit-pandas-profiling
+pyngrok

utils/levels.py

@@ -0,0 +1,36 @@
+import streamlit as st
+from utils.login import get_login
+import os
+
+def initialize_level():
+    if 'level' not in st.session_state:
+        if get_login()["status"]:
+            if not os.path.exists(f".sessions/{get_login()['username']}/level.txt"):
+                with open(f".sessions/{get_login()['username']}/level.txt", "w") as f:
+                    f.write("0")
+                st.session_state['level'] = 0
+            else:
+                with open(f".sessions/{get_login()['username']}/level.txt", "r") as f:
+                    st.session_state['level'] = int(f.read())
+
+def get_level():
+    return st.session_state['level']
+
+def render_page(page, level):
+    if get_login()["status"]:
+        if st.session_state['level'] < level:
+            st.error(f"You need to complete Level {st.session_state['level']} first!")
+        else:
+            page()
+    else:
+        st.error("You need to login first!")
+
+def complete_level(level):
+    if st.session_state['level'] > level:
+        st.info(f'You have Already completed Level {level}!')
+    else:
+        st.session_state['level'] = level + 1
+        with open(f".sessions/{get_login()['username']}/level.txt", "w") as f:
+            f.write(str(st.session_state['level']))
+        st.balloons()
+        st.success(f'You have completed Level {level}! You can now move on to the next level.')

utils/login.py

@@ -0,0 +1,59 @@
+import streamlit as st
+import os
+import requests
+import os
+import json
+
+# Fetch the service account key JSON file contents
+
+
+def initialize_login():
+    if "login" not in st.session_state:
+        st.columns(3)[1].image("assets/logo.png")
+        username = st.text_input("Username")
+        password = st.text_input("Password", type="password")
+
+        if st.button("Login"):
+            authorized = authenticate(username, password)
+            if authorized["status"]:
+                st.session_state["login"] = authorized
+                os.makedirs(
+                    os.path.join(".sessions", st.session_state["login"]["username"]),
+                    exist_ok=True,
+                )
+                st.success("Login Successful!")
+                st.experimental_rerun()
+            else:
+                st.error("Invalid username or password")
+    else:
+        st.sidebar.success(f'Hello, {st.session_state["login"]["Name"]}!')
+
+
+def authenticate(username, password):
+    FIREBASE_WEB_API_KEY = os.environ.get("FIREBASE_WEB_API_KEY")
+    payload = json.dumps(
+        {
+            "email": f"{username}@aieye.com",
+            "password": password,
+            "returnSecureToken": False,
+        }
+    )
+
+    rest_api_url = (
+        f"https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword"
+    )
+    r = requests.post(rest_api_url, params={"key": FIREBASE_WEB_API_KEY}, data=payload)
+    print(r.json())
+
+    if r.status_code == 200:
+        return {
+            "status": True,
+            "Name": " ".join(username.split("_")),
+            "username": username,
+        }
+    else:
+        return {"status": False}
+
+
+def get_login():
+    return st.session_state.get("login", {"status": False})