Milestone 1

history_asim.csv

@@ -0,0 +1,3 @@
+field_name,start_date,end_date,crop,irrigation_method
+square_one,2024-05-01,2024-07-26,Wheat,Rainfed
+uk_farm,2024-08-01,2024-10-31,Corn,Irrigated

pag/monitor.py

@@ -32,12 +32,16 @@ def check_authentication():
 
 
 config = SHConfig()
-config.instance_id       = '352670fb-2edf-4abd-90c8-437485a2403e'
-config.sh_client_id      = 'ca95f10f-443c-4c60-9a36-98950292bb9b'
-config.sh_client_secret  = 'rNFGRxGNiNFrXJfGyHIkVRyGOrdWNsfI'
+config.instance_id       = '44e79764-8b9d-43b0-a4bf-15799db2899d'
+config.sh_client_id      = '4ae34b53-3f81-4ba0-9c7d-b6fb0606dac3'
+config.sh_client_secret  = '3IPSSqE75fqK38vP85hxttR9PJEs5OxX'
 config.sh_timesfm_IP = "34.121.141.161"
-OpenAI_key = os.getenv('OPENAI_KEY')
-client = OpenAI(api_key= OpenAI_key)
+try:
+    OpenAI_key = os.getenv('OPENAI_KEY')
+    client = OpenAI(api_key= OpenAI_key)
+except:
+    OpenAI_key = "sk-"
+    client = OpenAI(api_key= OpenAI_key)
 
 def select_field(gdf):
     st.markdown("""
@@ -137,7 +141,7 @@ def download_date_data(df, field, dates, metric, clientName,):
 
 
 def track(metric, field_name, src_df, client_name):
-    st.title(":green[Select Date and Start Monitoring]")
+    st.subheader(":green[Select Date and Start Monitoring]")
     dates = []
     date = -1
     if 'dates' not in st.session_state:
@@ -170,9 +174,10 @@ def track(metric, field_name, src_df, client_name):
             .stSelectbox > div > div {cursor: pointer;}
             </style>
             """, unsafe_allow_html=True)
+        dates.append(-1)
         date = st.selectbox('Select Observation Date: ', dates, index=len(dates)-1, key=f'Select Date Dropdown Menu - {metric}')
         if date != -1:
-            st.success(f'You selected: {date}')
+            st.write(f'You selected: {date}')
             #Add the date to the session state
             st.session_state['date'] = date
         else:
@@ -182,7 +187,7 @@ def track(metric, field_name, src_df, client_name):
 
 
     st.markdown('---')
-    st.header('Show Field Data')
+    st.subheader('Show Field Data')
 
     # If a field and a date are selected, display the field data
     if date != -1:   
@@ -232,9 +237,10 @@ def track(metric, field_name, src_df, client_name):
         )
 
         # Add the base map
-        token = open("token.mapbox_token").read()
-        fig.update_layout(mapbox_style="satellite", mapbox_accesstoken=token)
-        st.plotly_chart(fig)
+        with st.expander("Show Map", expanded=False):
+            token = open("token.mapbox_token").read()
+            fig.update_layout(mapbox_style="satellite", mapbox_accesstoken=token)
+            st.plotly_chart(fig, use_container_width=True)
 
         #Dwonload Links
 
@@ -287,10 +293,9 @@ def track(metric, field_name, src_df, client_name):
            
 
 def monitor_fields():
+    st.title(":orange[Field Monitoring]")
     row1,row2 = st.columns([1,2])
     with row1:
-        st.title(":orange[Field Monitoring]")
-
         current_user = greeting("Let's take a look how these fields are doing")
         if os.path.exists(f"fields_{current_user}.parquet"):
             gdf = gpd.read_parquet(f"fields_{current_user}.parquet")
@@ -299,125 +304,173 @@ def monitor_fields():
                 st.info("No Field Selected Yet!")  
             else:
                 metric = st.radio("Select Metric to Monitor", ["NDVI", "LAI", "CAB"], key="metric", index=0, help="Select the metric to monitor")
