Fix dates in comments

Author: C-Achard

dlclive/core/inferenceutils.py

@@ -10,7 +10,7 @@
 #
 
 
-# NOTE - DUPLICATED @C-Achard 2026-26-01: Copied from the original DeepLabCut codebase
+# NOTE - DUPLICATED @C-Achard 2026-01-26: Copied from the original DeepLabCut codebase
 # from deeplabcut/core/inferenceutils.py
 from __future__ import annotations
 
@@ -66,7 +66,9 @@ def __init__(self, j1, j2, affinity=1):
         self._length = sqrt((j1.pos[0] - j2.pos[0]) ** 2 + (j1.pos[1] - j2.pos[1]) ** 2)
 
     def __repr__(self):
-        return f"Link {self.idx}, affinity={self.affinity:.2f}, length={self.length:.2f}"
+        return (
+            f"Link {self.idx}, affinity={self.affinity:.2f}, length={self.length:.2f}"
+        )
 
     @property
     def confidence(self):
@@ -264,7 +266,10 @@ def __init__(
         self.max_overlap = max_overlap
         self._has_identity = "identity" in self[0]
         if identity_only and not self._has_identity:
-            warnings.warn("The network was not trained with identity; setting `identity_only` to False.", stacklevel=2)
+            warnings.warn(
+                "The network was not trained with identity; setting `identity_only` to False.",
+                stacklevel=2,
+            )
         self.identity_only = identity_only & self._has_identity
         self.nan_policy = nan_policy
         self.force_fusion = force_fusion
@@ -345,15 +350,19 @@ def calibrate(self, train_data_file):
             pass
         n_bpts = len(df.columns.get_level_values("bodyparts").unique())
         if n_bpts == 1:
-            warnings.warn("There is only one keypoint; skipping calibration...", stacklevel=2)
+            warnings.warn(
+                "There is only one keypoint; skipping calibration...", stacklevel=2
+            )
             return
 
         xy = df.to_numpy().reshape((-1, n_bpts, 2))
         frac_valid = np.mean(~np.isnan(xy), axis=(1, 2))
         # Only keeps skeletons that are more than 90% complete
         xy = xy[frac_valid >= 0.9]
         if not xy.size:
-            warnings.warn("No complete poses were found. Skipping calibration...", stacklevel=2)
+            warnings.warn(
+                "No complete poses were found. Skipping calibration...", stacklevel=2
+            )
             return
 
         # TODO Normalize dists by longest length?
@@ -369,9 +378,14 @@ def calibrate(self, train_data_file):
             self.safe_edge = True
         except np.linalg.LinAlgError:
             # Covariance matrix estimation fails due to numerical singularities
-            warnings.warn("The assembler could not be robustly calibrated. Continuing without it...", stacklevel=2)
+            warnings.warn(
+                "The assembler could not be robustly calibrated. Continuing without it...",
+                stacklevel=2,
+            )
 
-    def calc_assembly_mahalanobis_dist(self, assembly, return_proba=False, nan_policy="little"):
+    def calc_assembly_mahalanobis_dist(
+        self, assembly, return_proba=False, nan_policy="little"
+    ):
         if self._kde is None:
             raise ValueError("Assembler should be calibrated first with training data.")
 
@@ -425,7 +439,9 @@ def _flatten_detections(data_dict):
             ids = [np.ones(len(arr), dtype=int) * -1 for arr in confidence]
         else:
             ids = [arr.argmax(axis=1) for arr in ids]
-        for i, (coords, conf, id_) in enumerate(zip(coordinates, confidence, ids, strict=False)):
+        for i, (coords, conf, id_) in enumerate(
+            zip(coordinates, confidence, ids, strict=False)
+        ):
             if not np.any(coords):
                 continue
             for xy, p, g in zip(coords, conf, id_, strict=False):
@@ -450,7 +466,9 @@ def extract_best_links(self, joints_dict, costs, trees=None):
             aff[np.isnan(aff)] = 0
 
             if trees:
-                vecs = np.vstack([[*det_s.pos, *det_t.pos] for det_s in dets_s for det_t in dets_t])
+                vecs = np.vstack(
+                    [[*det_s.pos, *det_t.pos] for det_s in dets_s for det_t in dets_t]
+                )
                 dists = []
                 for n, tree in enumerate(trees, start=1):
                     d, _ = tree.query(vecs)
@@ -459,8 +477,15 @@ def extract_best_links(self, joints_dict, costs, trees=None):
                 aff *= w.reshape(aff.shape)
 
             if self.greedy:
-                conf = np.asarray([[det_s.confidence * det_t.confidence for det_t in dets_t] for det_s in dets_s])
-                rows, cols = np.where((conf >= self.pcutoff * self.pcutoff) & (aff >= self.min_affinity))
+                conf = np.asarray(
+                    [
+                        [det_s.confidence * det_t.confidence for det_t in dets_t]
+                        for det_s in dets_s
+                    ]
+                )
+                rows, cols = np.where(
+                    (conf >= self.pcutoff * self.pcutoff) & (aff >= self.min_affinity)
+                )
                 candidates = sorted(
                     zip(rows, cols, aff[rows, cols], lengths[rows, cols], strict=False),
                     key=lambda x: x[2],
@@ -476,14 +501,18 @@ def extract_best_links(self, joints_dict, costs, trees=None):
                         if len(i_seen) == self.max_n_individuals:
                             break
             else:  # Optimal keypoint pairing
-                inds_s = sorted(range(len(dets_s)), key=lambda x: dets_s[x].confidence, reverse=True)[
-                    : self.max_n_individuals
+                inds_s = sorted(
+                    range(len(dets_s)), key=lambda x: dets_s[x].confidence, reverse=True
+                )[: self.max_n_individuals]
+                inds_t = sorted(
+                    range(len(dets_t)), key=lambda x: dets_t[x].confidence, reverse=True
+                )[: self.max_n_individuals]
+                keep_s = [
+                    ind for ind in inds_s if dets_s[ind].confidence >= self.pcutoff
                 ]
-                inds_t = sorted(range(len(dets_t)), key=lambda x: dets_t[x].confidence, reverse=True)[
-                    : self.max_n_individuals
+                keep_t = [
+                    ind for ind in inds_t if dets_t[ind].confidence >= self.pcutoff
                 ]
-                keep_s = [ind for ind in inds_s if dets_s[ind].confidence >= self.pcutoff]
-                keep_t = [ind for ind in inds_t if dets_t[ind].confidence >= self.pcutoff]
                 aff = aff[np.ix_(keep_s, keep_t)]
                 rows, cols = linear_sum_assignment(aff, maximize=True)
                 for row, col in zip(rows, cols, strict=False):
@@ -522,7 +551,9 @@ def push_to_stack(i):
             if new_ind in assembled:
                 continue
             if safe_edge:
-                d_old = self.calc_assembly_mahalanobis_dist(assembly, nan_policy=nan_policy)
+                d_old = self.calc_assembly_mahalanobis_dist(
+                    assembly, nan_policy=nan_policy
+                )
                 success = assembly.add_link(best, store_dict=True)
                 if not success:
                     assembly._dict = dict()
@@ -575,7 +606,9 @@ def build_assemblies(self, links):
                 continue
             assembly = Assembly(self.n_multibodyparts)
             assembly.add_link(link)
-            self._fill_assembly(assembly, lookup, assembled, self.safe_edge, self.nan_policy)
+            self._fill_assembly(
+                assembly, lookup, assembled, self.safe_edge, self.nan_policy
+            )
             for assembly_link in assembly._links:
                 i, j = assembly_link.idx
                 lookup[i].pop(j)
@@ -587,7 +620,10 @@ def build_assemblies(self, links):
         n_extra = len(assemblies) - self.max_n_individuals
         if n_extra > 0:
             if self.safe_edge:
-                ds_old = [self.calc_assembly_mahalanobis_dist(assembly) for assembly in assemblies]
+                ds_old = [
+                    self.calc_assembly_mahalanobis_dist(assembly)
+                    for assembly in assemblies
+                ]
                 while len(assemblies) > self.max_n_individuals:
                     ds = []
                     for i, j in itertools.combinations(range(len(assemblies)), 2):
@@ -719,7 +755,10 @@ def _assemble(self, data_dict, ind_frame):
             for _, group in groups:
                 ass = Assembly(self.n_multibodyparts)
                 for joint in sorted(group, key=lambda x: x.confidence, reverse=True):
-                    if joint.confidence >= self.pcutoff and joint.label < self.n_multibodyparts:
+                    if (
+                        joint.confidence >= self.pcutoff
+                        and joint.label < self.n_multibodyparts
+                    ):
                         ass.add_joint(joint)
                 if len(ass):
                     assemblies.append(ass)
@@ -748,15 +787,21 @@ def _assemble(self, data_dict, ind_frame):
             assembled.update(assembled_)
 
         # Remove invalid assemblies
-        discarded = set(joint for joint in joints if joint.idx not in assembled and np.isfinite(joint.confidence))
+        discarded = set(
+            joint
+            for joint in joints
+            if joint.idx not in assembled and np.isfinite(joint.confidence)
+        )
         for assembly in assemblies[::-1]:
             if 0 < assembly.n_links < self.min_n_links or not len(assembly):
                 for link in assembly._links:
                     discarded.update((link.j1, link.j2))
                 assemblies.remove(assembly)
         if 0 < self.max_overlap < 1:  # Non-maximum pose suppression
             if self._kde is not None:
-                scores = [-self.calc_assembly_mahalanobis_dist(ass) for ass in assemblies]
+                scores = [
+                    -self.calc_assembly_mahalanobis_dist(ass) for ass in assemblies
+                ]
             else:
                 scores = [ass._affinity for ass in assemblies]
             lst = list(zip(scores, assemblies, strict=False))
@@ -825,7 +870,9 @@ def wrapped(i):
             n_frames = len(self.metadata["imnames"])
             with multiprocessing.Pool(n_processes) as p:
                 with tqdm(total=n_frames) as pbar:
-                    for i, (assemblies, unique) in p.imap_unordered(wrapped, range(n_frames), chunksize=chunk_size):
+                    for i, (assemblies, unique) in p.imap_unordered(
+                        wrapped, range(n_frames), chunksize=chunk_size
+                    ):
                         if assemblies:
                             self.assemblies[i] = assemblies
                         if unique is not None:
@@ -844,7 +891,9 @@ def parse_metadata(data):
         params["joint_names"] = data["metadata"]["all_joints_names"]
         params["num_joints"] = len(params["joint_names"])
         params["paf_graph"] = data["metadata"]["PAFgraph"]
-        params["paf"] = data["metadata"].get("PAFinds", np.arange(len(params["joint_names"])))
+        params["paf"] = data["metadata"].get(
+            "PAFinds", np.arange(len(params["joint_names"]))
+        )
         params["bpts"] = params["ibpts"] = range(params["num_joints"])
         params["imnames"] = [fn for fn in list(data) if fn != "metadata"]
         return params
@@ -934,7 +983,11 @@ def calc_object_keypoint_similarity(
     else:
         oks = []
         xy_preds = [xy_pred]
-        combos = (pair for l in range(len(symmetric_kpts)) for pair in itertools.combinations(symmetric_kpts, l + 1))
+        combos = (
+            pair
+            for l in range(len(symmetric_kpts))
+            for pair in itertools.combinations(symmetric_kpts, l + 1)
+        )
         for pairs in combos:
             # Swap corresponding keypoints
             tmp = xy_pred.copy()
@@ -971,7 +1024,9 @@ def match_assemblies(
     num_ground_truth = len(ground_truth)
 
     # Sort predictions by score
-    inds_pred = np.argsort([ins.affinity if ins.n_links else ins.confidence for ins in predictions])[::-1]
+    inds_pred = np.argsort(
+        [ins.affinity if ins.n_links else ins.confidence for ins in predictions]
+    )[::-1]
     predictions = np.asarray(predictions)[inds_pred]
 
     # indices of unmatched ground truth assemblies
@@ -1078,7 +1133,9 @@ def find_outlier_assemblies(dict_of_assemblies, criterion="area", qs=(5, 95)):
         raise ValueError(f"Invalid criterion {criterion}.")
 
     if len(qs) != 2:
-        raise ValueError("Two percentiles (for lower and upper bounds) should be given.")
+        raise ValueError(
+            "Two percentiles (for lower and upper bounds) should be given."
+        )
 
     tuples = []
     for frame_ind, assemblies in dict_of_assemblies.items():
@@ -1182,7 +1239,9 @@ def evaluate_assembly_greedy(
         oks = np.asarray([match.oks for match in all_matched])[sorted_pred_indices]
 
         # Compute prediction and recall
-        p, r = _compute_precision_and_recall(total_gt_assemblies, oks, oks_t, recall_thresholds)
+        p, r = _compute_precision_and_recall(
+            total_gt_assemblies, oks, oks_t, recall_thresholds
+        )
         precisions.append(p)
         recalls.append(r)
 
@@ -1255,7 +1314,9 @@ def evaluate_assembly(
     precisions = []
     recalls = []
     for t in oks_thresholds:
-        p, r = _compute_precision_and_recall(total_gt_assemblies, oks, t, recall_thresholds)
+        p, r = _compute_precision_and_recall(
+            total_gt_assemblies, oks, t, recall_thresholds
+        )
         precisions.append(p)
         recalls.append(r)
 

dlclive/modelzoo/resolve_config.py

@@ -3,7 +3,7 @@
 For instance, "num_bodyparts x 2" is replaced with the number of bodyparts multiplied by 2.
 """
 
-# NOTE - DUPLICATED @deruyter92 2026-23-01: Copied from the original DeepLabCut codebase
+# NOTE - DUPLICATED @deruyter92 2026-01-23: Copied from the original DeepLabCut codebase
 # from deeplabcut/pose_estimation_pytorch/modelzoo/utils.py
 import copy
 
@@ -99,7 +99,9 @@ def get_updated_value(variable: str) -> int | list[int]:
             else:
                 raise ValueError(f"Unknown operator for variable: {variable}")
 
-        raise ValueError(f"Found {variable} in the configuration file, but cannot parse it.")
+        raise ValueError(
+            f"Found {variable} in the configuration file, but cannot parse it."
+        )
 
     updated_values = {
         "num_bodyparts": num_bodyparts,
@@ -125,7 +127,10 @@ def get_updated_value(variable: str) -> int | list[int]:
                 backbone_output_channels,
                 **kwargs,
             )
-        elif isinstance(config[k], str) and config[k].strip().split(" ")[0] in updated_values.keys():
+        elif (
+            isinstance(config[k], str)
+            and config[k].strip().split(" ")[0] in updated_values.keys()
+        ):
             config[k] = get_updated_value(config[k])
 
     return config

dlclive/modelzoo/utils.py

@@ -69,7 +69,7 @@ def read_config_as_dict(config_path: str | Path) -> dict:
     return cfg
 
 
-# NOTE - DUPLICATED @deruyter92 2026-23-01: Copied from the original DeepLabCut codebase
+# NOTE - DUPLICATED @deruyter92 2026-01-23: Copied from the original DeepLabCut codebase
 # from deeplabcut/pose_estimation_pytorch/config/make_pose_config.py
 def add_metadata(
     project_config: dict,
@@ -98,7 +98,7 @@ def add_metadata(
     return config
 
 
-# NOTE - DUPLICATED @deruyter92 2026-23-01: Copied from the original DeepLabCut codebase
+# NOTE - DUPLICATED @deruyter92 2026-01-23: Copied from the original DeepLabCut codebase
 # from deeplabcut/pose_estimation_pytorch/modelzoo/utils.py
 def load_super_animal_config(
     super_animal: str,

dlclive/pose_estimation_pytorch/dynamic_cropping.py

@@ -8,7 +8,7 @@
 #
 # Licensed under GNU Lesser General Public License v3.0
 
-# NOTE DUPLICATED @C-Achard 2026-26-01: Duplication between this file
+# NOTE DUPLICATED @C-Achard 2026-01-26: Duplication between this file
 # and deeplabcut/pose_estimation_pytorch/runners/dynamic_cropping.py
 # NOTE Testing already exists at deeplabcut/tests/pose_estimation_pytorch/runners/test_dynamic_cropper.py
 """Modules to dynamically crop individuals out of videos to improve video analysis"""
@@ -82,7 +82,9 @@ def crop(self, image: torch.Tensor) -> torch.Tensor:
                 height.
         """
         if len(image) != 1:
-            raise RuntimeError(f"DynamicCropper can only be used with batch size 1 (found image shape: {image.shape})")
+            raise RuntimeError(
+                f"DynamicCropper can only be used with batch size 1 (found image shape: {image.shape})"
+            )
 
         if self._shape is None:
             self._shape = image.shape[3], image.shape[2]
@@ -307,7 +309,9 @@ def crop(self, image: torch.Tensor) -> torch.Tensor:
                 `crop` was previously called with an image of a different W or H.
         """
         if len(image) != 1:
-            raise RuntimeError(f"DynamicCropper can only be used with batch size 1 (found image shape: {image.shape})")
+            raise RuntimeError(
+                f"DynamicCropper can only be used with batch size 1 (found image shape: {image.shape})"
+            )
 
         if self._shape is None:
             self._shape = image.shape[3], image.shape[2]
@@ -394,7 +398,9 @@ def update(self, pose: torch.Tensor) -> torch.Tensor:
 
         return pose
 
-    def _prepare_bounding_box(self, x1: int, y1: int, x2: int, y2: int) -> tuple[int, int, int, int]:
+    def _prepare_bounding_box(
+        self, x1: int, y1: int, x2: int, y2: int
+    ) -> tuple[int, int, int, int]:
         """Prepares the bounding box for cropping.
 
         Adds a margin around the bounding box, then transforms it into the target aspect
@@ -491,8 +497,12 @@ def generate_patches(self) -> list[tuple[int, int, int, int]]:
         Returns:
             A list of patch coordinates as tuples (x0, y0, x1, y1).
         """
-        patch_xs = self.split_array(self._shape[0], self._patch_counts[0], self._patch_overlap)
-        patch_ys = self.split_array(self._shape[1], self._patch_counts[1], self._patch_overlap)
+        patch_xs = self.split_array(
+            self._shape[0], self._patch_counts[0], self._patch_overlap
+        )
+        patch_ys = self.split_array(
+            self._shape[1], self._patch_counts[1], self._patch_overlap
+        )
 
         patches = []
         for y0, y1 in patch_ys: