boris-behav-obs 9.0.8__py2.py3-none-any.whl → 9.1.1__py2.py3-none-any.whl

boris/dialog.py

@@ -20,15 +20,16 @@ This file is part of BORIS.
 
 """
 
+from decimal import Decimal as dec
+from typing import Union
+import datetime as dt
 import logging
-import sys
+import math
 import pathlib as pl
-import traceback
 import platform
-import datetime as dt
 import subprocess
-from decimal import Decimal as dec
-from typing import Union
+import sys
+import traceback
 
 from PySide6.QtCore import Qt, Signal, qVersion, QRect, QTime, QDateTime, QSize
 from PySide6.QtWidgets import (
@@ -409,6 +410,9 @@ class get_time_widget(QWidget):
         set time on time widget
         """
 
+        if math.isnan(new_time):
+            return
+
         self.pb_sign.setText("-" if new_time < 0 else "+")
 
         # seconds

boris/edit_event.py

@@ -21,6 +21,7 @@ This file is part of BORIS.
 """
 
 from decimal import Decimal as dec
+import math
 
 from PySide6.QtWidgets import (
     QDialog,
@@ -67,14 +68,7 @@ class DlgEditEvent(QDialog, Ui_Form):
             for w in (self.lb_frame_idx, self.sb_frame_idx, self.cb_set_frame_idx_na):
                 w.setVisible(False)
 
-        if (observation_type in (cfg.LIVE, cfg.MEDIA)) or (observation_type == cfg.IMAGES and self.time_value != cfg.NA):
-            # self.time_widget = duration_widget.Duration_widget(self.time_value)
-            # if time_format == cfg.S:
-            #    self.time_widget.set_format_s()
-            # if time_format == cfg.HHMMSS:
-            #    self.time_widget.set_format_hhmmss()
-
-            # future time widget
+        if (observation_type in (cfg.LIVE, cfg.MEDIA)) or (observation_type == cfg.IMAGES and not math.isnan(self.time_value)):
             self.time_widget = dialog.get_time_widget(self.time_value)
 
             if time_format == cfg.S:
@@ -87,6 +81,7 @@ class DlgEditEvent(QDialog, Ui_Form):
             self.horizontalLayout_2.insertWidget(0, self.time_widget)
 
         if observation_type == cfg.IMAGES:
+            self.time_widget = dialog.get_time_widget(self.time_value)
             # hide frame index widgets
             for w in (self.lb_frame_idx, self.sb_frame_idx, self.cb_set_frame_idx_na, self.pb_set_to_current_time):
                 w.setVisible(False)

boris/event_operations.py

@@ -78,10 +78,13 @@ def add_event(self):
     )
     editWindow.setWindowTitle("Add a new event")
 
-    sortedSubjects = [""] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+    sortedSubjects = [cfg.NO_FOCAL_SUBJECT] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+
+    print(f"{sortedSubjects=}")
 
     editWindow.cobSubject.addItems(sortedSubjects)
-    editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
+    if self.currentSubject:
+        editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
 
     sortedCodes = sorted([self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]])
 
@@ -103,7 +106,9 @@ def add_event(self):
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
@@ -152,7 +157,9 @@ def add_event(self):
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
@@ -220,9 +227,6 @@ def filter_events(self):
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations=[],  # empty selection of observations for selecting all subjects and behaviors
-        start_coding=dec("NaN"),
-        end_coding=dec("NaN"),
-        maxTime=None,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
         by_category=False,
@@ -687,10 +691,9 @@ def edit_event(self):
                     if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == edit_window.cobCode.currentText():
                         event = self.full_event(key)
                         # subject
-                        if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT:
-                            event[cfg.SUBJECT] = ""
-                        else:
-                            event[cfg.SUBJECT] = edit_window.cobSubject.currentText()
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
 
                         event[cfg.COMMENT] = edit_window.leComment.toPlainText()
 
@@ -749,7 +752,9 @@ def edit_event(self):
                         else:
                             event[cfg.TIME] = edit_window.time_widget.get_time()
 
-                        event[cfg.SUBJECT] = edit_window.cobSubject.currentText()
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
                         event[cfg.COMMENT] = edit_window.leComment.toPlainText()
                         event["row"] = pj_event_idx
                         event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][

boris/events_snapshots.py

@@ -212,7 +212,7 @@ def events_snapshots(self):
                         if start < time_interval:
                             start = dec("0.000")
 
-                        if cfg.POINT in behavior_state:
+                        if behavior_state in cfg.POINT_EVENT_TYPES:
                             media_path = project_functions.full_path(
                                 self.pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][nplayer][mediaFileIdx],
                                 self.projectFileName,
@@ -222,7 +222,7 @@ def events_snapshots(self):
                             if vframes == 0:
                                 vframes = 1
 
-                        if cfg.STATE in behavior_state:
+                        if behavior_state in cfg.STATE_EVENT_TYPES:
                             if idx % 2 == 0:
                                 # check if stop is on same media file
                                 if (
@@ -413,7 +413,7 @@ def extract_events(self):
                     rows = [{"occurence": util.float2decimal(r["occurence"])} for r in cursor.fetchall()]
 
                     behavior_state = project_functions.event_type(behavior, self.pj[cfg.ETHOGRAM])
-                    if cfg.STATE in behavior_state and len(rows) % 2:  # unpaired events
+                    if behavior_state in cfg.STATE_EVENT_TYPES and len(rows) % 2:  # unpaired events
                         continue
 
                     for idx, row in enumerate(rows):
@@ -472,7 +472,7 @@ def extract_events(self):
                             new_extension = ".wav"
                             codecs = "-vn"
 
-                        if cfg.POINT in behavior_state:
+                        if behavior_state in cfg.POINT_EVENT_TYPES:
                             globalStart = dec("0.000") if row["occurence"] < timeOffset else round(row["occurence"] - timeOffset, 3)
                             start = round(
                                 row["occurence"]
@@ -494,7 +494,7 @@ def extract_events(self):
                                 3,
                             )
 
-                        if cfg.STATE in behavior_state:
+                        if behavior_state in cfg.STATE_EVENT_TYPES:
                             if idx % 2 == 0:
                                 # check if stop is on same media file
                                 if (

boris/export_events.py

@@ -72,15 +72,19 @@ def export_events_as_behavioral_sequences(self, separated_subjects=False, timed=
     if len(selected_observations) == 1:
         max_media_duration_all_obs, _ = observation_operations.media_duration(self.pj[cfg.OBSERVATIONS], selected_observations)
         start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
+        start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
+        start_interval, end_interval = dec("NaN"), dec("NaN")
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
+        start_interval=start_interval,
+        end_interval=end_interval,
         maxTime=max_media_duration_all_obs,
         show_include_modifiers=True,
         show_exclude_non_coded_behaviors=False,
@@ -161,15 +165,19 @@ def export_tabular_events(self, mode: str = "tabular") -> None:
     if len(selected_observations) == 1:
         max_media_duration_all_obs, _ = observation_operations.media_duration(self.pj[cfg.OBSERVATIONS], selected_observations)
         start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
+        start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
+        start_interval, end_interval = dec("NaN"), dec("NaN")
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
+        start_interval=start_interval,
+        end_interval=end_interval,
         maxTime=max_media_duration_all_obs,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
@@ -361,15 +369,19 @@ def export_aggregated_events(self):
     if len(selected_observations) == 1:
         max_media_duration_all_obs, _ = observation_operations.media_duration(self.pj[cfg.OBSERVATIONS], selected_observations)
         start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
+        start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
+        start_interval, end_interval = dec("NaN"), dec("NaN")
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
+        start_interval=start_interval,
+        end_interval=end_interval,
         maxTime=max_media_duration_all_obs,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
@@ -587,7 +599,7 @@ def export_aggregated_events(self):
         return
 
     if outputFormat == cfg.SDIS_EXT:  # SDIS format
-        out: str = "% SDIS file created by BORIS (www.boris.unito.it) " f"at {util.datetime_iso8601(dt.datetime.now())}\nTimed <seconds>;\n"
+        out: str = f"% SDIS file created by BORIS (www.boris.unito.it) at {util.datetime_iso8601(dt.datetime.now())}\nTimed <seconds>;\n"
         for obs_id in selected_observations:
             # observation id
             out += "\n<{}>\n".format(obs_id)
@@ -613,10 +625,7 @@ def export_aggregated_events(self):
                 fileName = f"{pl.Path(exportDir) / util.safeFileName(obs_id)}.{outputFormat}"
                 with open(fileName, "wb") as f:
                     f.write(str.encode(out))
-                out = (
-                    "% SDIS file created by BORIS (www.boris.unito.it) "
-                    f"at {util.datetime_iso8601(dt.datetime.now())}\nTimed <seconds>;\n"
-                )
+                out = f"% SDIS file created by BORIS (www.boris.unito.it) at {util.datetime_iso8601(dt.datetime.now())}\nTimed <seconds>;\n"
 
         if flag_group:
             with open(fileName, "wb") as f:
@@ -665,11 +674,15 @@ def export_events_as_textgrid(self) -> None:
 
     start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
 
+    start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
+
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
+        start_interval=start_interval,
+        end_interval=end_interval,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
         maxTime=max_obs_length,
@@ -700,9 +713,7 @@ def export_events_as_textgrid(self) -> None:
         "        intervals: size = {intervalsSize}\n"
     )
 
-    interval_template = (
-        "        intervals [{count}]:\n" "            xmin = {xmin}\n" "            xmax = {xmax}\n" '            text = "{name}"\n'
-    )
+    interval_template = '        intervals [{count}]:\n            xmin = {xmin}\n            xmax = {xmax}\n            text = "{name}"\n'
 
     point_subject_header = (
         "    item [{subject_index}]:\n"
@@ -713,7 +724,7 @@ def export_events_as_textgrid(self) -> None:
         "        points: size = {intervalsSize}\n"
     )
 
-    point_template = "        points [{count}]:\n" "            number = {number}\n" '            mark = "{mark}"\n'
+    point_template = '        points [{count}]:\n            number = {number}\n            mark = "{mark}"\n'
 
     # widget for results
     self.results = dialog.Results_dialog()
@@ -773,6 +784,14 @@ def export_events_as_textgrid(self) -> None:
             min_time = float(parameters[cfg.START_TIME])
             max_time = float(parameters[cfg.END_TIME])
 
+        if parameters["time"] == cfg.TIME_OBS_INTERVAL:
+            max_media_duration, _ = observation_operations.media_duration(self.pj[cfg.OBSERVATIONS], [obs_id])
+            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            offset = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET])
+            min_time = float(obs_interval[0]) + offset
+            # Use max media duration for max time if no interval is defined (=0)
+            max_time = float(obs_interval[1]) + offset if obs_interval[1] != 0 else float(max_media_duration)
+
         # delete events outside time interval
         cursor.execute(
             "DELETE FROM aggregated_events WHERE observation = ? AND (start < ? AND stop < ?) OR (start > ? AND stop > ?)",
@@ -936,10 +955,7 @@ def export_events_as_textgrid(self) -> None:
 
             # POINT events
             cursor.execute(
-                (
-                    "SELECT start, behavior FROM aggregated_events "
-                    "WHERE observation = ? AND subject = ? AND type = 'POINT' ORDER BY start"
-                ),
+                ("SELECT start, behavior FROM aggregated_events WHERE observation = ? AND subject = ? AND type = 'POINT' ORDER BY start"),
                 (obs_id, subject),
             )
 

boris/export_observation.py

@@ -148,7 +148,7 @@ def export_events_jwatcher(
         if fmf_file_path.exists():
             fmf_creation_answer = dialog.MessageDialog(
                 cfg.programName,
-                (f"The {fmf_file_path} file already exists.<br>" "What do you want to do?"),
+                (f"The {fmf_file_path} file already exists.<br>What do you want to do?"),
                 [cfg.OVERWRITE, "Skip file creation", cfg.CANCEL],
             )
 
@@ -190,7 +190,7 @@ def export_events_jwatcher(
         if faf_file_path.exists():
             faf_creation_answer = dialog.MessageDialog(
                 cfg.programName,
-                (f"The {faf_file_path} file already exists.<br>" "What do you want to do?"),
+                (f"The {faf_file_path} file already exists.<br>What do you want to do?"),
                 [cfg.OVERWRITE, "Skip file creation", cfg.CANCEL],
             )
             if faf_creation_answer == cfg.CANCEL:
@@ -310,6 +310,7 @@ def export_tabular_events(
     interval = parameters["time"]
 
     start_coding, end_coding, coding_duration = observation_operations.coding_time(pj[cfg.OBSERVATIONS], [obs_id])
+    start_interval, end_interval = observation_operations.time_intervals_range(pj[cfg.OBSERVATIONS], [obs_id])
 
     if interval == cfg.TIME_EVENTS:
         min_time = start_coding
@@ -330,6 +331,12 @@ def export_tabular_events(
         min_time = parameters[cfg.START_TIME]
         max_time = parameters[cfg.END_TIME]
 
+    if interval == cfg.TIME_OBS_INTERVAL:
+        max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obs_id])
+        min_time = start_interval
+        # Use max media duration for max time if no interval is defined (=0)
+        max_time = end_interval if end_interval != 0 else max_media_duration
+
     logging.debug(f"min_time: {min_time}  max_time: {max_time}")
 
     events_with_status = project_functions.events_start_stop(ethogram, observation[cfg.EVENTS], observation[cfg.TYPE])
@@ -647,6 +654,8 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str, force_numbe
     data = tablib.Dataset()
 
     start_coding, end_coding, coding_duration = observation_operations.coding_time(pj[cfg.OBSERVATIONS], [obsId])
+    start_interval, end_interval = observation_operations.time_intervals_range(pj[cfg.OBSERVATIONS], [obsId])
+
     if start_coding is None and end_coding is None:  # no events
         return data, 0
 
@@ -668,6 +677,12 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str, force_numbe
         min_time = float(parameters[cfg.START_TIME])
         max_time = float(parameters[cfg.END_TIME])
 
+    if interval == cfg.TIME_OBS_INTERVAL:
+        max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obsId])
+        min_time = float(start_interval)
+        # Use max media duration for max time if no interval is defined (=0)
+        max_time = float(end_interval) if end_interval != 0 else float(max_media_duration)
+
     logging.debug(f"min_time: {min_time}  max_time: {max_time}")
 
     # obs description

boris/observation_operations.py

@@ -43,8 +43,9 @@ from PySide6.QtWidgets import (
     QSlider,
     QMainWindow,
     QDockWidget,
+    QPushButton,
 )
-from PySide6.QtCore import Qt, QDateTime, QTimer
+from PySide6.QtCore import Qt, QDateTime, QTimer, QObject, QEvent
 from PySide6.QtGui import QFont, QIcon, QTextCursor
 
 from PySide6 import QtTest
@@ -346,6 +347,40 @@ def coding_time(observations: dict, observations_list: list) -> Tuple[Optional[d
     return start_coding, end_coding, coding_duration
 
 
+def time_intervals_range(observations: dict, observations_list: list) -> Tuple[Optional[dec], Optional[dec]]:
+    """
+    returns earliest start interval and latest end interval
+
+    Args:
+        observations (dict): observations of project
+        observations_list (list): list of selected observations
+
+    Returns:
+        decimal.Decimal: time of earliest start interval
+        decimal.Decimal: time of latest end interval
+
+    """
+    start_interval_list = []
+    end_interval_list = []
+    for obs_id in observations_list:
+        observation = observations[obs_id]
+        offset = observation[cfg.TIME_OFFSET]
+        start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
+        end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
+
+    if not start_interval_list:
+        earliest_start_interval = None
+    else:
+        earliest_start_interval = min([x for x in start_interval_list])
+
+    if not end_interval_list:
+        latest_end_interval = None
+    else:
+        latest_end_interval = min([x for x in end_interval_list])
+
+    return earliest_start_interval, latest_end_interval
+
+
 def observation_total_length(observation: dict) -> dec:
     """
     Observation media duration (if any)
@@ -2190,6 +2225,7 @@ def initialize_new_live_observation(self):
 
     # button start enabled
     self.pb_live_obs.setEnabled(True)
+
     self.w_live.setVisible(True)
     self.w_obs_info.setVisible(True)
 

boris/param_panel.py

@@ -59,6 +59,7 @@ class Param_panel(QDialog, Ui_Dialog):
         self.rb_media_duration.clicked.connect(lambda: self.rb_time_interval_selection(cfg.TIME_FULL_OBS))
         self.rb_observed_events.clicked.connect(lambda: self.rb_time_interval_selection(cfg.TIME_EVENTS))
         self.rb_user_defined.clicked.connect(lambda: self.rb_time_interval_selection(cfg.TIME_ARBITRARY_INTERVAL))
+        self.rb_obs_interval.clicked.connect(lambda: self.rb_time_interval_selection(cfg.TIME_OBS_INTERVAL))
 
         self.cbIncludeModifiers.stateChanged.connect(self.cb_exclude_non_coded_modifiers_visibility)
 
@@ -90,6 +91,17 @@ class Param_panel(QDialog, Ui_Dialog):
             self.frm_time_interval.setEnabled(False)
             self.frm_time_interval.setVisible(True)
 
+        elif button == cfg.TIME_OBS_INTERVAL:
+            if not ((self.start_interval is None) or self.start_interval.is_nan()):
+                # Set start_time and end_time widgets values even if it is not shown with
+                # more than 1 observation as some analyses might use it (eg: advanced event filtering)
+                end_interval = self.end_interval if self.end_interval != 0 else self.media_duration
+                self.start_time.set_time(self.start_interval)
+                self.end_time.set_time(end_interval)
+                self.frm_time_interval.setEnabled(False)
+                if len(self.selectedObservations) == 1:
+                    self.frm_time_interval.setVisible(True)
+
         else:
             self.frm_time_interval.setVisible(False)
 

boris/param_panel_ui.py

@@ -175,6 +175,11 @@ class Ui_Dialog(object):
 
         self.horizontalLayout_5.addWidget(self.rb_user_defined)
 
+        self.rb_obs_interval = QRadioButton(self.frm_time)
+        self.rb_obs_interval.setObjectName(u"rb_obs_interval")
+
+        self.horizontalLayout_5.addWidget(self.rb_obs_interval)
+
         self.rb_media_duration = QRadioButton(self.frm_time)
         self.rb_media_duration.setObjectName(u"rb_media_duration")
         self.rb_media_duration.setCheckable(True)
@@ -288,6 +293,7 @@ class Ui_Dialog(object):
         self.lb_time_interval.setText(QCoreApplication.translate("Dialog", u"Time interval", None))
         self.rb_observed_events.setText(QCoreApplication.translate("Dialog", u"Observed events", None))
         self.rb_user_defined.setText(QCoreApplication.translate("Dialog", u"User defined", None))
+        self.rb_obs_interval.setText(QCoreApplication.translate("Dialog", u"Interval of observation", None))
         self.rb_media_duration.setText(QCoreApplication.translate("Dialog", u"Media file(s) duration", None))
         self.lbStartTime.setText(QCoreApplication.translate("Dialog", u"Start time", None))
         self.label_2.setText("")