-                st.success(f"Monitoring {metric} for {field_name}")
+                st.write(f"Monitoring {metric} for {field_name}")
                 with st.expander("Metrics Explanation", expanded=False):
                     st.write("NDVI: Normalized Difference Vegetation Index, Mainly used to monitor the health of vegetation")
                     st.write("LAI: Leaf Area Index, Mainly used to monitor the productivity of vegetation")
                     st.write("CAB: Chlorophyll Absorption in the Blue band, Mainly used to monitor the chlorophyll content in vegetation")
                     # st.write("NDMI: Normalized Difference Moisture Index, Mainly used to monitor the moisture content in vegetation")
-                st.info("More metrics and analysis features will be added soon")
+ 
         else:
             st.info("No Fields Added Yet!")
             return
-        
+    with row2:
         if field_name != "Select Field":
-            st.title(":orange[Predict Metrics for Next Month]")
-            st.write(f"Press the button below to predict {metric} for the next 30 weeks")
-            subcol1, subcol2, subcol3 = st.columns(3)
-            if subcol2.button(f'Predict & Recommend'):
-                
-                start_date = '2024-01-01'
-                today = datetime.today()
-                end_date = today.strftime('%Y-%m-%d')
-                year = '2024'
-
-                dates = get_and_cache_available_dates(gdf, field_name, year, start_date, end_date)
-                my_bar = st.progress(0, text= f"Downloading Data for the last {len(dates)//6} months ...")
-                counter = 0
-                downloaded_prev_metrics = []
-                for index, date in enumerate(dates):
-                    # time.sleep(0.1)
-                    metric_data = get_cuarted_df_for_field(gdf, field_name, date, metric, current_user, dates = None)
-                    cloud_cover_data = get_cuarted_df_for_field(gdf, field_name, date, 'CLP', current_user, dates = None)
-                    field_data = metric_data.merge(cloud_cover_data, on='geometry')
-                    avg_metric = field_data[f'{metric}_{date}'].mean() 
-                    downloaded_prev_metrics.append((date, avg_metric))
-                    counter = counter + 100/(len(dates))
-                    my_bar.progress(round(counter), text=f"Downloading Data for the last {len(dates)//6} months: {round(counter)}%")
-
-                st.subheader('Predictions:')
-                # chart_data = pd.DataFrame(
-                # {
-                #     "date": [metric[0] for metric in downloaded_prev_metrics],
-                #     f"{metric}": [metric[1] for metric in downloaded_prev_metrics],
-                # }
-                # )
-
-                # st.area_chart(chart_data, x="date", y=f"{metric}")
-                channel = grpc.insecure_channel(f"{config.sh_timesfm_IP}:50051")
-                print("runing client request")
-                stub = pb.timesfm_pb2_grpc.PredictAgriStub(channel)
-                features = stub.predict_metric(iter([pb.timesfm_pb2.prev_values(value=metric[1], date=metric[0]) for metric in downloaded_prev_metrics]))
-                print("server streaming:")
-                predictions = []
-                for feature in features:
-                    predictions.append(feature.value)
-                # do something with the returned output
-                # print(predictions)
-                future_dates = []
-                # print(dates[0])
-                curr_date = datetime.today()
-                for pred in predictions:
-                    curr_date = curr_date + timedelta(days=7)
-                    future_dates.append(curr_date.strftime('%Y-%m-%d'))
-
-                prev_dates = [metric[0] for metric in downloaded_prev_metrics]
-                history_metric_data = [metric[1] for metric in downloaded_prev_metrics]
-                future_metric_data = predictions
-                interval_dates = prev_dates
-                interval_dates.extend(future_dates)
-                history_metric_data.extend([0 for i in range(len(predictions))])
-                masked_future_metric_data = [0 for i in range(len([metric[1] for metric in downloaded_prev_metrics]))]
-                masked_future_metric_data.extend(future_metric_data)
-                # print(f"interval_dates:{len(interval_dates)}")
-                # print(f"history_metric_data:{len(history_metric_data)}")
-                # print(f"masked_future_metric_data:{len(masked_future_metric_data)}")
-                # print(predictions)
-            
-                # print(interval_dates)
-                prediction_chart_data = pd.DataFrame(
-                {
-                    f"history_{metric}_values": history_metric_data,
-                    f"predicted_{metric}_values":masked_future_metric_data,
-                    f"date": interval_dates,
-                }
-                )
-
-                # print(prediction_chart_data)
-
+            track(metric, field_name, gdf, current_user)
+
+    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:
+            st.session_state['api_token'] = ''
+            st.session_state['api_token_confirmed'] = False
+        if not st.session_state['api_token_confirmed']:
+            with st.empty():
+                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")
+            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):
+                    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")
+        else:
+            st.success(f"API Token Confirmed valid until {st.session_state['valid_until']}")
+        lookback_days = st.slider("Select Lookback Days", 30, 365, 60, step=30,key="lookback_days", help="Large lookback days may take longer to load")
+        subcol1, subcol2, subcol3 = st.columns(3)
+ 
+        if subcol2.button(f'Predict & Recommend', key="predict_button", disabled=not st.session_state['api_token_confirmed']):
+            # start_date = '2024-01-01'
+            today = datetime.today()
+            end_date = today.strftime('%Y-%m-%d')
+            start_date = today - timedelta(days=lookback_days)
+            start_date = start_date.strftime('%Y-%m-%d')
+            year = '2024'
+
+            dates = get_and_cache_available_dates(gdf, field_name, year, start_date, end_date)
+            newest_date, oldest_date = dates[0], dates[-1]
+            number_of_months = (datetime.strptime(newest_date, '%Y-%m-%d') - datetime.strptime(oldest_date, '%Y-%m-%d')).days//30
+            my_bar = st.progress(0, text= f"Downloading Data for the last {number_of_months+1} months ...")
+            counter = 0
+            downloaded_prev_metrics = []
+            for index, date in enumerate(dates):
+                # time.sleep(0.1)
+                metric_data = get_cuarted_df_for_field(gdf, field_name, date, metric, current_user, dates = None)
+                # cloud_cover_data = get_cuarted_df_for_field(gdf, field_name, date, 'CLP', current_user, dates = None)
+                # field_data = metric_data.merge(cloud_cover_data, on='geometry')
+                avg_metric = metric_data[f'{metric}_{date}'].mean() 
+                downloaded_prev_metrics.append((date, avg_metric))
+                counter = counter + 100/(len(dates))
+                my_bar.progress(round(counter), text=f"Downloading Data for the last {len(dates)//6} months: {round(counter)}%")
+
+            st.subheader('Predictions:')
+            # chart_data = pd.DataFrame(
+            # {
+            #     "date": [metric[0] for metric in downloaded_prev_metrics],
+            #     f"{metric}": [metric[1] for metric in downloaded_prev_metrics],
+            # }
+            # )
+
+            # st.area_chart(chart_data, x="date", y=f"{metric}")
+            channel = grpc.insecure_channel(f"{config.sh_timesfm_IP}:50051")
+            print("runing client request")
+            stub = pb.timesfm_pb2_grpc.PredictAgriStub(channel)
+            features = stub.predict_metric(iter([pb.timesfm_pb2.prev_values(value=metric[1], date=metric[0]) for metric in downloaded_prev_metrics]))
+            print("server streaming:")
+            predictions = []
+            for feature in features:
+                predictions.append(feature.value)
+            # do something with the returned output
+            # print(predictions)
+            future_dates = []
+            # print(dates[0])
+            curr_date = datetime.today()
+            for pred in predictions:
+                curr_date = curr_date + timedelta(days=7)
+                future_dates.append(curr_date.strftime('%Y-%m-%d'))
+
+            prev_dates = [metric[0] for metric in downloaded_prev_metrics]
+            history_metric_data = [metric[1] for metric in downloaded_prev_metrics]
+            future_metric_data = predictions
+            interval_dates = prev_dates
+            interval_dates.extend(future_dates)
+            history_metric_data.extend([0 for i in range(len(predictions))])
+            masked_future_metric_data = [0 for i in range(len([metric[1] for metric in downloaded_prev_metrics]))]
+            masked_future_metric_data.extend(future_metric_data)
+            # print(f"interval_dates:{len(interval_dates)}")
+            # print(f"history_metric_data:{len(history_metric_data)}")
+            # print(f"masked_future_metric_data:{len(masked_future_metric_data)}")
+            # print(predictions)
+        
+            # print(interval_dates)
+            prediction_chart_data = pd.DataFrame(
+            {
+                f"history_{metric}_values": history_metric_data,
+                f"predicted_{metric}_values":masked_future_metric_data,
+                f"date": interval_dates,
+            }
+            )
+
+            # print(prediction_chart_data)
+            graph_col, recommendation_col = st.columns([1,1])
+            with graph_col:
                 st.area_chart(prediction_chart_data, x="date", y=[f"history_{metric}_values", f"predicted_{metric}_values"])
-
+            with recommendation_col:
                 st.subheader('Recommendation:')
-                crop = "Wheat"
-
-                try:
-                    prompt = f"given the {metric} values weekly for the next 30 weeks, comment if they are appropriate to grow {crop} (write one paragraph showing your conclusion): {metric} values:{predictions}"
-                    response = client.chat.completions.create(
-                        model="gpt-4o",
-                        messages=[
-                            {
-                            "role": "user",
-                            "content": prompt
-                            }
-                        ],
-                        temperature=1,
-                        max_tokens=256,
-                        top_p=1,
-                        frequency_penalty=0,
-                        presence_penalty=0
-                    )
-                    st.caption(response.choices[0].message.content)
-                except:
-                    st.code("Server Error: Could't generate recommendation!")
-
-
-        
-
-        with row2:
-            if field_name != "Select Field":
-                track(metric, field_name, gdf, current_user)
-
-        
+                with st.spinner("Generating Recommendation..."):
+                    crop = gdf.loc[gdf['name'] == field_name].crop if 'crop' in gdf.columns else "Wheat"
+                    
+
+                    try:           
+                        weeks = future_dates
+                        gdf_loc = gdf.loc[gdf['name'] == field_name].reset_index(drop=True)
+                        location = utils.get_region_from_coordinates(gdf_loc.geometry[0].centroid.y, gdf_loc.geometry[0].centroid.x)
+                        prompt = f"""The Field Name is {field_name} and is located in {location}.
+                        Analyze {crop} growth conditions for the next {len(weeks)} weeks starting from {weeks[0]} to {weeks[-1]} based on the Forecatsed {metric} values weekly.
+                        {metric}: {predictions}
+
+                        Provide a concise Short report:
+
+                        1. Field Status (use format "Category: Status -  One sentence comment", (e.g. Overall Health: Low - The NDVI values consistently below 0.2, indicating weak vegetative growth.)
+                        - Overall Health:
+                        - Growth Stage:
+                        - Pest Risk:
+                        - Disease Risk:
+                        - Stress Level:
+
+                        2. Yield Forecast:
+                        [look online for the expected yield for the crop in the region based {metric} values]
+
+                        3. Recommendation:
+                        [one actionable advice reasoned based on the forecasted {metric} values, season, crop, and region]
+
+                        """
+                        # prompt = f"given the {metric} values weekly for the next 30 weeks, comment if they are appropriate to grow {crop} (write one paragraph showing your conclusion): {metric} values:{predictions}"
+                        response = client.chat.completions.create(
+                            model="gpt-4o",
+                            messages=[
+                                {
+                                "role": "user",
+                                "content": prompt
+                                }
+                            ],
+                            temperature=1,
+                            max_tokens=256,
+                            top_p=1,
+                            frequency_penalty=0,
+                            presence_penalty=0
+                        )
+                        st.markdown(response.choices[0].message.content)
+                    except Exception as e:
+                        st.code("Server Error: Could't generate recommendation!")
+                        st.error(e)
+
+
+    
 
 
 if __name__ == '__main__':

