Handle errors from sageranger due to invalid authorization token

config/fetch_and_alert.yml

@@ -13,11 +13,11 @@ detector_model_type: "<insert model type>"
 #classifier_model - path to classifier model
 classifier_model: /home/johnsmith/cougarvision/classifier_models/EfficientNetB5_456_Unfrozen_05_0.26_0.92.h5 
 checkpoint_frequency: -1 
-#log_dir - path to logs (must create this folder first)
+#log_dir - path to logs 
 log_dir: /home/johnsmith/cougarvision/logs/
 #classes - path to the class list for the classifier model
 classes: /home/johnsmith/cougarvision/labels/sw_classes.txt 
-#Run version that allows for images cast to two screens? True/False
+#Run version that allows for images cast to two screens True/False
 visualize_output: True
 #for visualizing output, folder for cougarvision to put all images
 path_to_unlabeled_output: /path/to/unlabeled/img/folder
@@ -34,9 +34,13 @@ threads: 8
 #strike force api url
 strikeforce_api: https://api.strikeforcewireless.com/api/v2/
 #strikeforce wireless username 
-username_scraper: yourusername.cam@gmail.com
+#formmatt matters here
+username_scraper: ['yourusername.cam@gmail.com']
 #strikeforce wireless password
-password_scraper: yourpassword
+password_scraper: ['yourpassword']
+# without brackets
+username: youremail@gmail.com
+password: yourpassword
 #authorization token from Strike Force
 auth_token: <must get from web dev tools after strikeforcewireless login>
 #save_dir - path to where the images get stored (must create folder)

cougarvision_utils/alert.py

@@ -8,56 +8,60 @@
 '''
 
 import mimetypes
+import logging 
 from email.message import EmailMessage
 from smtplib import SMTP_SSL, SMTP_SSL_PORT
 from datetime import datetime as dt
 
 
 def smtp_setup(username, password, host):
-    '''SMTP Setup
+    """SMTP Setup
 
     This function creates a simple mail transfer protocol by taking in a
     host email, a username and password for an email.
 
     Args:
-    username: username for email to send message from, string from config
-    password: password for email message will be sent from, string from config
-    host: IMAP protocol to download gmail messages, initialized in
-    detect_img.py
-
-    Returns: SMTP_SSL object logged into the mailing account specified in
-    config yml
-    '''
+    username (str): username for email to send message from
+        string from config
+    password (str): password for email message will be sent from,
+        string from config
+    host (str): IMAP protocol to download gmail messages, initialized in
+        detect_img.py
+
+    Returns:
+    SMTP_SSL object logged into the mailing account specified in
+        config yml
+    """
     # Init sending mail
     smtp_server = SMTP_SSL(host, port=SMTP_SSL_PORT)
     smtp_server.set_debuglevel(1)  # Show SMTP server interactions
     smtp_server.login(username, password)
     return smtp_server
 
 
-def send_alert(alert, img, smtp_server, from_email, to_emails, dev, conf):
-    '''Send Alert
+def send_alert(config, alert, img, dev, prob):
+    """Send Alert
 
     This function takes in the animal label, the image of the animal of
     interest, the SMTP server created, and the to and from emails to send
     the alert containing that specific image along with the confidence value.
 
     Args:
-    alert: label of animal that the alert is being created for
-    conf: confidence value of the classifier that the animal it says it
-    is is the animal it is
-    img: the PIL.Image of the image that is to be sent, to be converted
-    to binary
-    smtp_server: where the email is to be sent from, SMTP_SSL object
-    from_email: the outgoing address for the alert
-    to_emails: the emails the alert will be sent to, defined in config yml file
-    '''
+    alert (str): label of animal that the alert is being created for
+    conf (float): confidence value of the classifier that the animal it says it
+        is is the animal it is
+    img(bytes): the PIL.Image of the image that is to be sent, to be converted
+        to binary
+    config (dict): holds the values of username, password, host,
+        dev/consumeremails for email setup and info for recipients.
+    """
     # Construct Email Content
     email_message = EmailMessage()
-    email_message.add_header('To', ', '.join(to_emails))
-    email_message.add_header('From', from_email)
-    email_message.add_header('Subject', 'Alert!')
-    email_message.add_header('X-Priority', '1')  # Urgency, 1 highest, 5 lowest
+    email_message['To'] = (', '.join(config.consumer_emails))
+    email_message['from'] = config.username
+    email_message['Subject'] = 'Alert!'
+    email_message['X-Priority'] = '1'  # Urgency, 1 highest, 5 lowest
+    message = ""
     if dev == 0:
         message = "Potential " + alert + " detected by CougarVision "\
                   + "system.\n\nPlease review attached image to verify"\
@@ -66,36 +70,48 @@ def send_alert(alert, img, smtp_server, from_email, to_emails, dev, conf):
                   + "and artifacts have been known to trigger the system."
     elif dev != 0:
         message = "Potential " + alert + " detected with confidence value: "\
-                  + conf
-
-    email_message.set_content(message)
+                  + prob 
 
     # Prepare Image format
     binary_data = img.getvalue()
 
     # Attach image to email
     filename = 'detection.jpg'
+    email_message.set_content(message)
+
     maintype, _, subtype = (mimetypes.guess_type(filename)[0] or
                             'application/octet-stream').partition("/")
+
     email_message.add_attachment(binary_data, maintype=maintype,
                                  subtype=subtype, filename=filename)
 
     # Server sends email message
-    server = smtp_server
+    server = smtp_setup(config.username, config.password, config.host)
     server.send_message(email_message)
+    logging.info("Email Alert sent.")
+    server.quit()
 
 
-def checkin(to_emails, username, password, host):
-    '''Sends server status to specified email at specified time interval'''
+def checkin(config):
+    """Sends server status to specified email at specified time interval
+
+    Args:
+    config (dict): holds the values of username, password, host,
+        dev/consumeremails for email setup and info for recipients.
+    """
     print("Checking in at: " + str(dt.now()))
+
     # Construct Email Content
     email_message = EmailMessage()
-    email_message.add_header('To', ', '.join(to_emails))
-    email_message.add_header('From', username)
-    email_message.add_header('Subject', 'Checkin')
+    email_message['To'] = ', '.join(config.dev_emails)
+    email_message['from'] = config.username
+    email_message['Subject'] = 'Checkin'
     email_message.add_header('X-Priority', '1')  # Urgency, 1 highest, 5 lowest
-    email_message.set_content('Still Alive :)')
+    message = "still Alive :) "
+    email_message.set_content(message)
+
     # Server sends email message
-    smtp_server = smtp_setup(username, password, host)
-    server = smtp_server
+    server = smtp_setup(config.username, config.password, config.host)
     server.send_message(email_message)
+    logging.info("Checkin email sent.")
+    server.quit()

cougarvision_utils/detect_img.py

@@ -11,15 +11,14 @@
 
 from io import BytesIO
 from datetime import datetime as dt
-import re
 import os
+import logging
 from PIL import Image
-from animl import classification, split
-from animl import detection
+import animl
 from sageranger import is_target, attach_image, post_event
 
 from cougarvision_utils.cropping import draw_bounding_box_on_image
-from cougarvision_utils.alert import smtp_setup, send_alert
+from cougarvision_utils.alert import send_alert
 
 
 def detect(images, config):  # pylint: disable=too-many-locals
@@ -47,7 +46,7 @@ def detect(images, config):  # pylint: disable=too-many-locals
         # confidendce and checkpoint frequency
         conf = config.confidence
         ch_f = config.checkpoint_frequency
-        results = detection.detect(config.detector_model_load,
+        results = animl.detect(config.detector_model_load,
                                    image_path_list,
                                    resize_width=1280,
                                    resize_height=1280,
@@ -56,26 +55,26 @@ def detect(images, config):  # pylint: disable=too-many-locals
                                    batch_size=4
                                    )
         # Parse results
-        data_frame = detection.parse_detections(results)
+        data_frame = animl.parse_detections(results)
         # single classification function checks for the file
         # extension so we add it
         data_frame["extension"] = data_frame["filepath"].str.extract(
                                             r'(\.[^.]+)$',
                                             expand=False).str.lower()
         # filter out all non animal detections
         if not data_frame.empty:
-            animal_df = split.get_animals(data_frame)
-            # other_df = split.get_empty(data_frame)
+            animal_df = animl.get_animals(data_frame) 
+
             # run classifier on animal detections if there are any
             if not animal_df.empty:
                 classifer_model = config.classifier_model_load
-                predictions_raw = classification.classify(classifer_model,
+                predictions_raw = animl.classify(classifer_model,
                                                           animal_df,
                                                           batch_size=4
                                                           )
                 # single classification expects a list
                 class_list_series = config.class_list["species"].tolist()
-                preds = classification.single_classification(animal_df,
+                preds = animl.single_classification(animal_df,
                                                              None,
                                                              predictions_raw,
                                                              class_list_series
@@ -87,8 +86,10 @@ def detect(images, config):  # pylint: disable=too-many-locals
                 cougars = cougars.reset_index(drop=True)
                 # create a row in the dataframe containing only the camera name
                 # flake8: disable-next
-                cougars['cam_name'] = cougars['filepath'].apply(
-                    lambda x: re.findall(r'[A-Z]\d+', x)[0])
+               # print("######Cougars:",cougars)
+                #cougars['cam_name'] = cougars['filepath'].apply(
+                #    lambda x: re.findall(r'[A-Z]\d+', x)[0])
+                cougars["cam_name"] = cougars["filepath"].str.extract(r"([A-Z]\d+)")
                 # Sends alert for each cougar detection
                 for idx in range(len(cougars.index)):
                     label = cougars.at[idx, 'prediction']
@@ -127,34 +128,43 @@ def detect(images, config):  # pylint: disable=too-many-locals
                     cam_name = cougars.at[idx, 'cam_name']
                     er_alerts = config.er_alerts
                     if label in config.alert_targets and er_alerts is True:
-                        is_target(cam_name,
-                                  config.authorization, label)
+                        try:
+                            is_target(cam_name,
+                                      config.authorization,
+                                      label)
+                        except KeyError as e:
+                            logging.warning("Invalid authorization token missing key: %s", str(e))
+                            print("Invalid authorization",
+                                  f"token missing key {e}")
+
                     # Email or Earthranger alerts as dictated in the config yml
                     if config.er_alerts is True:
-                        event_id = post_event(label,
-                                              cam_name,
-                                              config.authorization)
-                        response = attach_image(event_id,
-                                                img_byte,
-                                                config.authorization,
-                                                label)
-                        print(response)
+                        try:
+                            event_id = post_event(label,
+                                                  cam_name,
+                                                  config.authorization)
+                            response = attach_image(event_id,
+                                                    img_byte,
+                                                    config.authorization,
+                                                    label)
+                            logging.info("Posted event on earthranger with associated img.")
+                            print(response)
+                        except KeyError as e:
+                            logging.warning("Invalid authorization token missing key: %s", str(e))
+                            print("Invalid authorization.",
+                                  f"token missing key {e}")
+
                     if config.email_alerts is True:
-                        smtp_server = smtp_setup(config.username,
-                                                 config.password,
-                                                 config.host
-                                                 )
                         dev = 0
-                        send_alert(label, image_bytes, smtp_server,
-                                   config.username, config.consumer_emails,
-                                   dev, prob
-                                   )
+                        send_alert(config,label,image_bytes,
+                                   dev, prob)
                         dev = 1
-                        send_alert(label, image_bytes, smtp_server,
-                                   config.username, config.dev_emails,
+                        send_alert(config,label, image_bytes,
                                    dev, prob)
 
                 # Write Dataframe to csv
                 current_date = dt.now()
                 formatted_dt = current_date.strftime("%m-%d-%Y_%H:%M:%S")
-                cougars.to_csv(f'{config.log_dir}dataframe_{formatted_dt}')
+                logs = config.log_dir
+                os.makedirs(logs, exist_ok=True)
+                cougars.to_csv(f'{logs}dataframe_{formatted_dt}')