boris/plot_events.py

@@ -47,7 +47,7 @@ def default_value(ethogram, behavior, parameter):
     return value for duration in case of point event
     """
     default_value_ = 0
-    if project_functions.event_type(behavior, ethogram) == "POINT EVENT" and parameter in ["duration"]:
+    if project_functions.event_type(behavior, ethogram) in cfg.POINT_EVENT_TYPES and parameter in ["duration"]:
         default_value_ = "NA"
     return default_value_
 
@@ -196,7 +196,7 @@ def create_behaviors_bar_plot(
             except Exception:
                 max_time = float(obs_length)
 
-        if param["time"] == cfg.TIME_ARBITRARY_INTERVAL:
+        if param["time"] in (cfg.TIME_ARBITRARY_INTERVAL, cfg.TIME_OBS_INTERVAL):
             min_time = float(start_time)
             max_time = float(end_time)
 
@@ -235,7 +235,7 @@ def create_behaviors_bar_plot(
             for behavior in distinct_behav:
                 # number of occurences
                 cursor.execute(
-                    ("SELECT COUNT(*) AS count FROM aggregated_events " "WHERE observation = ? AND subject = ? AND behavior = ?"),
+                    ("SELECT COUNT(*) AS count FROM aggregated_events WHERE observation = ? AND subject = ? AND behavior = ?"),
                     (
                         obs_id,
                         subject,
@@ -246,7 +246,7 @@ def create_behaviors_bar_plot(
                     behaviors[subject][behavior]["number of occurences"] = 0 if row["count"] is None else row["count"]
 
                 # total duration
-                if cfg.STATE in project_functions.event_type(behavior, pj[cfg.ETHOGRAM]):
+                if project_functions.event_type(behavior, pj[cfg.ETHOGRAM]) in cfg.STATE_EVENT_TYPES:
                     cursor.execute(
                         (
                             "SELECT SUM(stop - start) AS duration FROM aggregated_events "
@@ -290,7 +290,7 @@ def create_behaviors_bar_plot(
                     except Exception:
                         colors.append("darkgray")
 
-                if cfg.STATE in project_functions.event_type(behavior, pj[cfg.ETHOGRAM]):
+                if project_functions.event_type(behavior, pj[cfg.ETHOGRAM]) in cfg.STATE_EVENT_TYPES:
                     durations.append(behaviors[subject][behavior]["duration"])
                     x_labels_duration.append(behavior)
 
@@ -440,6 +440,13 @@ def create_events_plot(
             min_time = 0.0
             max_time = float(obs_length)
 
+        if interval == cfg.TIME_OBS_INTERVAL:
+            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            offset = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET])
+            min_time = float(obs_interval[0]) + offset
+            # Use max media duration for max time if no interval is defined (=0)
+            max_time = float(obs_interval[1]) + offset if obs_interval[1] != 0 else float(obs_length)
+
         if interval == cfg.TIME_EVENTS:
             try:
                 min_time = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][0][0])  # first event
@@ -523,7 +530,7 @@ def create_events_plot(
 
                 # total duration
                 cursor.execute(
-                    ("SELECT start, stop FROM aggregated_events " "WHERE  subject = ? AND behavior = ? AND modifiers = ?"),
+                    ("SELECT start, stop FROM aggregated_events WHERE  subject = ? AND behavior = ? AND modifiers = ?"),
                     (
                         subject,
                         behavior,

boris/project_functions.py

@@ -37,10 +37,11 @@ from PySide6.QtCore import Qt
 from . import config as cfg
 from . import db_functions
 from . import dialog
+from . import observation_operations
 from . import portion as I
+from . import project_functions
 from . import utilities as util
 from . import version
-from . import observation_operations
 
 
 def check_observation_exhaustivity(
@@ -583,9 +584,9 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
             return "", ""
         else:
             return (
-                f"""<font color="{cfg.subtitlesColors[
-                        parameters[cfg.SELECTED_SUBJECTS].index(row['subject']) % len(cfg.subtitlesColors)
-                    ]}">""",
+                f"""<font color="{
+                    cfg.subtitlesColors[parameters[cfg.SELECTED_SUBJECTS].index(row["subject"]) % len(cfg.subtitlesColors)]
+                }">""",
                 "</font>",
             )
 
