Merge pull request #24 from sdsc-ordes/feat/image-batch

Dockerfile

@@ -0,0 +1,42 @@
+From ubuntu:latest
+
+RUN apt-get update
+RUN apt-get install python3 python3-pip -y
+
+# https://stackoverflow.com/questions/75608323/how-do-i-solve-error-externally-managed-environment-every-time-i-use-pip-3
+# https://veronneau.org/python-311-pip-and-breaking-system-packages.html
+ENV PIP_BREAK_SYSTEM_PACKAGES 1
+
+
+##################################################
+# Ubuntu setup
+##################################################
+
+RUN  apt-get update \
+  && apt-get install -y wget \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN apt-get update && apt-get -y upgrade \
+  && apt-get install -y --no-install-recommends \
+    unzip \
+    nano \
+    git \ 
+    g++ \
+    gcc \
+    htop \
+    zip \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+##################################################
+# ODTP setup
+##################################################
+
+RUN mkdir /app
+COPY . /saving-willy
+RUN pip3 install --upgrade setuptools
+RUN pip3 install -r /saving-willy/requirements.txt
+
+WORKDIR /saving-willy
+
+ENTRYPOINT bash

README.md

@@ -28,7 +28,7 @@ pip install -r requirements.txt
 ```
 
 ```
-streamlit run app.py 
+streamlit run src/main.py
 ```
 
 

basic_map/app.py

@@ -1,21 +0,0 @@
-import pandas as pd
-import streamlit as st
-import folium
-
-from streamlit_folium import st_folium
-from streamlit_folium import folium_static
-
-
-visp_loc = 46.295833, 7.883333
-#m = folium.Map(location=visp_loc, zoom_start=9)
-
-
-st.markdown("# :whale: :whale: Cetaceans :red[& friends] :balloon:")
-
-m = folium.Map(location=visp_loc, zoom_start=9,
-                              tiles='https://tile.opentopomap.org/{z}/{x}/{y}.png',
-                              attr='<a href="https://opentopomap.org/">Open Topo Map</a>')
-
-folium_static(m)
-
-

basic_map/app1.py

@@ -1,42 +0,0 @@
-# lets try using map stuff without folium, maybe stlite doesnt support that.
-
-import streamlit as st
-import pandas as pd
-
-# Load data
-f = 'mountains_clr.csv'
-df = pd.read_csv(f).dropna()
-
-print(df)
-
-st.markdown("# :whale: :whale: Cetaceans :red[& friends] :balloon:")
-
-st.markdown("## :mountain: Mountains")
-st.markdown(f"library version: **{st.__version__}**")
-# not sure where my versions are getting pegged from, but we have a 1y spread :(
-# https://github.com/streamlit/streamlit/blob/1.24.1/lib/streamlit/elements/map.py
-#    rather hard to find the docs for old versions, no selector unlike many libraries.
-
-visp_loc = 46.295833, 7.883333
-tile_xyz = 'https://tile.opentopomap.org/{z}/{x}/{y}.png'
-tile_attr = '<a href="https://opentopomap.org/">Open Topo Map</a>'
-st.map(df, latitude='lat', longitude='lon', color='color', size='size', zoom=7)
-#, tiles=tile_xyz, attr=tile_attr)
-
-#st.map(df)
-
-#st.map(df, latitude="col1", longitude="col2", size="col3", color="col4")
-
-import numpy as np
-
-df2 = pd.DataFrame(
-    {
-        "col1": np.random.randn(1000) / 50 + 37.76,
-        "col2": np.random.randn(1000) / 50 + -122.4,
-        "col3": np.random.randn(1000) * 100,
-        "col4": np.random.rand(1000, 4).tolist(),
-    }
-)
-#st.map(df, latitude="col1", longitude="col2", size="col3", color="col4")
-
-

basic_map/requirements.txt

@@ -1,4 +0,0 @@
-streamlit
-folium
-streamlit-folium
-

docs/app.md

@@ -1,5 +0,0 @@
-Here is the documentation for the app code generating the streamlit front-end. 
-
-# Streamlit App 
-
-::: basic_map.app

requirements.txt

@@ -1,4 +1,4 @@
-numpy==1.24
+numpy==1.26.4
 pandas==2.2.3
 
 

src/classifier/classifier_hotdog.py

@@ -0,0 +1,26 @@
+import streamlit as st
+import json 
+from PIL import Image
+
+
+def hotdog_classify(pipeline_hot_dog, tab_hotdogs): 
+    col1, col2 = tab_hotdogs.columns(2)
+    for file in st.session_state.files:
+        image = st.session_state.images[file.name]
+        observation = st.session_state.observations[file.name].to_dict()
+        # display the image (use cached version, no need to reread)
+        col1.image(image, use_column_width=True)
+        # and then run inference on the image
+        hotdog_image = Image.fromarray(image)
+        predictions = pipeline_hot_dog(hotdog_image)
+
+        col2.header("Probabilities")
+        first = True
+        for p in predictions:
+            col2.subheader(f"{ p['label'] }: { round(p['score'] * 100, 1)}%")
+            if first:
+                observation['predicted_class'] = p['label']
+                observation['predicted_score'] = round(p['score'] * 100, 1)
+                first = False
+        
+        tab_hotdogs.write(f"Session observation: {json.dumps(observation)}")

src/classifier/classifier_image.py

@@ -0,0 +1,68 @@
+import streamlit as st
+import logging
+
+# get a global var for logger accessor in this module
+LOG_LEVEL = logging.DEBUG
+g_logger = logging.getLogger(__name__)
+g_logger.setLevel(LOG_LEVEL)
+
+import whale_viewer as viewer
+from hf_push_observations import push_observations
+from utils.grid_maker import gridder
+from utils.metadata_handler import metadata2md
+
+def cetacean_classify(cetacean_classifier):
+    files = st.session_state.files
+    images = st.session_state.images
+    observations = st.session_state.observations
+
+    batch_size, row_size, page = gridder(files)
+    
+    grid = st.columns(row_size)
+    col = 0
+
+    for file in files: 
+        image = images[file.name]
+        
+        with grid[col]:
+            st.image(image, use_column_width=True)
+            observation = observations[file.name].to_dict()
+            # run classifier model on `image`, and persistently store the output
+            out = cetacean_classifier(image) # get top 3 matches
+            st.session_state.whale_prediction1 = out['predictions'][0]
+            st.session_state.classify_whale_done = True
+            msg = f"[D]2 classify_whale_done: {st.session_state.classify_whale_done}, whale_prediction1: {st.session_state.whale_prediction1}"
+            g_logger.info(msg)
+            
+            # dropdown for selecting/overriding the species prediction
+            if not st.session_state.classify_whale_done:
+                selected_class = st.sidebar.selectbox("Species", viewer.WHALE_CLASSES, 
+                                                                index=None, placeholder="Species not yet identified...", 
+                                                                disabled=True)
+            else:
+                pred1 = st.session_state.whale_prediction1
+                # get index of pred1 from WHALE_CLASSES, none if not present
+                print(f"[D] pred1: {pred1}")
+                ix = viewer.WHALE_CLASSES.index(pred1) if pred1 in viewer.WHALE_CLASSES else None
+                selected_class = st.selectbox(f"Species for {file.name}", viewer.WHALE_CLASSES, index=ix)
+            
+            observation['predicted_class'] = selected_class
+            if selected_class != st.session_state.whale_prediction1:
+                observation['class_overriden'] = selected_class
+            
+            st.session_state.public_observation = observation
+            st.button(f"Upload observation for {file.name} to THE INTERNET!", on_click=push_observations)
+            # TODO: the metadata only fills properly if `validate` was clicked.
+            st.markdown(metadata2md())
+
+            msg = f"[D] full observation after inference: {observation}"
+            g_logger.debug(msg)
+            print(msg)
+            # TODO: add a link to more info on the model, next to the button.
+
+            whale_classes = out['predictions'][:]
+            # render images for the top 3 (that is what the model api returns)
+            st.markdown(f"Top 3 Predictions for {file.name}")
+            for i in range(len(whale_classes)):
+                viewer.display_whale(whale_classes, i)
+        col = (col + 1) % row_size

src/classifier_image.py

@@ -0,0 +1,70 @@
+import streamlit as st
+import logging
+import os
+
+# get a global var for logger accessor in this module
+LOG_LEVEL = logging.DEBUG
+g_logger = logging.getLogger(__name__)
+g_logger.setLevel(LOG_LEVEL)
+
+from grid_maker import gridder
+import hf_push_observations as sw_push_obs
+import utils.metadata_handler as meta_handler
+import whale_viewer as sw_wv
+
+def cetacean_classify(cetacean_classifier, tab_inference):
+    files = st.session_state.files
+    images = st.session_state.images
+    observations = st.session_state.observations
+
+    batch_size, row_size, page = gridder(files)
+    
+    grid = st.columns(row_size)
+    col = 0
+
+    for file in files: 
+        image = images[file.name]
+        
+        with grid[col]:
+            st.image(image, use_column_width=True)
+            observation = observations[file.name].to_dict()
+            # run classifier model on `image`, and persistently store the output
+            out = cetacean_classifier(image) # get top 3 matches
+            st.session_state.whale_prediction1 = out['predictions'][0]
+            st.session_state.classify_whale_done = True
+            msg = f"[D]2 classify_whale_done: {st.session_state.classify_whale_done}, whale_prediction1: {st.session_state.whale_prediction1}"
+            g_logger.info(msg)
+            
+            # dropdown for selecting/overriding the species prediction
+            if not st.session_state.classify_whale_done:
+                selected_class = st.sidebar.selectbox("Species", sw_wv.WHALE_CLASSES, 
+                                                                index=None, placeholder="Species not yet identified...", 
+                                                                disabled=True)
+            else:
+                pred1 = st.session_state.whale_prediction1
+                # get index of pred1 from WHALE_CLASSES, none if not present
+                print(f"[D] pred1: {pred1}")
+                ix = sw_wv.WHALE_CLASSES.index(pred1) if pred1 in sw_wv.WHALE_CLASSES else None
+                selected_class = tab_inference.selectbox("Species", sw_wv.WHALE_CLASSES, index=ix)
+            
+            observation['predicted_class'] = selected_class
+            if selected_class != st.session_state.whale_prediction1:
+                observation['class_overriden'] = selected_class
+            
+            st.session_state.public_observation = observation
+            st.button(f"Upload observation for {file.name} to THE INTERNET!", on_click=sw_push_obs.push_observations)
+            # TODO: the metadata only fills properly if `validate` was clicked.
+            st.markdown(meta_handler.metadata2md())
+
+            msg = f"[D] full observation after inference: {observation}"
+            g_logger.debug(msg)
+            print(msg)
+            # TODO: add a link to more info on the model, next to the button.
+
+            whale_classes = out['predictions'][:]
+            # render images for the top 3 (that is what the model api returns)
+            #with tab_inference:
+            st.title(f"Species detected for {file.name}")
+            for i in range(len(whale_classes)):
+                sw_wv.display_whale(whale_classes, i)
+        col = (col + 1) % row_size

src/hf_push_observations.py

@@ -0,0 +1,56 @@
+from streamlit.delta_generator import DeltaGenerator
+import streamlit as st
+from huggingface_hub import HfApi
+import json
+import tempfile
+import logging
+
+# get a global var for logger accessor in this module
+LOG_LEVEL = logging.DEBUG
+g_logger = logging.getLogger(__name__)
+g_logger.setLevel(LOG_LEVEL)
+
+def push_observations(tab_log:DeltaGenerator=None):
+    """
+    Push the observations to the Hugging Face dataset
+    
+    Args:
+        tab_log (streamlit.container): The container to log messages to. If not provided,
+            log messages are in any case written to the global logger (TODO: test - didn't 
+            push any observation since generating the logger)
+    
+    """
+    # we get the observation from session state: 1 is the dict 2 is the image.
+    # first, lets do an info display (popup)
+    metadata_str = json.dumps(st.session_state.public_observation)
+    
+    st.toast(f"Uploading observations: {metadata_str}", icon="🦭")
+    tab_log = st.session_state.tab_log
+    if tab_log is not None:
+        tab_log.info(f"Uploading observations: {metadata_str}")
+        
+    # get huggingface api
+    import os 
+    token = os.environ.get("HF_TOKEN", None)
+    api = HfApi(token=token)
+
+    f = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
+    f.write(metadata_str)
+    f.close()
+    st.info(f"temp file: {f.name} with metadata written...")
+
+    path_in_repo= f"metadata/{st.session_state.public_observation['author_email']}/{st.session_state.public_observation['image_md5']}.json"
+    msg = f"fname: {f.name} | path: {path_in_repo}"
+    print(msg)
+    st.warning(msg)
+    # rv = api.upload_file(
+    #     path_or_fileobj=f.name,
+    #     path_in_repo=path_in_repo,
+    #     repo_id="Saving-Willy/temp_dataset",
+    #     repo_type="dataset",
+    # )
+    # print(rv)
+    # msg = f"observation attempted tx to repo happy walrus: {rv}"
+    g_logger.info(msg)
+    st.info(msg)
+    

src/input/input_handling.py

@@ -0,0 +1,118 @@
+import datetime
+import logging
+
+import streamlit as st
+from streamlit.delta_generator import DeltaGenerator
+
+import cv2
+import numpy as np
+
+from input.input_observation import InputObservation
+from input.input_validator import get_image_datetime, is_valid_email, is_valid_number
+
+m_logger = logging.getLogger(__name__)
+m_logger.setLevel(logging.INFO)
+
+''' 
+A module to setup the input handling for the whale observation guidance tool
+
+both the UI elements (setup_input_UI) and the validation functions.
+'''
+allowed_image_types = ['jpg', 'jpeg', 'png', 'webp']
+
+# an arbitrary set of defaults so testing is less painful...
+# ideally we add in some randomization to the defaults
+spoof_metadata = {
+    "latitude": 23.5,
+    "longitude": 44,
+    "author_email": "super@whale.org",
+    "date": None,
+    "time": None,
+}
+
+def setup_input(
+    viewcontainer: DeltaGenerator=None,
+    _allowed_image_types: list=None, ) -> InputObservation:
+    """
+    Sets up the input interface for uploading an image and entering metadata.
+
+    It provides input fields for an image upload, lat/lon, author email, and date-time. 
+    In the ideal case, the image metadata will be used to populate location and datetime.
+
+    Parameters:
+        viewcontainer (DeltaGenerator, optional): The Streamlit container to use for the input interface. Defaults to st.sidebar.
+        _allowed_image_types (list, optional): List of allowed image file types for upload. Defaults to allowed_image_types.
+
+    Returns:
+        InputObservation: An object containing the uploaded image and entered metadata.
+
+    """
+                
+    if viewcontainer is None:
+        viewcontainer = st.sidebar
+        
+    if _allowed_image_types is None:
+        _allowed_image_types = allowed_image_types
+    
+
+    viewcontainer.title("Input image and data")
+
+    # 1. Input the author email 
+    author_email = viewcontainer.text_input("Author Email", spoof_metadata.get('author_email', ""))
+    if author_email and not is_valid_email(author_email):   
+        viewcontainer.error("Please enter a valid email address.")
+
+    # 2. Image Selector
+    uploaded_files = viewcontainer.file_uploader("Upload an image", type=allowed_image_types, accept_multiple_files=True)
+    observations = {}
+    images = {}
+    if uploaded_files is not None:
+        for file in uploaded_files:
+
+            viewcontainer.title(f"Metadata for {file.name}")
+
+            # Display the uploaded image
+            # load image using cv2 format, so it is compatible with the ML models
+            file_bytes = np.asarray(bytearray(file.read()), dtype=np.uint8)
+            filename = file.name
+            image = cv2.imdecode(file_bytes, 1)
+            # Extract and display image date-time
+            image_datetime = None  # For storing date-time from image
+            image_datetime = get_image_datetime(file)
+            m_logger.debug(f"image date extracted as {image_datetime} (from {uploaded_files})")
+        
+
+            # 3. Latitude Entry Box
+            latitude = viewcontainer.text_input("Latitude for "+filename, spoof_metadata.get('latitude', ""))
+            if latitude and not is_valid_number(latitude):
+                viewcontainer.error("Please enter a valid latitude (numerical only).")
+                m_logger.error(f"Invalid latitude entered: {latitude}.")
+            # 4. Longitude Entry Box
+            longitude = viewcontainer.text_input("Longitude for "+filename, spoof_metadata.get('longitude', ""))
+            if longitude and not is_valid_number(longitude):
+                viewcontainer.error("Please enter a valid longitude (numerical only).")
+                m_logger.error(f"Invalid latitude entered: {latitude}.")
+            # 5. Date/time
+            ## first from image metadata
+            if image_datetime is not None:
+                time_value = datetime.datetime.strptime(image_datetime, '%Y:%m:%d %H:%M:%S').time()
+                date_value = datetime.datetime.strptime(image_datetime, '%Y:%m:%d %H:%M:%S').date()
+            else:
+                time_value = datetime.datetime.now().time()  # Default to current time
+                date_value = datetime.datetime.now().date()
+
+            ## if not, give user the option to enter manually
+            date_option = st.sidebar.date_input("Date for "+filename, value=date_value)
+            time_option = st.sidebar.time_input("Time for "+filename, time_value)
+
+            observation = InputObservation(image=file, latitude=latitude, longitude=longitude, 
+                                        author_email=author_email, date=image_datetime, time=None, 
+                                        date_option=date_option, time_option=time_option)
+            observations[file.name] = observation
+            images[file.name] = image
+    
+    st.session_state.images = images
+    st.session_state.files = uploaded_files
+
+    return observations
+

src/{input_handling.py → input/input_observation.py}

@@ -1,48 +1,5 @@
-from fractions import Fraction
-from PIL import Image
-from PIL import ExifTags
-import re
-import datetime
 import hashlib
-import logging
-
-import streamlit as st
-from streamlit.runtime.uploaded_file_manager import UploadedFile # for type hinting
-from streamlit.delta_generator import DeltaGenerator
-
-import cv2
-import numpy as np
-
-m_logger = logging.getLogger(__name__)
-# we can set the log level locally for funcs in this module
-#g_m_logger.setLevel(logging.DEBUG)
-m_logger.setLevel(logging.INFO)
-
-''' 
-A module to setup the input handling for the whale observation guidance tool
-
-both the UI elements (setup_input_UI) and the validation functions.
-'''
-#allowed_image_types = ['webp']
-allowed_image_types = ['jpg', 'jpeg', 'png', 'webp']
-
-import random
-import string
-def generate_random_md5() -> str:
-    """
-    Generates a random MD5 hash.
-
-    This function creates a random string of 16 alphanumeric characters,
-    encodes it, and then computes its MD5 hash.
-
-    Returns:
-        str: The MD5 hash of the generated random string.
-    """
-    # Generate a random string
-    random_string = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
-    # Encode the string and compute its MD5 hash
-    md5_hash = hashlib.md5(random_string.encode()).hexdigest()
-    return md5_hash
+from input.input_validator import generate_random_md5
 
 # autogenerated class to hold the input data
 class InputObservation:
@@ -87,7 +44,9 @@ class InputObservation:
         from_input(input):
             Creates an observation from another input observation.
     """
-    def __init__(self, image=None, latitude=None, longitude=None, author_email=None, date=None, time=None, date_option=None, time_option=None, uploaded_filename=None):
+    def __init__(self, image=None, latitude=None, longitude=None, 
+                 author_email=None, date=None, time=None, date_option=None, time_option=None, 
+                 uploaded_filename=None):
         self.image = image
         self.latitude = latitude
         self.longitude = longitude
@@ -125,8 +84,6 @@ class InputObservation:
             "author_email": self.author_email,
             "date": self.date,
             "time": self.time,
-            # "date_option": self.date_option,
-            # "time_option": self.time_option,
             "date_option": str(self.date_option),
             "time_option": str(self.time_option),
             "uploaded_filename": self.uploaded_filename
@@ -149,208 +106,5 @@ class InputObservation:
         return InputObservation(data["image"], data["latitude"], data["longitude"], data["author_email"], data["date"], data["time"], data["date_option"], data["time_option"], data["uploaded_filename"])
 
 
-def is_valid_number(number:str) -> bool:
-    """
-    Check if the given string is a valid number (int or float, sign ok)
-
-    Args:
-        number (str): The string to be checked.
-
-    Returns:
-        bool: True if the string is a valid number, False otherwise.
-    """
-    pattern = r'^[-+]?[0-9]*\.?[0-9]+$'
-    return re.match(pattern, number) is not None
-
-
-# Function to validate email address
-def is_valid_email(email:str) -> bool:
-    """
-    Validates if the provided email address is in a correct format.
-
-    Args:
-        email (str): The email address to validate.
-
-    Returns:
-        bool: True if the email address is valid, False otherwise.
-    """
-    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
-    return re.match(pattern, email) is not None
-
-# Function to extract date and time from image metadata
-def get_image_datetime(image_file: UploadedFile) -> str | None: 
-    """
-    Extracts the original date and time from the EXIF metadata of an uploaded image file.
-
-    Args:
-        image_file (UploadedFile): The uploaded image file from which to extract the date and time.
-
-    Returns:
-        str: The original date and time as a string if available, otherwise None.
-
-    Raises:
-        Warning: If the date and time could not be extracted from the image metadata.
-    """
-    try:
-        image = Image.open(image_file)
-        exif_data = image._getexif()
-        if exif_data is not None:
-            if ExifTags.Base.DateTimeOriginal in exif_data:
-                return exif_data.get(ExifTags.Base.DateTimeOriginal)
-    except Exception as e: # FIXME: what types of exception?
-         st.warning(f"Could not extract date from image metadata. (file: {image_file.name})")
-         # TODO: add to logger
-    return None
-
-def decimal_coords(coords:tuple, ref:str) -> Fraction:
-    """
-    Converts coordinates from degrees, minutes, and seconds to decimal degrees.
-
-    Args:
-        coords (tuple): A tuple containing three elements representing degrees, minutes, and seconds.
-        ref (str): A string representing the reference direction ('N', 'S', 'E', 'W').
-
-    Returns:
-        Fraction: The coordinates in decimal degrees. Negative if the reference is 'S' or 'W'.
-
-    Example:
-        decimal_coords((40, 26, 46), 'N') -> 40.44611111111111
-        decimal_coords((40, 26, 46), 'W') -> -40.44611111111111
-    """
-    # https://stackoverflow.com/a/73267185
-    if ref not in ['N', 'S', 'E', 'W']:
-        raise ValueError("Invalid reference direction. Must be 'N', 'S', 'E', or 'W'.")
-    if len(coords) != 3:
-        raise ValueError("Coordinates must be a tuple of three elements (degrees, minutes, seconds).")
-    
-    decimal_degrees = coords[0] + coords[1] / 60 + coords[2] / 3600
-    if ref == "S" or ref =='W':
-        decimal_degrees = -decimal_degrees
-    return decimal_degrees
-
-
-def get_image_latlon(image_file: UploadedFile) -> tuple[float, float] | None:
-    """
-    Extracts the latitude and longitude from the EXIF metadata of an uploaded image file.
-
-    Args:
-        image_file (UploadedFile): The uploaded image file from which to extract the latitude and longitude.
-
-    Returns:
-        tuple[float, float]: The latitude and longitude as a tuple if available, otherwise None.
-
-    Raises:
-        Warning: If the latitude and longitude could not be extracted from the image metadata.
-    """
-    try:
-        image = Image.open(image_file)
-        exif_data = image._getexif()
-        if exif_data is not None:
-            if ExifTags.Base.GPSInfo in exif_data:
-                gps_ifd = exif_data.get(ExifTags.Base.GPSInfo) 
-                
-                lat = float(decimal_coords(gps_ifd[ExifTags.GPS.GPSLatitude], gps_ifd[ExifTags.GPS.GPSLatitudeRef]))
-                lon = float(decimal_coords(gps_ifd[ExifTags.GPS.GPSLongitude], gps_ifd[ExifTags.GPS.GPSLongitudeRef]))
-            
-                return lat, lon
-            
-    except Exception as e: # FIXME: what types of exception?
-         st.warning(f"Could not extract latitude and longitude from image metadata. (file: {str(image_file)}")
-
-
-# an arbitrary set of defaults so testing is less painful...
-# ideally we add in some randomization to the defaults
-spoof_metadata = {
-    "latitude": 23.5,
-    "longitude": 44,
-    "author_email": "super@whale.org",
-    "date": None,
-    "time": None,
-}
-
-#def display_whale(whale_classes:List[str], i:int, viewcontainer=None):
-def setup_input(
-    viewcontainer: DeltaGenerator=None,
-    _allowed_image_types: list=None, ) -> InputObservation:
-    """
-    Sets up the input interface for uploading an image and entering metadata.
-
-    It provides input fields for an image upload, lat/lon, author email, and date-time. 
-    In the ideal case, the image metadata will be used to populate location and datetime.
-
-    Parameters:
-        viewcontainer (DeltaGenerator, optional): The Streamlit container to use for the input interface. Defaults to st.sidebar.
-        _allowed_image_types (list, optional): List of allowed image file types for upload. Defaults to allowed_image_types.
-
-    Returns:
-        InputObservation: An object containing the uploaded image and entered metadata.
-
-    """
-                
-    if viewcontainer is None:
-        viewcontainer = st.sidebar
-        
-    if _allowed_image_types is None:
-        _allowed_image_types = allowed_image_types
-    
-
-    viewcontainer.title("Input image and data")
-
-    # 1. Image Selector
-    uploaded_filename = viewcontainer.file_uploader("Upload an image", type=allowed_image_types)
-    image_datetime = None  # For storing date-time from image
-
-    if uploaded_filename is not None:
-        # Display the uploaded image
-        #image = Image.open(uploaded_filename)
-        # load image using cv2 format, so it is compatible with the ML models
-        file_bytes = np.asarray(bytearray(uploaded_filename.read()), dtype=np.uint8)
-        image = cv2.imdecode(file_bytes, 1)
-
-
-        viewcontainer.image(image, caption='Uploaded Image.', use_column_width=True)
-        # store the image in the session state
-        st.session_state.image = image
-        
-
-        # Extract and display image date-time
-        image_datetime = get_image_datetime(uploaded_filename)
-        print(f"[D] image date extracted as {image_datetime}")
-        m_logger.debug(f"image date extracted as {image_datetime} (from {uploaded_filename})")
-        
-
-    # 2. Latitude Entry Box
-    latitude = viewcontainer.text_input("Latitude", spoof_metadata.get('latitude', ""))
-    if latitude and not is_valid_number(latitude):
-        viewcontainer.error("Please enter a valid latitude (numerical only).")
-        m_logger.error(f"Invalid latitude entered: {latitude}.")
-    # 3. Longitude Entry Box
-    longitude = viewcontainer.text_input("Longitude", spoof_metadata.get('longitude', ""))
-    if longitude and not is_valid_number(longitude):
-        viewcontainer.error("Please enter a valid longitude (numerical only).")
-        m_logger.error(f"Invalid latitude entered: {latitude}.")
-        
-    # 4. Author Box with Email Address Validator
-    author_email = viewcontainer.text_input("Author Email", spoof_metadata.get('author_email', ""))
-
-    if author_email and not is_valid_email(author_email):   
-        viewcontainer.error("Please enter a valid email address.")
-
-    # 5. date/time
-    ## first from image metadata
-    if image_datetime is not None:
-        time_value = datetime.datetime.strptime(image_datetime, '%Y:%m:%d %H:%M:%S').time()
-        date_value = datetime.datetime.strptime(image_datetime, '%Y:%m:%d %H:%M:%S').date()
-    else:
-        time_value = datetime.datetime.now().time()  # Default to current time
-        date_value = datetime.datetime.now().date()
-
-    ## if not, give user the option to enter manually
-    date_option = st.sidebar.date_input("Date", value=date_value)
-    time_option = st.sidebar.time_input("Time", time_value)
 
-    observation = InputObservation(image=uploaded_filename, latitude=latitude, longitude=longitude, 
-                                   author_email=author_email, date=image_datetime, time=None, 
-                                   date_option=date_option, time_option=time_option)
-    return observation
 

src/input/input_validator.py

@@ -0,0 +1,125 @@
+import random
+import string
+import hashlib
+import re
+import streamlit as st
+from fractions import Fraction
+
+from PIL import Image
+from PIL import ExifTags
+
+from streamlit.runtime.uploaded_file_manager import UploadedFile
+
+def generate_random_md5():
+    # Generate a random string
+    random_string = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
+    # Encode the string and compute its MD5 hash
+    md5_hash = hashlib.md5(random_string.encode()).hexdigest()
+    return md5_hash
+
+def is_valid_number(number:str) -> bool:
+    """
+    Check if the given string is a valid number (int or float, sign ok)
+
+    Args:
+        number (str): The string to be checked.
+
+    Returns:
+        bool: True if the string is a valid number, False otherwise.
+    """
+    pattern = r'^[-+]?[0-9]*\.?[0-9]+$'
+    return re.match(pattern, number) is not None
+
+# Function to validate email address
+def is_valid_email(email:str) -> bool:
+    """
+    Validates if the provided email address is in a correct format.
+
+    Args:
+        email (str): The email address to validate.
+
+    Returns:
+        bool: True if the email address is valid, False otherwise.
+    """
+    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    return re.match(pattern, email) is not None
+
+# Function to extract date and time from image metadata
+def get_image_datetime(image_file): 
+    """
+    Extracts the original date and time from the EXIF metadata of an uploaded image file.
+
+    Args:
+        image_file (UploadedFile): The uploaded image file from which to extract the date and time.
+
+    Returns:
+        str: The original date and time as a string if available, otherwise None.
+
+    Raises:
+        Warning: If the date and time could not be extracted from the image metadata.
+    """
+    try:
+        image = Image.open(image_file)
+        exif_data = image._getexif()
+        if exif_data is not None:
+            if ExifTags.Base.DateTimeOriginal in exif_data:
+                return exif_data.get(ExifTags.Base.DateTimeOriginal)
+    except Exception as e: # FIXME: what types of exception?
+         st.warning(f"Could not extract date from image metadata. (file: {image_file.name})")
+         # TODO: add to logger
+    return None
+
+def decimal_coords(coords:tuple, ref:str) -> Fraction:
+    """
+    Converts coordinates from degrees, minutes, and seconds to decimal degrees.
+
+    Args:
+        coords (tuple): A tuple containing three elements representing degrees, minutes, and seconds.
+        ref (str): A string representing the reference direction ('N', 'S', 'E', 'W').
+
+    Returns:
+        Fraction: The coordinates in decimal degrees. Negative if the reference is 'S' or 'W'.
+
+    Example:
+        decimal_coords((40, 26, 46), 'N') -> 40.44611111111111
+        decimal_coords((40, 26, 46), 'W') -> -40.44611111111111
+    """
+    # https://stackoverflow.com/a/73267185
+    if ref not in ['N', 'S', 'E', 'W']:
+        raise ValueError("Invalid reference direction. Must be 'N', 'S', 'E', or 'W'.")
+    if len(coords) != 3:
+        raise ValueError("Coordinates must be a tuple of three elements (degrees, minutes, seconds).")
+    
+    decimal_degrees = coords[0] + coords[1] / 60 + coords[2] / 3600
+    if ref == "S" or ref =='W':
+        decimal_degrees = -decimal_degrees
+    return decimal_degrees
+
+
+def get_image_latlon(image_file: UploadedFile) -> tuple[float, float] | None:
+    """
+    Extracts the latitude and longitude from the EXIF metadata of an uploaded image file.
+
+    Args:
+        image_file (UploadedFile): The uploaded image file from which to extract the latitude and longitude.
+
+    Returns:
+        tuple[float, float]: The latitude and longitude as a tuple if available, otherwise None.
+
+    Raises:
+        Warning: If the latitude and longitude could not be extracted from the image metadata.
+    """
+    try:
+        image = Image.open(image_file)
+        exif_data = image._getexif()
+        if exif_data is not None:
+            if ExifTags.Base.GPSInfo in exif_data:
+                gps_ifd = exif_data.get(ExifTags.Base.GPSInfo) 
+                
+                lat = float(decimal_coords(gps_ifd[ExifTags.GPS.GPSLatitude], gps_ifd[ExifTags.GPS.GPSLatitudeRef]))
+                lon = float(decimal_coords(gps_ifd[ExifTags.GPS.GPSLongitude], gps_ifd[ExifTags.GPS.GPSLongitudeRef]))
+            
+                return lat, lon
+            
+    except Exception as e: # FIXME: what types of exception?
+         st.warning(f"Could not extract latitude and longitude from image metadata. (file: {str(image_file)}")

src/main.py

@@ -1,31 +1,25 @@
-#import datetime
-from PIL import Image
-
-import json
 import logging
 import os
-import tempfile
 
 import pandas as pd
 import streamlit as st
-from streamlit.delta_generator import DeltaGenerator # for type hinting
 import folium
 from streamlit_folium import st_folium
-from huggingface_hub import HfApi
+
 from transformers import pipeline
 from transformers import AutoModelForImageClassification
 
 from datasets import disable_caching
 disable_caching()
 
-import alps_map as sw_am
-import input_handling as sw_inp
-import obs_map as sw_map
-import st_logs as sw_logs
-import whale_gallery as sw_wg
-import whale_viewer as sw_wv
-
-
+import whale_gallery as gallery
+import whale_viewer as viewer
+from input.input_handling import setup_input
+from maps.alps_map import present_alps_map
+from maps.obs_map import present_obs_map
+from utils.st_logs import setup_logging, parse_log_buffer
+from classifier.classifier_image import cetacean_classify
+from classifier.classifier_hotdog import hotdog_classify
 
 
 # setup for the ML model on huggingface (our wrapper)
@@ -45,96 +39,40 @@ g_logger = logging.getLogger(__name__)
 g_logger.setLevel(LOG_LEVEL)
 
 st.set_page_config(layout="wide")
-#sw_logs.setup_logging(level=LOG_LEVEL, buffer_len=40)
-
-
 
 # initialise various session state variables
 if "handler" not in st.session_state:
-    st.session_state['handler'] = sw_logs.setup_logging()
+    st.session_state['handler'] = setup_logging()
+
+if "observations" not in st.session_state:
+    st.session_state.observations = {}
+
+if "images" not in st.session_state:
+    st.session_state.images = {}
 
-if "full_data" not in st.session_state:
-    st.session_state.full_data = {}
+if "files" not in st.session_state:
+    st.session_state.files = {}
+
+if "public_observation" not in st.session_state:
+    st.session_state.public_observation = {}
 
 if "classify_whale_done" not in st.session_state:
     st.session_state.classify_whale_done = False
 
 if "whale_prediction1" not in st.session_state:
     st.session_state.whale_prediction1 = None
-    
-if "image" not in st.session_state:
-    st.session_state.image = None
 
 if "tab_log" not in st.session_state:
     st.session_state.tab_log = None
     
 
-def metadata2md() -> str:
-    """Get metadata from cache and return as markdown-formatted key-value list
-
-    Returns:
-        str: Markdown-formatted key-value list of metadata
-        
-    """
-    markdown_str = "\n"
-    for key, value in st.session_state.full_data.items():
-            markdown_str += f"- **{key}**: {value}\n"
-    return markdown_str
-
-
-def push_observation(tab_log:DeltaGenerator=None):
-    """
-    Push the observation to the Hugging Face dataset
-    
-    Args:
-        tab_log (streamlit.container): The container to log messages to. If not provided,
-            log messages are in any case written to the global logger (TODO: test - didn't 
-            push any data since generating the logger)
-    
-    """
-    # we get the data from session state: 1 is the dict 2 is the image.
-    # first, lets do an info display (popup)
-    metadata_str = json.dumps(st.session_state.full_data)
-    
-    st.toast(f"Uploading observation: {metadata_str}", icon="🦭")
-    tab_log = st.session_state.tab_log
-    if tab_log is not None:
-        tab_log.info(f"Uploading observation: {metadata_str}")
-        
-    # get huggingface api
-    import os 
-    token = os.environ.get("HF_TOKEN", None)
-    api = HfApi(token=token)
-
-    f = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
-    f.write(metadata_str)
-    f.close()
-    st.info(f"temp file: {f.name} with metadata written...")
-
-    path_in_repo= f"metadata/{st.session_state.full_data['author_email']}/{st.session_state.full_data['image_md5']}.json"
-    msg = f"fname: {f.name} | path: {path_in_repo}"
-    print(msg)
-    st.warning(msg)
-    rv = api.upload_file(
-        path_or_fileobj=f.name,
-        path_in_repo=path_in_repo,
-        repo_id="Saving-Willy/temp_dataset",
-        repo_type="dataset",
-    )
-    print(rv)
-    msg = f"data attempted tx to repo happy walrus: {rv}"
-    g_logger.info(msg)
-    st.info(msg)
-    
-
-
 def main() -> None:
     """
     Main entry point to set up the streamlit UI and run the application.
 
     The organisation is as follows:
 
-    1. data input (a new observation) is handled in the sidebar
+    1. observation input (a new observations) is handled in the sidebar
     2. the rest of the interface is organised in tabs:
     
         - cetean classifier
@@ -156,26 +94,25 @@ def main() -> None:
     #g_logger.warning("warning message")
 
     # Streamlit app
-    #tab_gallery, tab_inference, tab_hotdogs, tab_map, tab_coords, tab_log = st.tabs(["Cetecean classifier", "Hotdog classifier", "Map", "Data", "Log", "Beautiful cetaceans"])
     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"])
     st.session_state.tab_log = tab_log
 
 
-    # create a sidebar, and parse all the input (returned as `observation` object)
-    observation = sw_inp.setup_input(viewcontainer=st.sidebar)
+    # create a sidebar, and parse all the input (returned as `observations` object)
+    observations = setup_input(viewcontainer=st.sidebar)
 
         
     if 0:## WIP
-        # goal of this code is to allow the user to override the ML prediction, before transmitting an observation
-        predicted_class = st.sidebar.selectbox("Predicted Class", sw_wv.WHALE_CLASSES)
+        # goal of this code is to allow the user to override the ML prediction, before transmitting an observations
+        predicted_class = st.sidebar.selectbox("Predicted Class", viewer.WHALE_CLASSES)
         override_prediction = st.sidebar.checkbox("Override Prediction")
 
         if override_prediction:
-            overridden_class = st.sidebar.selectbox("Override Class", sw_wv.WHALE_CLASSES)
-            st.session_state.full_data['class_overriden'] = overridden_class
+            overridden_class = st.sidebar.selectbox("Override Class", viewer.WHALE_CLASSES)
+            st.session_state.observations['class_overriden'] = overridden_class
         else:
-            st.session_state.full_data['class_overriden'] = None
+            st.session_state.observations['class_overriden'] = None
 
 
     with tab_map:
@@ -190,19 +127,19 @@ def main() -> None:
             
         if show_db_points:
             # show a nicer map, observations marked, tileset selectable.
-            st_data = sw_map.present_obs_map(
+            st_observation = present_obs_map(
                 dataset_id=dataset_id, data_files=data_files,
                 dbg_show_extra=dbg_show_extra)
             
         else:
             # development map.
-            st_data = sw_am.present_alps_map()
+            st_observation = present_alps_map()
             
 
     with tab_log:
         handler = st.session_state['handler']
         if handler is not None:
-            records = sw_logs.parse_log_buffer(handler.buffer)
+            records = parse_log_buffer(handler.buffer)
             st.dataframe(records[::-1], use_container_width=True,)
             st.info(f"Length of records: {len(records)}")
         else:
@@ -236,22 +173,16 @@ def main() -> None:
         # specific to the gallery (otherwise we get side effects)
         tg_cont = st.container(key="swgallery")
         with tg_cont:
-            sw_wg.render_whale_gallery(n_cols=4)
+            gallery.render_whale_gallery(n_cols=4)
         
 
-    # Display submitted data
+    # Display submitted observation
     if st.sidebar.button("Validate"):
-        # create a dictionary with the submitted data
-        submitted_data = observation.to_dict()
-        #print(submitted_data)
-        
-        #full_data.update(**submitted_data)
-        for k, v in submitted_data.items():
-            st.session_state.full_data[k] = v
+        # create a dictionary with the submitted observation
+        submitted_data = observations
+        st.session_state.observations = observations
             
-        #st.write(f"full dict of data: {json.dumps(submitted_data)}")
-        #tab_inference.info(f"{st.session_state.full_data}")
-        tab_log.info(f"{st.session_state.full_data}")
+        tab_log.info(f"{st.session_state.observations}")
 
         df = pd.DataFrame(submitted_data, index=[0])
         with tab_coords:
@@ -278,49 +209,12 @@ def main() -> None:
                                                                             trust_remote_code=True)
 
         
-        if st.session_state.image is None:
+        if st.session_state.images is None:
             # TODO: cleaner design to disable the button until data input done?
             st.info("Please upload an image first.")
         else:
-            # run classifier model on `image`, and persistently store the output
-            out = cetacean_classifier(st.session_state.image) # get top 3 matches
-            st.session_state.whale_prediction1 = out['predictions'][0]
-            st.session_state.classify_whale_done = True
-            msg = f"[D]2 classify_whale_done: {st.session_state.classify_whale_done}, whale_prediction1: {st.session_state.whale_prediction1}"
-            st.info(msg)
-            g_logger.info(msg)
-            
-            # dropdown for selecting/overriding the species prediction
-            #st.info(f"[D] classify_whale_done: {st.session_state.classify_whale_done}, whale_prediction1: {st.session_state.whale_prediction1}")
-            if not st.session_state.classify_whale_done:
-                selected_class = tab_inference.sidebar.selectbox("Species", sw_wv.WHALE_CLASSES, index=None, placeholder="Species not yet identified...", disabled=True)
-            else:
-                pred1 = st.session_state.whale_prediction1
-                # get index of pred1 from WHALE_CLASSES, none if not present
-                print(f"[D] pred1: {pred1}")
-                ix = sw_wv.WHALE_CLASSES.index(pred1) if pred1 in sw_wv.WHALE_CLASSES else None
-                selected_class = tab_inference.selectbox("Species", sw_wv.WHALE_CLASSES, index=ix)
-            
-            st.session_state.full_data['predicted_class'] = selected_class
-            if selected_class != st.session_state.whale_prediction1:
-                st.session_state.full_data['class_overriden'] = selected_class
+            cetacean_classify(cetacean_classifier)
                 
-            btn = st.button("Upload observation to THE INTERNET!", on_click=push_observation)
-            # TODO: the metadata only fills properly if `validate` was clicked.
-            tab_inference.markdown(metadata2md())
-
-            msg = f"[D] full data after inference: {st.session_state.full_data}"
-            g_logger.debug(msg)
-            print(msg)
-            # TODO: add a link to more info on the model, next to the button.
-
-            whale_classes = out['predictions'][:]
-            # render images for the top 3 (that is what the model api returns)
-            with tab_inference:
-                st.markdown("## Species detected")
-                for i in range(len(whale_classes)):
-                    sw_wv.display_whale(whale_classes, i)
-            
         
 
         
@@ -340,27 +234,10 @@ def main() -> None:
 
         if st.session_state.image is None:
             st.info("Please upload an image first.")
-            st.info(str(observation.to_dict()))
+            #st.info(str(observations.to_dict()))
             
         else:
-            col1, col2 = tab_hotdogs.columns(2)
-
-            # display the image (use cached version, no need to reread)
-            col1.image(st.session_state.image, use_column_width=True)
-            # and then run inference on the image
-            hotdog_image = Image.fromarray(st.session_state.image)
-            predictions = pipeline_hot_dog(hotdog_image)
-
-            col2.header("Probabilities")
-            first = True
-            for p in predictions:
-                col2.subheader(f"{ p['label'] }: { round(p['score'] * 100, 1)}%")
-                if first:
-                    st.session_state.full_data['predicted_class'] = p['label']
-                    st.session_state.full_data['predicted_score'] = round(p['score'] * 100, 1)
-                    first = False
-            
-            tab_hotdogs.write(f"Session Data: {json.dumps(st.session_state.full_data)}")
+            hotdog_classify(pipeline_hot_dog, tab_hotdogs)
             
             
 

src/{obs_map.py → maps/obs_map.py}

@@ -7,8 +7,8 @@ import streamlit as st
 import folium
 from streamlit_folium import st_folium
 
-import whale_viewer as sw_wv
-from fix_tabrender import js_show_zeroheight_iframe
+import whale_viewer as viewer
+from utils.fix_tabrender import js_show_zeroheight_iframe
 
 m_logger = logging.getLogger(__name__)
 # we can set the log level locally for funcs in this module
@@ -60,7 +60,7 @@ _colors = [
     "#778899" # Light Slate Gray
 ]
 
-whale2color = {k: v for k, v in zip(sw_wv.WHALE_CLASSES, _colors)}
+whale2color = {k: v for k, v in zip(viewer.WHALE_CLASSES, _colors)}
 
 def create_map(tile_name:str, location:Tuple[float], zoom_start: int = 7) -> folium.Map:
     """

src/utils/grid_maker.py

@@ -0,0 +1,13 @@
+import streamlit as st
+import math
+
+def gridder(files):
+    cols = st.columns(3)
+    with cols[0]:
+        batch_size = st.select_slider("Batch size:",range(10,110,10), value=10)
+    with cols[1]:
+        row_size = st.select_slider("Row size:", range(1,6), value = 5)
+    num_batches = math.ceil(len(files)/batch_size)
+    with cols[2]:
+        page = st.selectbox("Page", range(1,num_batches+1))
+    return batch_size, row_size, page

src/utils/metadata_handler.py

@@ -0,0 +1,16 @@
+import streamlit as st
+
+def metadata2md() -> str:
+    """Get metadata from cache and return as markdown-formatted key-value list
+
+    Returns:
+        str: Markdown-formatted key-value list of metadata
+        
+    """
+    markdown_str = "\n"
+    keys_to_print = ["latitude","longitude","author_email","date","time"]
+    for key, value in st.session_state.public_observation.items():
+            if key in keys_to_print:
+                markdown_str += f"- **{key}**: {value}\n"
+    return markdown_str
+

src/whale_viewer.py

@@ -1,4 +1,5 @@
 from typing import List
+import streamlit as st
 from streamlit.delta_generator import DeltaGenerator
 
 from PIL import Image
@@ -133,7 +134,7 @@ def display_whale(whale_classes:List[str], i:int, viewcontainer:DeltaGenerator=N
         None
     
     """
-    import streamlit as st
+    
     if viewcontainer is None:
         viewcontainer = st
 
@@ -147,11 +148,10 @@ def display_whale(whale_classes:List[str], i:int, viewcontainer:DeltaGenerator=N
     
     
     viewcontainer.markdown(
-        "### :whale:  #" + str(i + 1) + ": " + format_whale_name(whale_classes[i])
+        ":whale:  #" + str(i + 1) + ": " + format_whale_name(whale_classes[i])
     )
     current_dir = os.getcwd()
     image_path = os.path.join(current_dir, "src/images/references/")
     image = Image.open(image_path + df_whale_img_ref.loc[whale_classes[i], "WHALE_IMAGES"])
 
-    viewcontainer.image(image, caption=df_whale_img_ref.loc[whale_classes[i], "WHALE_REFERENCES"])
-    # link st.markdown(f"[{df.loc[whale_classes[i], 'WHALE_REFERENCES']}]({df.loc[whale_classes[i], 'WHALE_REFERENCES']})")
+    viewcontainer.image(image, caption=df_whale_img_ref.loc[whale_classes[i], "WHALE_REFERENCES"], use_column_width=True)

tests/test_input_handling.py

@@ -2,7 +2,7 @@ import pytest
 from pathlib import Path
 
 from input_handling import is_valid_email, is_valid_number
-from input_handling import get_image_datetime, get_image_latlon, decimal_coords
+from input.input_validator import get_image_latlon, decimal_coords, get_image_datetime
 
 # generate tests for is_valid_email
 # - test with valid email