boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__py3-none-any.whl

boris/analysis_plugins/_export_to_feral.py

@@ -0,0 +1,225 @@
+"""
+BORIS plugin
+
+Export to FERAL (getferal.ai)
+"""
+
+import pandas as pd
+import json
+from pathlib import Path
+
+from PySide6.QtWidgets import QFileDialog
+
+# dependencies for CategoryDialog
+from PySide6.QtWidgets import QListWidget, QListWidgetItem, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QDialog
+from PySide6.QtCore import Qt
+
+
+__version__ = "0.1.1"
+__version_date__ = "2025-11-28"
+__plugin_name__ = "Export observations to FERAL"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+class CategoryDialog(QDialog):
+    def __init__(self, items, parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("Organize the videos in categories")
+
+        self.setModal(True)
+
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        lists_layout = QHBoxLayout()
+
+        # All videos
+        self.list_unclassified = self._create_list_widget()
+        self.label_unclassified = QLabel("All videos")
+        col0_layout = QVBoxLayout()
+        col0_layout.addWidget(self.label_unclassified)
+        col0_layout.addWidget(self.list_unclassified)
+
+        self.list_cat1 = self._create_list_widget()
+        self.label_cat1 = QLabel("train")
+        col1_layout = QVBoxLayout()
+        col1_layout.addWidget(self.label_cat1)
+        col1_layout.addWidget(self.list_cat1)
+
+        self.list_cat2 = self._create_list_widget()
+        self.label_cat2 = QLabel("val")
+        col2_layout = QVBoxLayout()
+        col2_layout.addWidget(self.label_cat2)
+        col2_layout.addWidget(self.list_cat2)
+
+        self.list_cat3 = self._create_list_widget()
+        self.label_cat3 = QLabel("test")
+        col3_layout = QVBoxLayout()
+        col3_layout.addWidget(self.label_cat3)
+        col3_layout.addWidget(self.list_cat3)
+
+        self.list_cat4 = self._create_list_widget()
+        self.label_cat4 = QLabel("inference")
+        col4_layout = QVBoxLayout()
+        col4_layout.addWidget(self.label_cat4)
+        col4_layout.addWidget(self.list_cat4)
+
+        # Add all columns to the horizontal layout
+        lists_layout.addLayout(col0_layout)
+        lists_layout.addLayout(col1_layout)
+        lists_layout.addLayout(col2_layout)
+        lists_layout.addLayout(col3_layout)
+        lists_layout.addLayout(col4_layout)
+
+        main_layout.addLayout(lists_layout)
+
+        buttons_layout = QHBoxLayout()
+        self.btn_ok = QPushButton("OK")
+        self.btn_cancel = QPushButton("Cancel")
+
+        self.btn_ok.clicked.connect(self.accept)
+        self.btn_cancel.clicked.connect(self.reject)
+
+        buttons_layout.addStretch()
+        buttons_layout.addWidget(self.btn_ok)
+        buttons_layout.addWidget(self.btn_cancel)
+
+        main_layout.addLayout(buttons_layout)
+
+        # Populate "Unclassified" with input items
+        for text in items:
+            QListWidgetItem(text, self.list_unclassified)
+
+    def _create_list_widget(self):
+        """
+        Create a QListWidget ready for drag & drop.
+        """
+        lw = QListWidget()
+        lw.setSelectionMode(QListWidget.ExtendedSelection)
+        lw.setDragEnabled(True)
+        lw.setAcceptDrops(True)
+        lw.setDropIndicatorShown(True)
+        lw.setDragDropMode(QListWidget.DragDrop)
+        lw.setDefaultDropAction(Qt.MoveAction)
+        return lw
+
+    def get_categories(self):
+        """
+        Return the content of all categories as a dictionary of lists.
+        """
+
+        def collect(widget):
+            return [widget.item(i).text().rstrip("*") for i in range(widget.count())]
+
+        return {
+            "unclassified": collect(self.list_unclassified),
+            "train": collect(self.list_cat1),
+            "val": collect(self.list_cat2),
+            "test": collect(self.list_cat3),
+            "inference": collect(self.list_cat4),
+        }
+
+
+def run(df: pd.DataFrame, project: dict):
+    """
+    Export observations to FERAL
+    See https://www.getferal.ai/ > Label Preparation
+    """
+
+    out: dict = {
+        "is_multilabel": False,
+        "splits": {
+            "train": [],
+            "val": [],
+            "test": [],
+            "inference": [],
+        },
+    }
+
+    log: list = []
+
+    # class names
+    class_names = {x: project["behaviors_conf"][x]["code"] for x in project["behaviors_conf"]}
+    out["class_names"] = class_names
+    reversed_class_names = {project["behaviors_conf"][x]["code"]: int(x) for x in project["behaviors_conf"]}
+    log.append(f"{class_names=}")
+
+    observations: list = sorted([x for x in project["observations"]])
+    log.append(f"Selected observation: {observations}")
+
+    labels: dict = {}
+    video_list: list = []
+    for observation_id in observations:
+        log.append("---")
+        log.append(observation_id)
+
+        # check number of media file in player #1
+        if len(project["observations"][observation_id]["file"]["1"]) != 1:
+            log.append(f"The observation {observation_id} contains more than one video")
+            continue
+
+        # check number of coded subjects
+        if len(set([x[1] for x in project["observations"][observation_id]["events"]])) > 1:
+            log.append(f"The observation {observation_id} contains more than one subject")
+            continue
+
+        media_file_path: str = project["observations"][observation_id]["file"]["1"][0]
+        media_file_name = str(Path(media_file_path).name)
+
+        # skip if no events
+        if not project["observations"][observation_id]["events"]:
+            video_list.append(media_file_name)
+            log.append(f"No events for observation {observation_id}")
+            continue
+        else:
+            video_list.append(media_file_name + "*")
+
+        # extract FPS
+        FPS = project["observations"][observation_id]["media_info"]["fps"][media_file_path]
+        log.append(f"{media_file_name} {FPS=}")
+        # extract media duration
+        duration = project["observations"][observation_id]["media_info"]["length"][media_file_path]
+        log.append(f"{media_file_name} {duration=}")
+
+        number_of_frames = int(duration / (1 / FPS))
+        log.append(f"{number_of_frames=}")
+
+        labels[media_file_name] = [0] * number_of_frames
+
+        for idx in range(number_of_frames):
+            t = idx * (1 / FPS)
+            behaviors = (
+                df[(df["Observation id"] == observation_id) & (df["Start (s)"] <= t) & (df["Stop (s)"] >= t)]["Behavior"].unique().tolist()
+            )
+            if len(behaviors) > 1:
+                log.append(f"The observation {observation_id} contains more than one behavior for frame {idx}")
+                del labels[media_file_name]
+                break
+            if behaviors:
+                behaviors_idx = reversed_class_names[behaviors[0]]
+                labels[media_file_name][idx] = behaviors_idx
+
+    out["labels"] = labels
+
+    # splits
+    dlg = CategoryDialog(video_list)
+
+    if dlg.exec():  # Dialog accepted
+        result = dlg.get_categories()
+        del result["unclassified"]
+        out["splits"] = result
+
+        filename, _ = QFileDialog.getSaveFileName(
+            None,
+            "Choose a file to save",
+            "",  # start directory
+            "JSON files (*.json);;All files (*.*)",
+        )
+        if filename:
+            with open(filename, "w") as f_out:
+                f_out.write(json.dumps(out, separators=(",", ": "), indent=1))
+
+    else:
+        log.append("splits section missing")
+
+    return "\n".join(log)

boris/analysis_plugins/_latency.py

@@ -0,0 +1,59 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors
+"""
+
+import pandas as pd
+
+__version__ = "0.0.1"
+__version_date__ = "2025-04-10"
+__plugin_name__ = "Behavior latencyxxx"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+import itertools
+
+
+def run(df: pd.DataFrame):
+    """
+    Latency of a behavior after another.
+    """
+
+    df["start_time"] = pd.to_datetime(df["Start (s)"])
+    df["end_time"] = pd.to_datetime(df["Stop (s)"])
+
+    latency_by_subject: dict = {}
+
+    for subject, group in df.groupby("subject"):
+        behaviors = group["behavior"].tolist()
+        # combinations = []
+        # Utiliser itertools pour créer des combinaisons 2 à 2 des comportements
+        for comb in itertools.combinations(behaviors, 2):
+            # combinations.append(comb)
+
+            last_A_end_time = None
+
+            # Liste pour stocker les latences de chaque sujet
+            subject_latency = []
+
+            for index, row in group.iterrows():
+                if row["behavior"] == comb[0]:
+                    # Si on rencontre un comportement A, on réinitialise le temps de fin du comportement A
+                    last_A_end_time = row["end_time"]
+                    subject_latency.append(None)  # Pas de latence pour A
+                elif row["behavior"] == comb[1] and last_A_end_time is not None:
+                    # Si on rencontre un comportement B et qu'on a déjà vu un A avant
+                    latency_time = row["start_time"] - last_A_end_time
+                    subject_latency.append(latency_time)
+                else:
+                    # Si on rencontre un B mais sans A avant
+                    subject_latency.append(None)
+
+            # Ajout des latences calculées au DataFrame
+            df.loc[group.index, f"latency {comb[1]} after {comb[0]}"] = subject_latency
+
+            # Calcul de la latence totale ou moyenne par sujet
+            latency_by_subject[(subject, comb)] = df.groupby("subject")["latency"].agg(["sum", "mean"])
+
+    return str(latency_by_subject)

boris/analysis_plugins/irr_cohen_kappa.py

@@ -0,0 +1,109 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Unweighted Cohen's Kappa
+"""
+
+import pandas as pd
+from typing import Dict, Tuple
+
+from sklearn.metrics import cohen_kappa_score
+from PySide6.QtWidgets import QInputDialog
+
+
+__version__ = "0.0.3"
+__version_date__ = "2025-09-02"
+__plugin_name__ = "Inter Rater Reliability - Unweighted Cohen's Kappa"
+__author__ = "Olivier Friard - University of Torino - Italy"
+__description__ = """
+This plugin calculates Cohen's Kappa to measure inter-rater reliability between two observers who code categorical behaviors over time intervals.
+Unlike the weighted version, this approach does not take into account the duration of the intervals.
+Each segment of time is treated equally, regardless of how long it lasts.
+This plugin does not take into account the modifiers.
+
+How it works:
+
+Time segmentation
+The program identifies all the time boundaries (start and end points) used by both observers.
+These boundaries are merged into a common timeline, which is then divided into a set of non-overlapping elementary intervals.
+
+Assigning codes
+For each elementary interval, the program determines which behavior was coded by each observer.
+
+Comparison of codes
+The program builds two parallel lists of behavior codes, one for each observer.
+Each elementary interval is counted as one unit of observation, no matter how long the interval actually lasts.
+
+Cohen's Kappa calculation
+Using these two lists, the program computes Cohen's Kappa using the cohen_kappa_score function of the sklearn package.
+(see https://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html for details)
+This coefficient measures how much the observers agree on their coding, adjusted for the amount of agreement that would be expected by chance.
+
+"""
+
+
+def run(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Calculate the Inter Rater Reliability - Unweighted Cohen's Kappa
+    """
+
+    # Attribute all active codes for each interval
+    def get_code(t_start, obs):
+        active_codes = [seg[2] for seg in obs if seg[0] <= t_start < seg[1]]
+        if not active_codes:
+            return ""
+        # Sort to ensure deterministic representation (e.g., "A+B" instead of "B+A")
+        return "+".join(sorted(active_codes))
+
+    # ask user for the number of decimal places for rounding (can be negative)
+    round_decimals, ok = QInputDialog.getInt(
+        None, "Rounding", "Enter the number of decimal places for rounding (can be negative)", value=3, minValue=-5, maxValue=3, step=1
+    )
+
+    # round times
+    df["Start (s)"] = df["Start (s)"].round(round_decimals)
+    df["Stop (s)"] = df["Stop (s)"].round(round_decimals)
+
+    # Get unique values
+    unique_obs_list = df["Observation id"].unique().tolist()
+
+    # Convert to tuples grouped by observation
+    grouped = {
+        obs: [
+            (row[0], row[1], row[2] + "|" + row[3])  # concatenate subject and behavior with |
+            for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"]].itertuples(index=False, name=None)
+        ]
+        for obs, group in df.groupby("Observation id")
+    }
+
+    ck_results: Dict[Tuple[str, str], str] = {}
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        # Perfect agreement with itself
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # get all the break points
+            time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+            # elementary intervals
+            elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+            obs1_codes = [get_code(t[0], obs1) for t in elementary_intervals]
+
+            obs2_codes = [get_code(t[0], obs2) for t in elementary_intervals]
+
+            # Cohen's Kappa
+            kappa = cohen_kappa_score(obs1_codes, obs2_codes)
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa : {kappa:.3f}")
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results

boris/analysis_plugins/irr_cohen_kappa_with_modifiers.py

@@ -0,0 +1,112 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Unweighted Cohen's Kappa with modifiers
+"""
+
+import pandas as pd
+
+from sklearn.metrics import cohen_kappa_score
+from PySide6.QtWidgets import QInputDialog
+
+__version__ = "0.0.3"
+__version_date__ = "2025-09-02"
+__plugin_name__ = "Inter Rater Reliability - Unweighted Cohen's Kappa with modifiers"
+__author__ = "Olivier Friard - University of Torino - Italy"
+__description__ = """
+This plugin calculates Cohen's Kappa to measure inter-rater reliability between two observers who code categorical behaviors over time intervals.
+Unlike the weighted version, this approach does not take into account the duration of the intervals.
+Each segment of time is treated equally, regardless of how long it lasts.
+This plugin takes into account the modifiers.
+
+
+How it works:
+
+Time segmentation
+The program identifies all the time boundaries (start and end points) used by both observers.
+These boundaries are merged into a common timeline, which is then divided into a set of non-overlapping elementary intervals.
+
+Assigning codes
+For each elementary interval, the program determines which behavior was coded by each observer.
+
+Comparison of codes
+The program builds two parallel lists of behavior codes, one for each observer.
+Each elementary interval is counted as one unit of observation, no matter how long the interval actually lasts.
+
+Cohen's Kappa calculation
+Using these two lists, the program computes Cohen's Kappa using the cohen_kappa_score function of the sklearn package.
+(see https://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html for details)
+This coefficient measures how much the observers agree on their coding, adjusted for the amount of agreement that would be expected by chance.
+
+"""
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Unweighted Cohen's Kappa with modifiers
+    """
+
+    # Attribute all active codes for each interval
+    def get_code(t_start, obs):
+        active_codes = [seg[2] for seg in obs if seg[0] <= t_start < seg[1]]
+        if not active_codes:
+            return ""
+        # Sort to ensure deterministic representation (e.g., "A+B" instead of "B+A")
+        return "+".join(sorted(active_codes))
+
+    # ask user for the number of decimal places for rounding (can be negative)
+    round_decimals, ok = QInputDialog.getInt(
+        None, "Rounding", "Enter the number of decimal places for rounding (can be negative)", value=3, minValue=-5, maxValue=3, step=1
+    )
+
+    # round times
+    df["Start (s)"] = df["Start (s)"].round(round_decimals)
+    df["Stop (s)"] = df["Stop (s)"].round(round_decimals)
+
+    # Get unique values
+    unique_obs_list = df["Observation id"].unique().tolist()
+
+    # Convert to tuples grouped by observation
+    grouped: dict = {}
+    modifiers: list = []
+    for col in df.columns:
+        if isinstance(col, tuple):
+            modifiers.append(col)
+
+    for obs, group in df.groupby("Observation id"):
+        o: list = []
+        for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"] + modifiers].itertuples(index=False, name=None):
+            modif_list = [row[i] for idx, i in enumerate(range(4, 4 + len(modifiers))) if modifiers[idx][0] == row[3]]
+            o.append((row[0], row[1], row[2] + "|" + row[3] + "|" + ",".join(modif_list)))
+        grouped[obs] = o
+
+    ck_results: dict = {}
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # get all the break points
+            time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+            # elementary intervals
+            elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+            obs1_codes = [get_code(t[0], obs1) for t in elementary_intervals]
+
+            obs2_codes = [get_code(t[0], obs2) for t in elementary_intervals]
+
+            # Cohen's Kappa
+            kappa = cohen_kappa_score(obs1_codes, obs2_codes)
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa : {kappa:.3f}")
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results

boris/analysis_plugins/irr_weighted_cohen_kappa.py

@@ -0,0 +1,157 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Weighted Cohen's Kappa
+"""
+
+import pandas as pd
+from typing import List, Tuple, Dict, Optional
+
+from PySide6.QtWidgets import QInputDialog
+
+__version__ = "0.0.3"
+__version_date__ = "2025-09-02"
+__plugin_name__ = "Inter Rater Reliability - Weighted Cohen's Kappa"
+__author__ = "Olivier Friard - University of Torino - Italy"
+__description__ = """
+This plugin calculates Cohen's Kappa to measure inter-rater reliability between two observers who code categorical behaviors over time intervals.
+Unlike the unweighted version, this approach takes into account the duration of each coded interval, giving more weight to longer intervals in the agreement calculation.
+This plugin does not take into account the modifiers.
+
+How it works:
+
+Time segmentation
+The program collects all the time boundaries from both observers and merges them into a unified set of time points.
+These define a set of non-overlapping elementary intervals covering the entire observed period.
+
+Assigning codes
+For each elementary interval, the program identifies the behavior category assigned by each observer.
+
+Weighted contingency table
+Instead of treating each interval equally, the program assigns a weight equal to the duration of the interval.
+These durations are accumulated in a contingency table that records how much time was spent in each combination of categories across the two observers.
+
+Agreement calculation
+
+Observed agreement (po): The proportion of total time where both observers assigned the same category.
+
+Expected agreement (pe): The proportion of agreement expected by chance, based on the time-weighted marginal distributions of each observer's coding.
+
+Cohen's Kappa (κ): Computed from the weighted observed and expected agreements.
+"""
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Weighted Cohen's Kappa
+    """
+
+    def cohen_kappa_weighted_by_time(
+        obs1: List[Tuple[float, float, str]], obs2: List[Tuple[float, float, str]]
+    ) -> Tuple[float, float, float, Dict[Tuple[Optional[str], Optional[str]], float]]:
+        """
+        Compute Cohen's Kappa weighted by time duration.
+
+        Args:
+            obs1: List of (start_time, end_time, code) for observer 1
+            obs2: List of (start_time, end_time, code) for observer 2
+
+        Returns:
+            kappa (float): Cohen's Kappa weighted by duration
+            po (float): Observed agreement proportion (weighted)
+            pe (float): Expected agreement proportion by chance (weighted)
+            contingency (dict): Contingency table {(code1, code2): total_duration}
+        """
+
+        # 1. Collect all time boundaries from both observers
+        time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+        # 2. Build elementary intervals (non-overlapping time bins)
+        elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+        # 3. # Attribute all active codes for each interval
+        def get_code(t: float, obs: List[Tuple[float, float, str]]) -> Optional[str]:
+            active_codes = [seg[2] for seg in obs if seg[0] <= t < seg[1]]
+            if not active_codes:
+                return None
+            return "+".join(sorted(active_codes))
+
+        # 4. Build weighted contingency table (durations instead of counts)
+        contingency: Dict[Tuple[Optional[str], Optional[str]], float] = {}
+        total_time = 0.0
+
+        for start, end in elementary_intervals:
+            c1 = get_code(start, obs1)
+            c2 = get_code(start, obs2)
+            duration = end - start
+            total_time += duration
+            contingency[(c1, c2)] = contingency.get((c1, c2), 0.0) + duration
+
+        # 5. Observed agreement (po)
+        po = sum(duration for (c1, c2), duration in contingency.items() if c1 == c2) / total_time
+
+        # Marginal distributions for each observer
+        codes1: Dict[Optional[str], float] = {}
+        codes2: Dict[Optional[str], float] = {}
+        for (c1, c2), duration in contingency.items():
+            codes1[c1] = codes1.get(c1, 0.0) + duration
+            codes2[c2] = codes2.get(c2, 0.0) + duration
+
+        # 6. Expected agreement (pe), using marginal proportions
+        all_codes = set(codes1) | set(codes2)
+        pe = sum((codes1.get(c, 0.0) / total_time) * (codes2.get(c, 0.0) / total_time) for c in all_codes)
+
+        # 7. Kappa calculation
+        kappa = (po - pe) / (1 - pe) if (1 - pe) != 0 else 0.0
+
+        return kappa, po, pe, contingency
+
+    # ask user for the number of decimal places for rounding (can be negative)
+    round_decimals, ok = QInputDialog.getInt(
+        None, "Rounding", "Enter the number of decimal places for rounding (can be negative)", value=3, minValue=-5, maxValue=3, step=1
+    )
+
+    # round times
+    df["Start (s)"] = df["Start (s)"].round(round_decimals)
+    df["Stop (s)"] = df["Stop (s)"].round(round_decimals)
+
+    # Get unique values as a numpy array
+    unique_obs = df["Observation id"].unique()
+
+    # Convert to a list
+    unique_obs_list = unique_obs.tolist()
+
+    # Convert to tuples grouped by observation
+    grouped = {
+        obs: [
+            (row[0], row[1], row[2] + "|" + row[3])  # concatenate subject and behavior with |
+            for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"]].itertuples(index=False, name=None)
+        ]
+        for obs, group in df.groupby("Observation id")
+    }
+
+    ck_results: dict = {}
+    str_results: str = ""
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # Cohen's Kappa
+            kappa, po, pe, table = cohen_kappa_weighted_by_time(obs1, obs2)
+
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}")
+            str_results += (
+                f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}\n"
+            )
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results, str_results