process.py

@@ -6,9 +6,9 @@ from sentinelhub import  SHConfig, MimeType
 
 
 config = SHConfig()
-config.instance_id       = '352670fb-2edf-4abd-90c8-437485a2403e'
-config.sh_client_id      = 'ca95f10f-443c-4c60-9a36-98950292bb9b'
-config.sh_client_secret  = 'rNFGRxGNiNFrXJfGyHIkVRyGOrdWNsfI'
+config.instance_id       = '44e79764-8b9d-43b0-a4bf-15799db2899d'
+config.sh_client_id      = '4ae34b53-3f81-4ba0-9c7d-b6fb0606dac3'
+config.sh_client_secret  = '3IPSSqE75fqK38vP85hxttR9PJEs5OxX'
 config.sh_timesfm_IP = "34.121.141.161"
 
 def Download_image_in_given_date(clientName, metric, df, field, date, mime_type = MimeType.TIFF):

tokens.txt

@@ -0,0 +1,11 @@
+k20rjxb2muforgz4eoh5b3rw8oaizsia
+pbmhjy7e8943e65i6cfwk8sixfwnj7ky
+zx57n4wyv34gd0unfs4y0kpjkfdgshx7
+ox5680uleqj9ea0jhqcl35a20qhlr3zm
+9mfg7acflhkbif70bnrn2lq3ult5t7l5
+gof83vvcxu6lrwqmfjnp3v0048rpbzid
+klhbf2c2o7l0g7d9z13kkp2z4q2r9v6i
+oijpgewezt9d39886829szmmryfr2k9y
+c4selw18hwft2mloqe9uv1ddozspmjbo
+kfpo6khkcuirmkshjufdob6k1dn9a2oo
+TEST_TOKEN

tokens_expired.txt

@@ -0,0 +1,6 @@
+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

@@ -7,6 +7,101 @@ import geopandas as gpd
 from shapely.geometry import Point
 from PIL import Image
 from tqdm import tqdm
+import geopy
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut, GeocoderUnavailable
+
+import random
+import string
+import os
+from datetime import datetime, timedelta
+
+TOKEN_FILE = "tokens.txt"
+EXPIRED_FILE = "tokens_expired.txt"
+
+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.'''
+    if not os.path.exists(token_file):
+        with open(token_file, 'w') as f:
+            tokens = set()
+            while len(tokens) < num_tokens:
+                token = ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
+                tokens.add(token)
+            for token in tokens:
+                f.write(token + '\n')
+    else:
+        with open(token_file, 'r') as f:
+            tokens = set(f.read().splitlines())
+        with open(token_file, 'a') as f:
+            while len(tokens) < num_tokens:
+                token = ''.join(random.choices(string.ascii_lowercase + string.digits, k=32))
+                if token not in tokens:
+                    tokens.add(token)
+                    f.write(token + '\n')
+    return tokens
+
+def confirm_api_token(token, token_file=TOKEN_FILE, expired_file=EXPIRED_FILE):
+    '''Checks if the given token is valid and not expired.'''
+    with open(token_file, 'r') as f:
+        tokens = set(f.read().splitlines())
+    if token in tokens:
+        now = datetime.now()
+        if token in load_expired_tokens(expired_file):
+            if now < load_token_expiration(token, expired_file):
+                return True
+        else:
+            expiry_date = now + timedelta(hours=1)
+            save_expired_token(token, expiry_date, expired_file)
+            return True
+    return False
+
+def load_expired_tokens(expired_file=EXPIRED_FILE):
+    '''Loads expired tokens from the file.'''
+    expired_tokens = {}
+    if os.path.exists(expired_file):
+        with open(expired_file, 'r') as f:
+            for line in f:
+                token, expiry_date = line.strip().split(',')
+                expired_tokens[token] = datetime.fromisoformat(expiry_date)
+    return expired_tokens
+
+def load_token_expiration(token, expired_file=EXPIRED_FILE):
+    '''Loads the expiration date for a given token.'''
+    expired_tokens = load_expired_tokens(expired_file)
+    return expired_tokens.get(token)
+
+def save_expired_token(token, expiry_date, expired_file=EXPIRED_FILE):
+    '''Saves expired tokens to the file.'''
+    if not os.path.exists(expired_file):
+        with open(expired_file, 'w') as f:
+            f.write(f"{token},{expiry_date.isoformat()}\n")
+    else:
+        with open(expired_file, 'a') as f:
+            f.write(f"{token},{expiry_date.isoformat()}\n")
+
+
+def get_region_from_coordinates(latitude, longitude, max_retries=3):
+    geolocator = Nominatim(user_agent="my_agent")
+    
+    for attempt in range(max_retries):
+        try:
+            location = geolocator.reverse(f"{latitude}, {longitude}")
+            if location and location.raw.get('address'):
+                address = location.raw['address']
+                # Try to get the most relevant administrative level
+                for level in ['state', 'county', 'region', 'province', 'district']:
+                    if level in address:
+                        return address[level]
+                # If no specific region is found, return the country
+                if 'country' in address:
+                    return address['country']
+            return "Region not found"
+        except (GeocoderTimedOut, GeocoderUnavailable):
+            if attempt == max_retries - 1:
+                return "Geocoding service unavailable"
+    
+    return "Failed to retrieve region information"
+
 
 # Initialzie custom basemaps for folium
 basemaps = {