boris-behav-obs 8.9.16__py3-none-any.whl → 9.7.6__py3-none-any.whl

boris/observations_list.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 
   This program is free software; you can redistribute it and/or modify
@@ -21,8 +21,8 @@ Copyright 2012-2023 Olivier Friard
 
 """
 
-from PyQt5.QtGui import QColor
-from PyQt5.QtWidgets import (
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
     QTableWidgetItem,
     QLabel,
     QLineEdit,
@@ -50,12 +50,21 @@ class MyTableWidgetItem(QTableWidgetItem):
 
     # Qt uses a simple < check for sorting items, override this to use the sortKey
     def __lt__(self, other):
-        return self.sortKey < other.sortKey
+        if isinstance(self.sortKey, str) and isinstance(other.sortKey, str):
+            return self.sortKey.lower() < other.sortKey.lower()
+        else:
+            return self.sortKey < other.sortKey
 
 
 class observationsList_widget(QDialog):
-    def __init__(self, data: list, header: list, column_type: list, not_paired: list = [], parent=None):
-
+    def __init__(
+        self,
+        data: list,
+        header: list,
+        column_type: list,
+        not_paired: list = [],
+        parent=None,
+    ):
         super(observationsList_widget, self).__init__(parent)
 
         self.data = data
@@ -78,7 +87,17 @@ class observationsList_widget(QDialog):
 
         self.cbLogic = QComboBox(self)
         self.cbLogic.addItems(
-            ["contains", "does not contain", "=", "!=", ">", "<", ">=", "<=", "between (use and to separate terms)"]
+            [
+                "contains",
+                "does not contain",
+                "=",
+                "!=",
+                ">",
+                "<",
+                ">=",
+                "<=",
+                "between (use and to separate terms)",
+            ]
         )
         self.cbLogic.currentIndexChanged.connect(self.view_filter)
 
@@ -105,7 +124,7 @@ class observationsList_widget(QDialog):
         self.pbUnSelectAll.clicked.connect(lambda: self.pbSelection_clicked("unselect"))
         hbox2.addWidget(self.pbUnSelectAll)
 
-        self.pbCancel = QPushButton("Cancel", clicked=self.pbCancel_clicked)
+        self.pbCancel = QPushButton(cfg.CANCEL, clicked=self.pbCancel_clicked)
         hbox2.addWidget(self.pbCancel)
 
         self.pbOpen = QPushButton("Start", clicked=self.pbOpen_clicked)
@@ -117,7 +136,7 @@ class observationsList_widget(QDialog):
         self.pbEdit = QPushButton("Edit", clicked=self.pbEdit_clicked)
         hbox2.addWidget(self.pbEdit)
 
-        self.pbOk = QPushButton("OK", clicked=self.pbOk_clicked)
+        self.pbOk = QPushButton(cfg.OK, clicked=self.pbOk_clicked)
         hbox2.addWidget(self.pbOk)
 
         self.gridLayout.addLayout(hbox2, 3, 0, 1, 3)
@@ -142,7 +161,6 @@ class observationsList_widget(QDialog):
         self.label.setText(f"{self.view.rowCount()} observation{'s' * (self.view.rowCount() > 1)}")
 
     def view_doubleClicked(self, index):
-
         if self.mode == cfg.MULTIPLE:
             return
 
@@ -155,7 +173,9 @@ class observationsList_widget(QDialog):
             return
 
         response = dialog.MessageDialog(
-            cfg.programName, "What do you want to do with this observation?", list(commands_index.keys()) + [cfg.CANCEL]
+            cfg.programName,
+            "What do you want to do with this observation?",
+            list(commands_index.keys()) + [cfg.CANCEL],
         )
         if response == cfg.CANCEL:
             return
@@ -166,10 +186,10 @@ class observationsList_widget(QDialog):
         """
         select or unselect all filtered observations
         """
-
-        for idx in range(self.view.rowCount()):
-            table_item = self.view.item(idx, 0)
-            table_item.setSelected(mode == "select")
+        if mode == "select":
+            self.view.selectAll()
+        if mode == "unselect":
+            self.view.clearSelection()
 
     def pbCancel_clicked(self):
         self.close()
@@ -187,7 +207,6 @@ class observationsList_widget(QDialog):
         self.done(4)
 
     def set_item(self, r, c):
-
         if self.column_type[c] == cfg.NUMERIC:
             try:
                 item = MyTableWidgetItem(self.data[r][c], float(self.data[r][c]))
@@ -208,7 +227,7 @@ class observationsList_widget(QDialog):
         filter
         """
 
-        def str2float(s):
+        def str2float(s: str):
             """
             convert str in float or return str
             """
@@ -223,60 +242,60 @@ class observationsList_widget(QDialog):
         def not_in(s, lst):
             return s not in lst
 
-        def equal(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num == s_num
+        def equal(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num == s_num
             else:
-                return l == s
+                return x == s
 
-        def not_equal(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num != s_num
+        def not_equal(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num != s_num
             else:
-                return l != s
+                return x != s
 
-        def gt(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num > s_num
+        def gt(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num > s_num
             else:
-                return l > s
+                return x > s
 
-        def lt(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num < s_num
+        def lt(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num < s_num
             else:
-                return l < s
+                return x < s
 
-        def gt_or_equal(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num >= s_num
+        def gt_or_equal(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num >= s_num
             else:
-                return l >= s
+                return x >= s
 
-        def lt_or_equal(s, l):
-            l_num, s_num = str2float(l), str2float(s)
-            if type(l_num) == type(s_num):
-                return l_num <= s_num
+        def lt_or_equal(s, x):
+            x_num, s_num = str2float(x), str2float(s)
+            if type(x_num) == type(s_num):
+                return x_num <= s_num
             else:
-                return l <= s
+                return x <= s
 
-        def between(s, l):
+        def between(s, x):
             if len(s.split(" AND ")) != 2:
                 return None
             s1, s2 = s.split(" AND ")
             s1_num, s2_num = str2float(s1), str2float(s2)
             if type(s1_num) != type(s2_num):
                 return None
-            l_num = str2float(l)
-            if type(s1_num) == type(l_num):
-                return l_num >= s1_num and l_num <= s2_num
+            x_num = str2float(x)
+            if type(s1_num) == type(x_num):
+                return s1_num <= x_num <= s2_num
             else:
-                return l >= s1 and l <= s2
+                return s1 <= x <= s2
 
         if not self.lineEdit.text():
             self.view.setRowCount(len(self.data))
@@ -286,7 +305,6 @@ class observationsList_widget(QDialog):
                     self.view.setItem(r, c, self.set_item(r, c))
 
         else:
-
             if self.cbLogic.currentText() == "contains":
                 logic = in_
             if self.cbLogic.currentText() == "does not contain":

boris/otx_parser.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -30,15 +30,16 @@ import re
 import zipfile
 import pathlib as pl
 from xml.dom import minidom
-import pprint
+import logging
+from typing import Tuple
 
 try:
     from . import config as cfg
-except:
+except Exception:
     import config as cfg
 
 
-def otx_to_boris(file_path: str) -> dict:
+def otx_to_boris(file_path: str) -> Tuple[dict, list]:
     """
     convert otx/otb/odx file in a BORIS project
 
@@ -49,6 +50,7 @@ def otx_to_boris(file_path: str) -> dict:
 
     Returns:
         dict: BORIS project
+        list: list of errors during importation
     """
 
     if pl.Path(file_path).suffix == ".otb":
@@ -57,26 +59,27 @@ def otx_to_boris(file_path: str) -> dict:
             if files_list:
                 try:
                     file_zip.extract(files_list[0])
-                except:
-                    return {"error": "error when extracting file"}
+                except Exception:
+                    return {"fatal": True}, ["Error when extracting file from OTB"]
             else:
-                return {"error": "error when extracting file"}
+                return {"fatal": True}, ["Error when extracting file"]
 
             try:
                 xmldoc = minidom.parse(files_list[0])
-            except:
-                return {"error": "parsing error"}
+            except Exception:
+                return {"fatal": True}, ["XML parsing error"]
 
     elif pl.Path(file_path).suffix in (".odx", ".otx"):
         try:
             xmldoc = minidom.parse(file_path)
-        except:
-            return {"error": "parsing error"}
+        except Exception:
+            return {"fatal": True}, ["XML parsing error"]
 
     else:
-        return {"error": "The file must be in OTB, OTX or ODX format"}
+        return {"fatal": True}, ["The file must be in OTB, OTX or ODX format"]
 
-    flag_long_key = False
+    flag_long_key: bool = False
+    error_list: list = []
 
     # metadata
     for item in xmldoc.getElementsByTagName("MET_METADATA"):
@@ -86,22 +89,18 @@ def otx_to_boris(file_path: str) -> dict:
         except Exception:
             project_name = ""
         try:
-            project_description = re.sub(
-                "<[^>]*>", "", metadata.getElementsByTagName("MET_PROJECT_DESCRIPTION")[0].toxml()
-            )
+            project_description = re.sub("<[^>]*>", "", metadata.getElementsByTagName("MET_PROJECT_DESCRIPTION")[0].toxml())
         except Exception:
             project_description = ""
 
         try:
-            project_creation_date = re.sub(
-                "<[^>]*>", "", metadata.getElementsByTagName("MET_CREATION_DATETIME")[0].toxml()
-            )
+            project_creation_date = re.sub("<[^>]*>", "", metadata.getElementsByTagName("MET_CREATION_DATETIME")[0].toxml())
         except Exception:
             project_creation_date = ""
 
     # modifiers
     modifiers: dict = {}
-    modifiers_set = {}
+    # modifiers_set = {}
     itemlist = xmldoc.getElementsByTagName("CDS_MODIFIER")
     for item in itemlist:
         modif = minidom.parseString(item.toxml())
@@ -112,16 +111,16 @@ def otx_to_boris(file_path: str) -> dict:
 
         try:
             modif_parent_id = re.sub("<[^>]*>", "", modif.getElementsByTagName("CDS_ELE_PARENT_ID")[0].toxml())
-        except:
+        except Exception:
             modif_parent_id = ""
 
         try:
             description = re.sub("<[^>]*>", "", modif.getElementsByTagName("CDS_ELE_DESCRIPTION")[0].toxml())
-        except:
+        except Exception:
             description = ""
         try:
             key = re.sub("<[^>]*>", "", modif.getElementsByTagName("CDS_ELE_START_KEYCODE")[0].toxml())
-        except:
+        except Exception:
             key = ""
 
         if modif_parent_id:
@@ -132,8 +131,7 @@ def otx_to_boris(file_path: str) -> dict:
                 flag_long_key = True
             modifiers[modif_id] = {"set_name": modif_code, "key": key, "description": description, "values": []}
 
-    print("modifiers")
-    pprint.pprint(modifiers)
+    logging.debug(modifiers)
 
     # connect modifiers to behaviors
     connections: dict = {}
@@ -143,8 +141,7 @@ def otx_to_boris(file_path: str) -> dict:
             connections[item.attributes["CDS_ELEMENT_ID"].value] = []
         connections[item.attributes["CDS_ELEMENT_ID"].value].append(item.attributes["CDS_MODIFIER_ID"].value)
 
-    print("connections")
-    pprint.pprint(connections)
+    logging.debug(connections)
 
     # behaviors
     behaviors: dict = {}
@@ -161,40 +158,37 @@ def otx_to_boris(file_path: str) -> dict:
 
         try:
             description = re.sub("<[^>]*>", "", behav.getElementsByTagName("CDS_ELE_DESCRIPTION")[0].toxml())
-        except:
+        except Exception:
             description = ""
         try:
             key = re.sub("<[^>]*>", "", behav.getElementsByTagName("CDS_ELE_START_KEYCODE")[0].toxml())
-        except:
+        except Exception:
             key = ""
 
         try:
             stop_key = re.sub("<[^>]*>", "", behav.getElementsByTagName("CDS_ELE_STOP_KEYCODE")[0].toxml())
-        except:
+        except Exception:
             stop_key = ""
 
         try:
             parent_name = re.sub("<[^>]*>", "", behav.getElementsByTagName("CDS_ELE_PARENT_NAME")[0].toxml())
-        except:
+        except Exception:
             parent_name = ""
 
         try:
             mutually_exclusive = re.sub("<[^>]*>", "", behav.getElementsByTagName("CDS_ELE_MUT_EXCLUSIVE")[0].toxml())
-        except:
+        except Exception:
             mutually_exclusive = ""
 
         if mutually_exclusive == "Y" and parent_name:
             mutually_exclusive_list.append(behav_code)
 
         if behav_id in connections:
-
             modifier_sets = [modifiers[modifier_set]["set_name"] for modifier_set in connections[behav_id]]
-            print(f"{modifier_sets=}")
         else:
             modifier_sets = []
 
         if parent_name:  # behavior
-
             if (not key or len(key) > 1) and stop_key:
                 key = stop_key
 
@@ -213,7 +207,6 @@ def otx_to_boris(file_path: str) -> dict:
             behaviors_list.append(behav_code)
 
         else:  #  behavioral category
-
             behav_category.append(behav_code)
 
     behaviors_boris: dict = {}
@@ -243,7 +236,7 @@ def otx_to_boris(file_path: str) -> dict:
                         "description": modifiers[modif_key]["description"],
                     }
 
-    pprint.pprint(behaviors_boris)
+    logging.debug(behaviors_boris)
 
     # subjects
     subjects = {}
@@ -253,11 +246,11 @@ def otx_to_boris(file_path: str) -> dict:
         subject_name = re.sub("<[^>]*>", "", subject.getElementsByTagName("CDS_ELE_NAME")[0].toxml())
         try:
             key = re.sub("<[^>]*>", "", subject.getElementsByTagName("CDS_ELE_START_KEYCODE")[0].toxml())
-        except:
+        except Exception:
             key = ""
         try:
             parent_name = re.sub("<[^>]*>", "", subject.getElementsByTagName("CDS_ELE_PARENT_NAME")[0].toxml())
-        except:
+        except Exception:
             parent_name = ""
 
         if parent_name:
@@ -270,7 +263,6 @@ def otx_to_boris(file_path: str) -> dict:
     variables = {}
     itemlist = xmldoc.getElementsByTagName("VL_VARIABLE")
     for item in itemlist:
-
         variable = minidom.parseString(item.toxml())
 
         variable_label = re.sub("<[^>]*>", "", variable.getElementsByTagName("VL_LABEL")[0].toxml())
@@ -293,7 +285,7 @@ def otx_to_boris(file_path: str) -> dict:
 
         try:
             variable_description = re.sub("<[^>]*>", "", modif.getElementsByTagName("VL_DESCRIPTION")[0].toxml())
-        except:
+        except Exception:
             variable_description = ""
 
         try:
@@ -303,7 +295,7 @@ def otx_to_boris(file_path: str) -> dict:
                 values_list.append(re.sub("<[^>]*>", "", value.toxml()))
             values_str = ",".join(values_list)
 
-        except:
+        except Exception:
             values_str = ""
 
         variables[variable_id] = {
@@ -331,16 +323,10 @@ def otx_to_boris(file_path: str) -> dict:
 
     observations = xmldoc.getElementsByTagName("OBS_OBSERVATION")
 
-    """
-    print(f"{len(observations)=}")
-    print()
-    """
-
     for OBS_OBSERVATION in observations:
         # OBS_OBSERVATION = minidom.parseString(OBS_OBSERVATION.toxml())
 
         obs_id = OBS_OBSERVATION.getAttribute("NAME")
-        """print(f"{obs_id=}")"""
 
         project[cfg.OBSERVATIONS][obs_id] = dict(
             {
@@ -362,27 +348,24 @@ def otx_to_boris(file_path: str) -> dict:
 
         OBS_EVENT_LOGS = OBS_OBSERVATION.getElementsByTagName("OBS_EVENT_LOGS")[0]
 
-        # print(f"{OBS_EVENT_LOGS=}")
-
         for OBS_EVENT_LOG in OBS_EVENT_LOGS.getElementsByTagName("OBS_EVENT_LOG"):
-
             CREATION_DATETIME = OBS_EVENT_LOG.getAttribute("CREATION_DATETIME")
 
-            CREATION_DATETIME = CREATION_DATETIME.replace(" ", "T").split(".")[0]
+            CREATION_DATETIME = CREATION_DATETIME.replace(" ", "T")  # .split(".")[0]
 
-            """print(f"{CREATION_DATETIME=}")  # ex: 2022-05-18 10:04:09.474512"""
+            logging.debug(f"{CREATION_DATETIME=}")  # ex: 2022-05-18 10:04:09.474512"""
 
             project[cfg.OBSERVATIONS][obs_id]["date"] = CREATION_DATETIME
 
             for event in OBS_EVENT_LOG.getElementsByTagName("OBS_EVENT"):
-
                 OBS_EVENT_TIMESTAMP = event.getElementsByTagName("OBS_EVENT_TIMESTAMP")[0].childNodes[0].data
 
-                day_timestamp = dt.datetime.strptime(OBS_EVENT_TIMESTAMP.split(" ")[0], "%Y-%m-%d").timestamp()
-
                 full_timestamp = dt.datetime.strptime(OBS_EVENT_TIMESTAMP, "%Y-%m-%d %H:%M:%S.%f").timestamp()
+                logging.debug(f"{full_timestamp=}")
 
-                timestamp = dec(str(round(full_timestamp - day_timestamp, 3)))
+                # day_timestamp = dt.datetime.strptime(OBS_EVENT_TIMESTAMP.split(" ")[0], "%Y-%m-%d").timestamp()
+                # timestamp = dec(str(round(full_timestamp - day_timestamp, 3)))
+                timestamp = dec(full_timestamp).quantize(dec(".001"))
 
                 try:
                     OBS_EVENT_SUBJECT = event.getElementsByTagName("OBS_EVENT_SUBJECT")[0].getAttribute("NAME")
@@ -390,26 +373,34 @@ def otx_to_boris(file_path: str) -> dict:
                     OBS_EVENT_SUBJECT = ""
 
                 OBS_EVENT_BEHAVIOR = event.getElementsByTagName("OBS_EVENT_BEHAVIOR")[0].getAttribute("NAME")
+                logging.debug(f"{OBS_EVENT_BEHAVIOR=}")
+                if not OBS_EVENT_BEHAVIOR:
+                    logging.warning(f"Behavior missing in observation {obs_id} at {timestamp}")
+                    error_list.append(f"Behavior missing in observation {obs_id} at {timestamp}")
+                    continue
 
-                OBS_EVENT_BEHAVIOR_MODIFIER = (
-                    event.getElementsByTagName("OBS_EVENT_BEHAVIOR")[0]
-                    .getElementsByTagName("OBS_EVENT_BEHAVIOR_MODIFIER")[0]
-                    .childNodes[0]
-                    .data
-                )
+                # modifier
+                try:
+                    OBS_EVENT_BEHAVIOR_MODIFIER = (
+                        event.getElementsByTagName("OBS_EVENT_BEHAVIOR")[0]
+                        .getElementsByTagName("OBS_EVENT_BEHAVIOR_MODIFIER")[0]
+                        .childNodes[0]
+                        .data
+                    )
+                except Exception:
+                    OBS_EVENT_BEHAVIOR_MODIFIER: str = ""
 
+                # comment
                 try:
-                    OBS_EVENT_COMMENT = event.getElementsByTagName("OBS_EVENT_COMMENT")[0].childNodes[0].data
+                    OBS_EVENT_COMMENT: str = event.getElementsByTagName("OBS_EVENT_COMMENT")[0].childNodes[0].data
                 except Exception:
-                    OBS_EVENT_COMMENT = ""
+                    OBS_EVENT_COMMENT: str = ""
 
-                """
-                print(f"{timestamp=}")
-                print(f"{OBS_EVENT_SUBJECT=}")
-                print(f"{OBS_EVENT_BEHAVIOR=}")
-                print(f"{OBS_EVENT_BEHAVIOR_MODIFIER=}")
-                print(f"{OBS_EVENT_COMMENT=}")
-                """
+                logging.debug(f"{timestamp=}")
+                logging.debug(f"{OBS_EVENT_SUBJECT=}")
+                logging.debug(f"{OBS_EVENT_BEHAVIOR=}")
+                logging.debug(f"{OBS_EVENT_BEHAVIOR_MODIFIER=}")
+                logging.debug(f"{OBS_EVENT_COMMENT=}")
 
                 project[cfg.OBSERVATIONS][obs_id][cfg.EVENTS].append(
                     [
@@ -421,10 +412,6 @@ def otx_to_boris(file_path: str) -> dict:
                     ]
                 )
 
-                # print(80 * "-")
-
-        # print(80 * "=")
-
     project[cfg.PROJECT_NAME] = project_name
     project[cfg.PROJECT_DATE] = project_creation_date.replace(" ", "T")
     project[cfg.ETHOGRAM] = behaviors_boris
@@ -434,15 +421,22 @@ def otx_to_boris(file_path: str) -> dict:
     project[cfg.INDEPENDENT_VARIABLES] = variables_boris
 
     if flag_long_key:
-        project["msg"] = "The keys longer than one char were deleted"
+        error_list.append("The keys longer than one char were deleted.")
+        logging.debug("The keys longer than one char were deleted.")
 
-    return project
+    return project, error_list
 
 
 if __name__ == "__main__":
     import sys
     import pprint
 
-    otx_to_boris(sys.argv[1])
+    logging.basicConfig(
+        format="%(asctime)s,%(msecs)d  %(module)s l.%(lineno)d %(levelname)s %(message)s",
+        datefmt="%H:%M:%S",
+        level=logging.DEBUG,
+    )
+    project, errors = otx_to_boris(sys.argv[1])
 
-    # pprint.pprint(otx_to_boris(sys.argv[1]))
+    pprint.pprint(project)
+    pprint.pprint(errors)