src/old_main.py

import logging
import os

import pandas as pd
import streamlit as st
import folium
from streamlit_folium import st_folium

# from transformers import pipeline
# from transformers import AutoModelForImageClassification

# from maps.obs_map import add_obs_map_header 

# from datasets import disable_caching
# disable_caching()

# import whale_gallery as gallery
# import whale_viewer as viewer
# from input.input_handling import setup_input, check_inputs_are_set
# from input.input_handling import init_input_container_states, add_input_UI_elements, init_input_data_session_states
# from input.input_handling import dbg_show_observation_hashes

# from maps.alps_map import present_alps_map
# from maps.obs_map import present_obs_map
# from utils.st_logs import parse_log_buffer, init_logging_session_states
# from utils.workflow_ui import refresh_progress_display, init_workflow_viz, init_workflow_session_states
# from hf_push_observations import push_all_observations

# from classifier.classifier_image import cetacean_just_classify, cetacean_show_results_and_review, cetacean_show_results, init_classifier_session_states
# from classifier.classifier_hotdog import hotdog_classify


# # setup for the ML model on huggingface (our wrapper)
# os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
#classifier_revision = '0f9c15e2db4d64e7f622ade518854b488d8d35e6'
# classifier_revision = 'main' # default/latest version
# # and the dataset of observations (hf dataset in our space)
# dataset_id = "Saving-Willy/temp_dataset"
# data_files = "data/train-00000-of-00001.parquet"

# USE_BASIC_MAP = False
# DEV_SIDEBAR_LIB = True

# # one toggle for all the extra debug text
# if "MODE_DEV_STATEFUL" not in st.session_state:
#     st.session_state.MODE_DEV_STATEFUL = False
    

# get a global var for logger accessor in this module
# LOG_LEVEL = logging.DEBUG
# g_logger = logging.getLogger(__name__)
# g_logger.setLevel(LOG_LEVEL)

# st.set_page_config(layout="wide")




def main() -> None:
    """
    Main entry point to set up the streamlit UI and run the application.

    The organisation is as follows:

    1. observation input (a new observations) is handled in the sidebar
    2. the rest of the interface is organised in tabs:
    
        - cetean classifier
        - hotdog classifier
        - map to present the obersvations
        - table of recent log entries
        - gallery of whale images
    
    The majority of the tabs are instantiated from modules. Currently the two 
    classifiers are still in-line here.
    
    """

    # g_logger.info("App started.")
    # g_logger.warning(f"[D] Streamlit version: {st.__version__}. Python version: {os.sys.version}")

    #g_logger.debug("debug message")
    #g_logger.info("info message")
    #g_logger.warning("warning message")

    # Streamlit app
    # tab_inference, tab_hotdogs, tab_map, tab_coords, tab_log, tab_gallery = \
    #     st.tabs(["Cetecean classifier", "Hotdog classifier", "Map", "*:gray[Dev:coordinates]*", "Log", "Beautiful cetaceans"])

    # # put this early so the progress indicator is at the top (also refreshed at end)
    # refresh_progress_display()    

    # # create a sidebar, and parse all the input (returned as `observations` object)
    # with st.sidebar:
    #     # layout handling
    #     add_input_UI_elements()
    #     # input elements (file upload, text input, etc)
    #     setup_input()

        
    # with tab_map:
    #     # visual structure: a couple of toggles at the top, then the map inlcuding a
    #     # dropdown for tileset selection.
    #     add_obs_map_header()
    #     tab_map_ui_cols = st.columns(2)
    #     with tab_map_ui_cols[0]:
    #         show_db_points = st.toggle("Show Points from DB", True)
    #     with tab_map_ui_cols[1]:
    #         dbg_show_extra = st.toggle("Show Extra points (test)", False)
            
    #     if show_db_points:
    #         # show a nicer map, observations marked, tileset selectable.
    #         st_observation = present_obs_map(
    #             dataset_id=dataset_id, data_files=data_files,
    #             dbg_show_extra=dbg_show_extra)
            
    #     else:
    #         # development map.
    #         st_observation = present_alps_map()
            

    # with tab_log:
    #     handler = st.session_state['handler']
    #     if handler is not None:
    #         records = parse_log_buffer(handler.buffer)
    #         st.dataframe(records[::-1], use_container_width=True,)
    #         st.info(f"Length of records: {len(records)}")
    #     else:
    #         st.error("⚠️ No log handler found!")

        
        
    # with tab_coords:
    #     # the goal of this tab is to allow selection of the new obsvation's location by map click/adjust.
    #     st.markdown("Coming later! :construction:")
    #     st.markdown(
    #         """*The goal is to allow interactive definition for the coordinates of a new
    #         observation, by click/drag points on the map.*""")
        

    #     st.write("Click on the map to capture a location.")
    #     #m = folium.Map(location=visp_loc, zoom_start=7)
    #     mm = folium.Map(location=[39.949610, -75.150282], zoom_start=16)
    #     folium.Marker( [39.949610, -75.150282], popup="Liberty Bell", tooltip="Liberty Bell"
    # ).add_to(mm)

    #     st_data2 = st_folium(mm, width=725)
    #     st.write("below the map...")
    #     if st_data2['last_clicked'] is not None:
    #         print(st_data2)
    #         st.info(st_data2['last_clicked'])


    # with tab_gallery:
        # # here we make a container to allow filtering css properties 
        # # specific to the gallery (otherwise we get side effects)
        # tg_cont = st.container(key="swgallery")
        # with tg_cont:
        #     gallery.render_whale_gallery(n_cols=4)
        

    # state handling re data_entry phases
    # 0. no data entered yet -> display the file uploader thing
    # 1. we have some images, but not all the metadata fields are done -> validate button shown, disabled
    # 2. all data entered -> validate button enabled
    # 3. validation button pressed, validation done -> enable the inference button. 
    #    - at this point do we also want to disable changes to the metadata selectors?
    #    anyway, simple first. 

    # if st.session_state.workflow_fsm.is_in_state('doing_data_entry'):
    #     # can we advance state? - only when all inputs are set for all uploaded files
    #     all_inputs_set = check_inputs_are_set(debug=True, empty_ok=False)
    #     if all_inputs_set:
    #         st.session_state.workflow_fsm.complete_current_state()
    #         # -> data_entry_complete
    #     else: 
    #         # button, disabled; no state change yet.
    #         st.sidebar.button(":gray[*Validate*]", disabled=True, help="Please fill in all fields.")
            
    
    # if st.session_state.workflow_fsm.is_in_state('data_entry_complete'):
    #     # can we advance state? - only when the validate button is pressed
    #     if st.sidebar.button(":white_check_mark:[**Validate**]"):
    #         # create a dictionary with the submitted observation
    #         tab_log.info(f"{st.session_state.observations}")
    #         df = pd.DataFrame([obs.to_dict() for obs in st.session_state.observations.values()])
    #         #df = pd.DataFrame(st.session_state.observations, index=[0])
    #         with tab_coords:
    #             st.table(df)
    #         # there doesn't seem to be any actual validation here?? TODO: find validator function (each element is validated by the input box, but is there something at the whole image level?)
    #         # hmm, maybe it should actually just be "I'm done with data entry"
    #         st.session_state.workflow_fsm.complete_current_state()
    #         # -> data_entry_validated
    
    # state handling re inference phases (tab_inference)
    # 3. validation button pressed, validation done -> enable the inference button.
    # 4. inference button pressed -> ML started. | let's cut this one out, since it would only
    #      make sense if we did it as an async action
    # 5. ML done -> show results, and manual validation options
    # 6. manual validation done -> enable the upload buttons
    # 
    # with tab_inference:
    #     # inside the inference tab, on button press we call the model (on huggingface hub)
    #     # which will be run locally. 
    #     # - the model predicts the top 3 most likely species from the input image
    #     # - these species are shown
    #     # - the user can override the species prediction using the dropdown 
    #     # - an observation is uploaded if the user chooses.

        
    #     if st.session_state.MODE_DEV_STATEFUL:
    #         dbg_show_observation_hashes()

    #     add_classifier_header()
    #     # if we are before data_entry_validated, show the button, disabled.
    #     if not st.session_state.workflow_fsm.is_in_state_or_beyond('data_entry_validated'):
    #         tab_inference.button(":gray[*Identify with cetacean classifier*]", disabled=True, 
    #                             help="Please validate inputs before proceeding", 
    #                             key="button_infer_ceteans")
        
    #     if st.session_state.workflow_fsm.is_in_state('data_entry_validated'):
    #         # show the button, enabled. If pressed, we start the ML model (And advance state)
    #         if tab_inference.button("Identify with cetacean classifier", 
    #                                 key="button_infer_ceteans"):
    #             cetacean_classifier = AutoModelForImageClassification.from_pretrained(
    #                 "Saving-Willy/cetacean-classifier", 
    #                 revision=classifier_revision, 
    #                 trust_remote_code=True)

    #             cetacean_just_classify(cetacean_classifier)
    #             st.session_state.workflow_fsm.complete_current_state()
    #             # trigger a refresh too (refreshhing the prog indicator means the script reruns and 
    #             # we can enter the next state - visualising the results / review)
    #             # ok it doesn't if done programmatically. maybe interacting with teh button? check docs.
    #             refresh_progress_display()
    #             #TODO: validate this doesn't harm performance adversely.
    #             st.rerun()
        
    #     elif st.session_state.workflow_fsm.is_in_state('ml_classification_completed'):
    #         # show the results, and allow manual validation
    #         st.markdown("""### Inference results and manual validation/adjustment """)
    #         if st.session_state.MODE_DEV_STATEFUL:
    #             s = ""
    #             for k, v in st.session_state.whale_prediction1.items():
    #                 s += f"* Image {k}: {v}\n"
                    
    #             st.markdown(s)

    #         # add a button to advance the state
    #         if st.button("Confirm species predictions", help="Confirm that all species are selected correctly"):
    #             st.session_state.workflow_fsm.complete_current_state()
    #             # -> manual_inspection_completed
    #             st.rerun()
            
    #         cetacean_show_results_and_review()

    #     elif st.session_state.workflow_fsm.is_in_state('manual_inspection_completed'):
    #         # show the ML results, and allow the user to upload the observation
    #         st.markdown("""### Inference Results (after manual validation) """)
            
            
    #         if st.button("Upload all observations to THE INTERNET!"):
    #             # let this go through to the push_all func, since it just reports to log for now.
    #             push_all_observations(enable_push=False)
    #             st.session_state.workflow_fsm.complete_current_state()
    #             # -> data_uploaded
    #             st.rerun()

    #         cetacean_show_results()
        
    #     elif st.session_state.workflow_fsm.is_in_state('data_uploaded'):
    #         # the data has been sent. Lets show the observations again
    #         # but no buttons to upload (or greyed out ok)
    #         st.markdown("""### Observation(s) uploaded - thank you!""")
    #         cetacean_show_results()

    #         st.divider()
    #         #df = pd.DataFrame(st.session_state.observations, index=[0])
    #         df = pd.DataFrame([obs.to_dict() for obs in st.session_state.observations.values()])
    #         st.table(df)

    #         # didn't decide what the next state is here - I think we are in the terminal state.
    #         #st.session_state.workflow_fsm.complete_current_state()
            
        
    # # inside the hotdog tab, on button press we call a 2nd model (totally unrelated at present, just for demo
    # # purposes, an hotdog image classifier) which will be run locally.
    # # - this model predicts if the image is a hotdog or not, and returns probabilities
    # # - the input image is the same as for the ceteacean classifier - defined in the sidebar
    # tab_hotdogs.title("Hot Dog? Or Not?")
    # tab_hotdogs.write("""
    #             *Run alternative classifer on input images. Here we are using
    #             a binary classifier - hotdog or not - from
    #             huggingface.co/julien-c/hotdog-not-hotdog.*""")

    # if tab_hotdogs.button("Get Hotdog Prediction"):   
        
    #     pipeline_hot_dog = pipeline(task="image-classification", model="julien-c/hotdog-not-hotdog")

    #     if st.session_state.image is None:
    #         st.info("Please upload an image first.")
    #         #st.info(str(observations.to_dict()))
            
    #     else:
    #         hotdog_classify(pipeline_hot_dog, tab_hotdogs)
            
            
    # # after all other processing, we can show the stage/state
    # refresh_progress_display()


if __name__ == "__main__":
    main()