boris-behav-obs 9.6.1__py2.py3-none-any.whl → 9.6.3__py2.py3-none-any.whl

boris/export_events.py

@@ -702,7 +702,7 @@ def export_events_as_textgrid(self) -> None:
     if not export_dir:
         return
 
-    mem_command = ""
+    mem_command: str = ""
 
     # see https://www.fon.hum.uva.nl/praat/manual/TextGrid_file_formats.html
 
@@ -795,6 +795,7 @@ def export_events_as_textgrid(self) -> None:
             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 > ?)",
             (
@@ -838,38 +839,30 @@ def export_events_as_textgrid(self) -> None:
 
         next_obs: bool = False
 
-        """
-        total_media_duration = round(
-            observation_operations.observation_total_length(self.pj[cfg.OBSERVATIONS][obs_id]), 3
-        )
-        """
-
+        # number of items for size parameter
         cursor.execute(
             (
-                "SELECT COUNT(DISTINCT subject) FROM aggregated_events "
-                "WHERE observation = ? AND subject IN ({}) AND type = 'STATE' ".format(
-                    ",".join(["?"] * len(parameters[cfg.SELECTED_SUBJECTS]))
-                )
+                "SELECT COUNT(*) FROM (SELECT * FROM aggregated_events "
+                f"WHERE observation = ? AND subject IN ({','.join(['?'] * len(parameters[cfg.SELECTED_SUBJECTS]))}) GROUP BY subject, behavior) "
             ),
             [obs_id] + parameters[cfg.SELECTED_SUBJECTS],
         )
 
-        subjectsNum = int(cursor.fetchone()[0])
-        """subjectsMin = min_time"""
-        subjectsMax = max_time
+        subjects_num = int(cursor.fetchone()[0])
+        subjects_max = max_time
 
         out = (
             'File type = "ooTextFile"\n'
             'Object class = "TextGrid"\n'
             "\n"
             f"xmin = 0.0\n"
-            f"xmax = {subjectsMax}\n"
+            f"xmax = {subjects_max}\n"
             "tiers? <exists>\n"
-            f"size = {subjectsNum}\n"
+            f"size = {subjects_num}\n"
             "item []:\n"
         )
 
-        subject_index = 0
+        subject_index: int = 0
         for subject in parameters[cfg.SELECTED_SUBJECTS]:
             if subject not in [
                 x[cfg.EVENT_SUBJECT_FIELD_IDX] if x[cfg.EVENT_SUBJECT_FIELD_IDX] else cfg.NO_FOCAL_SUBJECT
@@ -877,7 +870,8 @@ def export_events_as_textgrid(self) -> None:
             ]:
                 continue
 
-            intervalsMin, intervalsMax = min_time, max_time
+            intervalsMin = min_time
+            intervalsMax = max_time
 
             # STATE events
             cursor.execute(
@@ -892,68 +886,66 @@ def export_events_as_textgrid(self) -> None:
                 {"start": util.float2decimal(r["start"]), "stop": util.float2decimal(r["stop"]), "code": r["behavior"]}
                 for r in cursor.fetchall()
             ]
-            if not rows:
-                continue
+            if rows:
+                out += interval_subject_header
 
-            out += interval_subject_header
+                count = 0
 
-            count = 0
-
-            # check if 1st behavior starts at the beginning
-            if rows[0]["start"] > 0:
-                count += 1
-                out += interval_template.format(count=count, name="null", xmin=0.0, xmax=rows[0]["start"])
-
-            for idx, row in enumerate(rows):
-                # check if events are overlapping
-                if (idx + 1 < len(rows)) and (row["stop"] > rows[idx + 1]["start"]):
-                    self.results.ptText.appendHtml(
-                        (
-                            f"The events overlap for subject <b>{subject}</b> in the observation <b>{obs_id}</b>. "
-                            "It is not possible to create the Praat TextGrid file."
+                # check if 1st behavior starts at the beginning
+                if rows[0]["start"] > 0:
+                    count += 1
+                    out += interval_template.format(count=count, name="null", xmin=0.0, xmax=rows[0]["start"])
+
+                for idx, row in enumerate(rows):
+                    # check if events are overlapping
+                    if (idx + 1 < len(rows)) and (row["stop"] > rows[idx + 1]["start"]):
+                        self.results.ptText.appendHtml(
+                            (
+                                f"The events overlap for subject <b>{subject}</b> in the observation <b>{obs_id}</b>. "
+                                "It is not possible to create the Praat TextGrid file."
+                            )
                         )
-                    )
-                    QApplication.processEvents()
+                        QApplication.processEvents()
 
-                    next_obs = True
-                    break
+                        next_obs = True
+                        break
 
-                count += 1
+                    count += 1
 
-                if (idx + 1 < len(rows)) and (rows[idx + 1]["start"] - dec("0.001") <= row["stop"] < rows[idx + 1]["start"]):
-                    xmax = rows[idx + 1]["start"]
-                else:
-                    xmax = row["stop"]
+                    if (idx + 1 < len(rows)) and (rows[idx + 1]["start"] - dec("0.001") <= row["stop"] < rows[idx + 1]["start"]):
+                        xmax = rows[idx + 1]["start"]
+                    else:
+                        xmax = row["stop"]
+
+                    out += interval_template.format(count=count, name=row["code"], xmin=row["start"], xmax=xmax)
+
+                    # check if no behavior
+                    if (idx + 1 < len(rows)) and (row["stop"] < rows[idx + 1]["start"] - dec("0.001")):
+                        count += 1
+                        out += interval_template.format(
+                            count=count,
+                            name="null",
+                            xmin=row["stop"],
+                            xmax=rows[idx + 1]["start"],
+                        )
 
-                out += interval_template.format(count=count, name=row["code"], xmin=row["start"], xmax=xmax)
+                if next_obs:
+                    break
 
-                # check if no behavior
-                if (idx + 1 < len(rows)) and (row["stop"] < rows[idx + 1]["start"] - dec("0.001")):
+                # check if last event ends at the end of media file
+                if rows[-1]["stop"] < max_time:
                     count += 1
-                    out += interval_template.format(
-                        count=count,
-                        name="null",
-                        xmin=row["stop"],
-                        xmax=rows[idx + 1]["start"],
-                    )
-
-            if next_obs:
-                break
-
-            # check if last event ends at the end of media file
-            if rows[-1]["stop"] < max_time:
-                count += 1
-                out += interval_template.format(count=count, name="null", xmin=rows[-1]["stop"], xmax=max_time)
-
-            # add info
-            subject_index += 1
-            out = out.format(
-                subject_index=subject_index,
-                subject=subject,
-                intervalsSize=count,
-                intervalsMin=intervalsMin,
-                intervalsMax=intervalsMax,
-            )
+                    out += interval_template.format(count=count, name="null", xmin=rows[-1]["stop"], xmax=max_time)
+
+                # add info
+                subject_index += 1
+                out = out.format(
+                    subject_index=subject_index,
+                    subject=subject,
+                    intervalsSize=count,
+                    intervalsMin=intervalsMin,
+                    intervalsMax=intervalsMax,
+                )
 
             # POINT events
             cursor.execute(

boris/gui_utilities.py

@@ -66,7 +66,6 @@ def restore_geometry(widget: QWidget, widget_name: str, default_width_height):
         ini_file_path = pl.Path.home() / pl.Path(".boris")
         if ini_file_path.is_file():
             settings = QSettings(str(ini_file_path), QSettings.IniFormat)
-            print(settings.value(f"{widget_name} geometry"))
             widget.restoreGeometry(settings.value(f"{widget_name} geometry"))
             logging.debug(f"geometry restored for {widget_name}  {settings.value(f'{widget_name} geometry')}")
         else:

boris/irr.py

@@ -126,7 +126,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
@@ -134,21 +134,18 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(stop) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
     nb_events2 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
@@ -201,11 +198,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"contingency_table:\n {contingency_table}")
 
     template = (
-        "Observation: {obsid1}\n"
-        "number of events: {nb_events1}\n\n"
-        "Observation: {obsid2}\n"
-        "number of events: {nb_events2:.0f}\n\n"
-        "K = {K:.3f}"
+        "Observation: {obsid1}\nnumber of events: {nb_events1}\n\nObservation: {obsid2}\nnumber of events: {nb_events2:.0f}\n\nK = {K:.3f}"
     )
 
     # out += "Observation length: <b>{:.3f} s</b><br>".format(self.observationTotalMediaLength(obsid1))
@@ -470,7 +463,7 @@ def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, select
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
@@ -483,22 +476,19 @@ def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, select
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(stop) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
 
     nb_events2 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
@@ -606,9 +596,7 @@ def needleman_wunch(self):
 
     cursor = db_connector.cursor()
     out = (
-        "Needleman-Wunsch similarity\n\n"
-        f"Time unit: {interval:.3f} s\n"
-        f"Selected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
+        f"Needleman-Wunsch similarity\n\nTime unit: {interval:.3f} s\nSelected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
     )
     mem_done = []
     nws_results = np.ones((len(selected_observations), len(selected_observations)))

boris/menu_options.py

@@ -143,6 +143,8 @@ def update_menu(self):
         self.actionJumpForward,
         self.actionJumpBackward,
         self.actionJumpTo,
+        self.action_change_time_offset_of_players,
+        self.action_deinterlace,
         self.actionZoom_level,
         self.actionRotate_current_video,
         self.actionDisplay_subtitles,

boris/modifier_coding_map_creator.py

@@ -907,8 +907,6 @@ class ModifiersMapCreatorWindow(QMainWindow):
         """
         self.area_list.clear()
 
-        print(f"{self.polygonsList2=}")
-
         for modifier_name in sorted(self.polygonsList2.keys()):
             self.area_list.addItem(modifier_name)
 

boris/observation_operations.py

@@ -1301,10 +1301,8 @@ def init_mpv(self):
 
     logging.debug("function: init_mpv")
 
-    """
-    print(f"{self.winId()=}")
-    print(f"{str(int(self.winId()))=}")
-    """
+    # print(f"{self.winId()=}")
+    # print(f"{str(int(self.winId()))=}")
 
     subprocess.Popen(
         [

boris/param_panel.py

@@ -96,12 +96,8 @@ class Param_panel(QDialog, Ui_Dialog):
                 # 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)
 
-                print(f"{self.end_interval=}")
-
                 end_interval = self.end_interval if self.end_interval != 0 else self.media_duration
 
-                print(f"{end_interval=}")
-
                 self.start_time.set_time(self.start_interval)
                 self.end_time.set_time(end_interval)
                 self.frm_time_interval.setEnabled(False)

boris/plot_spectrogram_rt.py

@@ -129,7 +129,8 @@ class Plot_spectrogram_RT(QWidget):
         try:
             wav = wave.open(wav_file, "r")
             frames = wav.readframes(-1)
-            sound_info = np.fromstring(frames, dtype=np.int16)
+            # sound_info = np.fromstring(frames, dtype=np.int16)
+            sound_info = np.frombuffer(frames, dtype=np.int16)
             frame_rate = wav.getframerate()
             wav.close()
             return sound_info, frame_rate

boris/plot_waveform_rt.py

@@ -109,7 +109,8 @@ class Plot_waveform_RT(QWidget):
         try:
             wav = wave.open(wav_file, "r")
             frames = wav.readframes(-1)
-            signal = np.fromstring(frames, dtype=np.int16)
+            # signal = np.fromstring(frames, dtype=np.int16)
+            signal = np.frombuffer(frames, dtype=np.int16)
             frame_rate = wav.getframerate()
             wav.close()
             return signal, frame_rate

boris/portion/__init__.py

@@ -3,18 +3,28 @@ from .interval import Interval, open, closed, openclosed, closedopen, empty, sin
 from .func import iterate
 from .io import from_string, to_string, from_data, to_data
 
-# disabled because BORIS does not need IntervalDict 
+# disabled because BORIS does not need IntervalDict
 # so the sortedcontainers module is not required
-#from .dict import IntervalDict
+# from .dict import IntervalDict
 
 
 __all__ = [
-    'inf', 'CLOSED', 'OPEN',
-    'Interval',
-    'open', 'closed', 'openclosed', 'closedopen', 'singleton', 'empty',
-    'iterate',
-    'from_string', 'to_string', 'from_data', 'to_data',
-    'IntervalDict',
+    "inf",
+    "CLOSED",
+    "OPEN",
+    "Interval",
+    "open",
+    "closed",
+    "openclosed",
+    "closedopen",
+    "singleton",
+    "empty",
+    "iterate",
+    "from_string",
+    "to_string",
+    "from_data",
+    "to_data",
+    "IntervalDict",
 ]
 
 CLOSED = Bound.CLOSED

boris/portion/const.py

@@ -5,11 +5,12 @@ class Bound(enum.Enum):
     """
     Bound types, either CLOSED for inclusive, or OPEN for exclusive.
     """
+
     CLOSED = True
     OPEN = False
 
     def __bool__(self):
-        raise ValueError('The truth value of a bound is ambiguous.')
+        raise ValueError("The truth value of a bound is ambiguous.")
 
     def __invert__(self):
         return Bound.CLOSED if self is Bound.OPEN else Bound.OPEN
@@ -21,7 +22,7 @@ class Bound(enum.Enum):
         return self.name
 
 
-class _Singleton():
+class _Singleton:
     __instance = None
 
     def __new__(cls, *args, **kwargs):
@@ -35,21 +36,29 @@ class _PInf(_Singleton):
     Represent positive infinity.
     """
 
-    def __neg__(self): return _NInf()
+    def __neg__(self):
+        return _NInf()
 
-    def __lt__(self, o): return False
+    def __lt__(self, o):
+        return False
 
-    def __le__(self, o): return isinstance(o, _PInf)
+    def __le__(self, o):
+        return isinstance(o, _PInf)
 
-    def __gt__(self, o): return not isinstance(o, _PInf)
+    def __gt__(self, o):
+        return not isinstance(o, _PInf)
 
-    def __ge__(self, o): return True
+    def __ge__(self, o):
+        return True
 
-    def __eq__(self, o): return isinstance(o, _PInf)
+    def __eq__(self, o):
+        return isinstance(o, _PInf)
 
-    def __repr__(self): return '+inf'
+    def __repr__(self):
+        return "+inf"
 
-    def __hash__(self): return hash(float('+inf'))
+    def __hash__(self):
+        return hash(float("+inf"))
 
 
 class _NInf(_Singleton):
@@ -57,21 +66,29 @@ class _NInf(_Singleton):
     Represent negative infinity.
     """
 
-    def __neg__(self): return _PInf()
+    def __neg__(self):
+        return _PInf()
 
-    def __lt__(self, o): return not isinstance(o, _NInf)
+    def __lt__(self, o):
+        return not isinstance(o, _NInf)
 
-    def __le__(self, o): return True
+    def __le__(self, o):
+        return True
 
-    def __gt__(self, o): return False
+    def __gt__(self, o):
+        return False
 
-    def __ge__(self, o): return isinstance(o, _NInf)
+    def __ge__(self, o):
+        return isinstance(o, _NInf)
 
-    def __eq__(self, o): return isinstance(o, _NInf)
+    def __eq__(self, o):
+        return isinstance(o, _NInf)
 
-    def __repr__(self): return '-inf'
+    def __repr__(self):
+        return "-inf"
 
-    def __hash__(self): return hash(float('-inf'))
+    def __hash__(self):
+        return hash(float("-inf"))
 
 
 # Positive infinity

boris/portion/dict.py

@@ -28,7 +28,7 @@ class IntervalDict(MutableMapping):
     number of distinct values (not keys) that are stored.
     """
 
-    __slots__ = ('_storage', )
+    __slots__ = ("_storage",)
 
     def __init__(self, mapping_or_iterable=None):
         """
@@ -352,10 +352,10 @@ class IntervalDict(MutableMapping):
         return key in self.domain()
 
     def __repr__(self):
-        return '{}{}{}'.format(
-            '{',
-            ', '.join('{!r}: {!r}'.format(i, v) for i, v in self.items()),
-            '}',
+        return "{}{}{}".format(
+            "{",
+            ", ".join("{!r}: {!r}".format(i, v) for i, v in self.items()),
+            "}",
         )
 
     def __eq__(self, other):

boris/portion/func.py

@@ -31,7 +31,7 @@ def iterate(interval, step, *, base=None, reverse=False):
     :return: a lazy iterator.
     """
     if base is None:
-        base = (lambda x: x)
+        base = lambda x: x
 
     exclude = operator.lt if not reverse else operator.gt
     include = operator.le if not reverse else operator.ge
@@ -39,7 +39,7 @@ def iterate(interval, step, *, base=None, reverse=False):
 
     value = base(interval.lower if not reverse else interval.upper)
     if (value == -inf and not reverse) or (value == inf and reverse):
-        raise ValueError('Cannot start iteration with infinity.')
+        raise ValueError("Cannot start iteration with infinity.")
 
     for i in interval if not reverse else reversed(interval):
         value = base(i.lower if not reverse else i.upper)