SNET Onboarding Setup

pag/monitor.py

@@ -321,24 +321,56 @@ def monitor_fields():
     if field_name != "Select Field":
         st.title(":orange[Field Health Forecast]")
         st.write(f"Press the button below to predict {metric} for the next 30 weeks")
-        if 'api_token_confirmed' not in st.session_state:
+        # Reset session state if any of the required keys are missing
+        required_keys = ['api_token', 'api_token_confirmed', 'valid_until']
+        if any(key not in st.session_state for key in required_keys):
             st.session_state['api_token'] = ''
             st.session_state['api_token_confirmed'] = False
+            st.session_state['valid_until'] = ''
+
         if not st.session_state['api_token_confirmed']:
             st.warning("No Valid API Token Found")
-            st.info("You can get the API Token from the Service Page on the SNET Platform (link to the service page)")
-            st.info("For Testing purposes, you can use: TEST_TOKEN")
+            with st.expander("Need a new API Token?", expanded=True):
+                st.markdown(utils.NEW_TOKEN_INSTRUCTIONS, unsafe_allow_html=True)
+            with st.expander("Token Usage history", expanded=False):
+                filename = f'{current_user}_tokens.csv'
+                if os.path.exists(filename):
+                    token_usage = pd.read_csv(filename)
+                    token_usage['is_expired'] = token_usage['valid_until'].apply(lambda x: 'Yes' if datetime.strptime(x, '%Y-%m-%d %H:%M:%S') < datetime.now() else 'No')
+                    st.write(token_usage)
+                else:
+                    st.write("No Token Usage History Found")
             api_token = st.text_input("API Token", key="api_token_input", help="Enter the API Token From SNET")
             if st.button("submit API Token", key="confirm_api_token"):
-                if utils.confirm_api_token(api_token):
+                if utils.confirm_api_token(api_token)['valid']:
                     st.session_state['api_token'] = api_token
                     st.session_state['api_token_confirmed'] = True
                     st.session_state['valid_until'] = utils.load_token_expiration(api_token).strftime('%Y-%m-%d %H:%M:%S')
                     st.rerun()
                 else:
-                    st.error("Invalid API Token")
+                    st.error(f"Invalid API Token; {utils.confirm_api_token(api_token)['message']}")
         else:
-            st.success(f"API Token Confirmed valid until {st.session_state['valid_until']}")
+            now = datetime.now()
+            valid_until = datetime.strptime(st.session_state['valid_until'], '%Y-%m-%d %H:%M:%S')
+            time_remaining = valid_until - now
+            minutes_remaining = int(time_remaining.total_seconds() // 60)
+            seconds_remaining = int(time_remaining.total_seconds() % 60)
+            time_left_column, clear_token_column = st.columns([1,1])
+            with time_left_column:
+                st.success(f"API Token Confirmed. Token valid for {minutes_remaining} minutes and {seconds_remaining} seconds")
+            with clear_token_column:
+                if st.button("Clear API Token", key="clear_api_token"):
+                    st.session_state['api_token'] = ''
+                    st.session_state['api_token_confirmed'] = False
+                    st.session_state['valid_until'] = ''
+                    st.rerun()
+            with st.expander("Need a new API Token?", expanded=False):
+                st.markdown(utils.NEW_TOKEN_INSTRUCTIONS, unsafe_allow_html=True)
+            with st.expander("Token Usage history", expanded=False):
+                token_usage = utils.manage_user_tokens(current_user, st.session_state['api_token'], valid_until.strftime('%Y-%m-%d %H:%M:%S'))
+                token_usage['is_expired'] = token_usage['valid_until'].apply(lambda x: 'Yes' if datetime.strptime(x, '%Y-%m-%d %H:%M:%S') < datetime.now() else 'No')
+                st.write(token_usage)
+
         lookback_days = st.slider("Select Lookback Days", 10, 360, 30, step=10,key="lookback_days", help="Large lookback days may take longer to load")
         subcol1, subcol2, subcol3 = st.columns(3)
  

tokens_expired.txt

@@ -1,6 +0,0 @@
-9mfg7acflhkbif70bnrn2lq3ult5t7l5,2024-07-26T20:38:48.882401
-3swbgq8p1x6wo4kt8vn9apus3y1trlii,2024-07-26T20:08:55.102588
-9mfg7acflhkbif70bnrn2lq3ult5t7l5,2024-07-26T20:09:19.569408
-9mfg7acflhkbif70bnrn2lq3ult5t7l5,2024-07-26T19:39:42.164519
-kfpo6khkcuirmkshjufdob6k1dn9a2oo,2025-07-26T20:45:07.000759
-TEST_TOKEN,2025-07-26T20:45:07.000759

utils.py

@@ -15,10 +15,62 @@ import random
 import string
 import os
 from datetime import datetime, timedelta
-import streamlit as st
 
 TOKEN_FILE = "tokens.txt"
 EXPIRED_FILE = "tokens_expired.txt"
+NEW_TOKEN_INSTRUCTIONS="""<div style="background-color: #e6f2ff; padding: 20px; border-radius: 5px;">
+<h3 style="color: #4CAF50;">Get Your SNET API Token</h3>
+
+<p style="color: #666; font-size: 16px;">
+    To get an API token for the SNET platform:
+    <ol>
+    <li>Purchase tokens on the SNET platform using AGIX</li>
+    <li> <del> Input the email address you used to sign up for the dashboard </del>.  Any text will work for testing purposes</li>
+    <li>An API token will be generated for you</li>
+    </ol>
+    
+    The generated token will be valid for unlimited calls to the forecasting API for 15 minutes from your first call, for any of your fields.
+</p>
+
+<p style="color: #666; font-size: 16px;">
+    You can find us on the SNET platform at: 
+    <a href="https://beta.singularitynet.io/servicedetails/org/EnigmaAi/service/farmingID" style="color: #007bff; text-decoration: none;">SNET Platform</a>
+</p>
+</div>
+"""
+
+import pandas as pd
+import os
+
+def manage_user_tokens(current_user, api_token, valid_until):
+    """
+    Manages the storage and retrieval of user API tokens.
+
+    Args:
+        current_user (str): The username of the currently logged-in user.
+        api_token (str): The API token to be stored.
+        valid_until (str): The expiration date of the API token (in 'YYYY-MM-DD HH:MM:SS' format).
+
+    Returns:
+        None
+    """
+    filename = f'{current_user}_tokens.csv'
+    # Check if the file exists
+    if not os.path.exists(filename):
+        # Create a new DataFrame and save it to the file
+        df = pd.DataFrame({'token': [api_token], 'valid_until': [valid_until]})
+        df.to_csv(filename, index=False)
+    else:
+        # Load the existing DataFrame
+        df = pd.read_csv(filename)
+        # Check if the token already exists in the DataFrame
+        if api_token not in df['token'].values:
+            # Append the new token and valid_until to the DataFrame
+            new_row = {'token': api_token, 'valid_until': valid_until}
+            new_row_df = pd.DataFrame(new_row, index=[0])
+            df = pd.concat([df, new_row_df], ignore_index=True)
+            df.to_csv(filename, index=False)
+    return df
 
 def generate_random_unique_tokens(num_tokens=10, token_file=TOKEN_FILE):
     '''Generates a list of random unique tokens and saves them to a file.'''
@@ -43,18 +95,25 @@ def generate_random_unique_tokens(num_tokens=10, token_file=TOKEN_FILE):
 
 def confirm_api_token(token, token_file=TOKEN_FILE, expired_file=EXPIRED_FILE):
     '''Checks if the given token is valid and not expired.'''
+    print(f'Checking token: {token} >>>>>>>>>>>>>>>>>>>')
+    msg = 'Token is valid'
     with open(token_file, 'r') as f:
-        tokens = set(f.read().splitlines())
-    if token in tokens:
+        tokens = set(f.read().splitlines()) # Load All possible tokens
+    if token in tokens: # Check if the token is one of the possible tokens
         now = datetime.now()
-        if token in load_expired_tokens(expired_file):
-            if now < load_token_expiration(token, expired_file):
-                return True
+        if token in load_expired_tokens(expired_file): # Check if the token have been used before
+            if now < load_token_expiration(token, expired_file): # Check if the token has been expired
+                return {'valid': True, 'message': msg}
+            else: # If the token has been expired, return invalid
+                msg = 'Token has expired'
+                return {'valid': False, 'message': msg}
         else:
-            expiry_date = now + timedelta(hours=1)
-            save_expired_token(token, expiry_date, expired_file)
-            return True
-    return False
+            msg = 'Token is valid'
+            expiry_date = now + timedelta(minutes=15)
+            save_expired_token(token, expiry_date, expired_file) # If the token is valid and have not been used before, set the expiration date to 15 minutes
+            return {'valid': True, 'message': msg}
+    msg = 'Token is invalid'
+    return {'valid': False, 'message': msg}
 
 def load_expired_tokens(expired_file=EXPIRED_FILE):
     '''Loads expired tokens from the file.'''
@@ -63,8 +122,8 @@ def load_expired_tokens(expired_file=EXPIRED_FILE):
         with open(expired_file, 'r') as f:
             for line in f:
                 print(line)
-                st.write(line)
-                st.write(line.strip().split(','))
+                print(line.strip().split(','))
+                print('------------')
                 token, expiry_date = line.strip().split(',')
                 expired_tokens[token] = datetime.fromisoformat(expiry_date)
     return expired_tokens