@@ -652,7 +653,7 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                     modifiers_str = f"\n{row['modifiers'].replace('|', ', ')}"
                 else:
                     modifiers_str = ""
-                out += ("{idx}\n" "{start} --> {stop}\n" "{col1}{subject}: {behavior}" "{modifiers}" "{col2}\n\n").format(
+                out += ("{idx}\n{start} --> {stop}\n{col1}{subject}: {behavior}{modifiers}{col2}\n\n").format(
                     idx=idx + 1,
                     start=util.seconds2time(row["start"]).replace(".", ","),
                     stop=util.seconds2time(row["stop"] if row["type"] == cfg.STATE else row["stop"] + cfg.POINT_EVENT_ST_DURATION).replace(
@@ -760,7 +761,7 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                         else:
                             modifiers_str = ""
 
-                        out += ("{idx}\n" "{start} --> {stop}\n" "{col1}{subject}: {behavior}" "{modifiers}" "{col2}\n\n").format(
+                        out += ("{idx}\n{start} --> {stop}\n{col1}{subject}: {behavior}{modifiers}{col2}\n\n").format(
                             idx=idx + 1,
                             start=util.seconds2time(row["start"] - init).replace(".", ","),
                             stop=util.seconds2time(
@@ -1531,12 +1532,12 @@ def event_type(code: str, ethogram: dict) -> str | None:
         code (str): behavior code
 
     Returns:
-        str: "STATE EVENT", "POINT EVENT" or None if code not found in ethogram
+        str: behavior type
     """
 
     for idx in ethogram:
         if ethogram[idx][cfg.BEHAVIOR_CODE] == code:
-            return ethogram[idx][cfg.TYPE].upper()
+            return ethogram[idx][cfg.TYPE]
     return None
 
 
@@ -1563,7 +1564,7 @@ def fix_unpaired_state_events(ethogram: dict, observation: dict, fix_at_time: de
         ]
 
         for behavior in sorted(set(behaviors)):
-            if (behavior in ethogram_behaviors) and (cfg.STATE in event_type(behavior, ethogram).upper()):
+            if (behavior in ethogram_behaviors) and (event_type(behavior, ethogram) in cfg.STATE_EVENT_TYPES):
                 lst, memTime = [], {}
                 for event in [
                     event
@@ -1620,8 +1621,9 @@ def fix_unpaired_state_events2(ethogram: dict, events: list, fix_at_time: dec) -
         behaviors: list = [event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in events if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject]
 
         for behavior in sorted(set(behaviors)):
-            if (behavior in ethogram_behaviors) and (cfg.STATE in event_type(behavior, ethogram).upper()):
-                lst, memTime = [], {}
+            if (behavior in ethogram_behaviors) and (event_type(behavior, ethogram) in cfg.STATE_EVENT_TYPES):
+                lst: list = []
+                memTime: dict = {}
                 for event in [
                     event
                     for event in events
@@ -1883,7 +1885,15 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
         "Comment stop": "string",
     }
 
-    state_behaviors = [pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in pj[cfg.ETHOGRAM] if pj[cfg.ETHOGRAM][x]["type"] == cfg.STATE_EVENT]
+    """
+    state_behaviors = [
+        pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE]
+        for x in pj[cfg.ETHOGRAM]
+        if pj[cfg.ETHOGRAM][x]["type"] in (cfg.STATE_EVENT, cfg.STATE_EVENT_WITH_CODING_MAP)
+    ]
+    """
+
+    state_behaviors = util.state_behavior_codes(pj[cfg.ETHOGRAM])
 
     for obs_id in pj[cfg.OBSERVATIONS]:
         if observations_list and obs_id not in observations_list: