Was already missing at lines 52-55

         else:
-             for span in candidates:
-                 if span.label_ in span_filter:
-                     yield span

     if span_getter is None:
-         yield doc[:], None
-         return
     if callable(span_getter):

     if callable(span_getter):
-         yield from span_getter(doc)
-         return
     for key, span_filter in span_getter.items():

         if key == "*":
-             candidates = (
                 (span, group) for group in doc.spans.values() for span in group

         else:
-             for span, group in candidates:
-                 if span.label_ in span_filter:
-                     yield span, group

     if callable(span_setter):
-         span_setter(doc, matches)
     else:

             elif isinstance(v, str):
-                 new_value[k] = [v]
             elif isinstance(v, list) and all(isinstance(i, str) for i in v):

             elif isinstance(v, str):
-                 new_value[k] = [v]
             elif isinstance(v, list) and all(isinstance(i, str) for i in v):

Was already missing at line 33

     if not verbs:
-         return conjugated_verbs

Was already missing at line 34

     else:
-         string = s
     string = string.lower().strip()

         return int(string)
-     except ValueError:
-         parsed = DIGITS_MAPPINGS.get(string, None)
-         return parsed

Was already missing at line 46

             ):
-                 continue
             for import_node in node.body:

Was already missing at line 206

     if isinstance(label, int):
-         return [span for span in spans if span.label == label]
     else:

Was already missing at line 22

         return "." + path
-     return path

Was already missing at line 190

         else:
-             sample_len = lambda idx, noise=True: 1  # noqa: E731

             if total + num_tokens > self.grad_accumulation_max_tokens:
-                 print(
  ...
-                 mini_batches.append([])
             total += num_tokens

             if 0 <= self.limit <= count:
-                 break
             if not (len(doc) and (filter_fn is None or filter_fn(doc))):

             if not (len(doc) and (filter_fn is None or filter_fn(doc))):
-                 continue
             count += 1

             for ent in doc.ents:
-                 for token in ent:
-                     token.is_sent_start = False
             for sent in doc.sents if doc.has_annotation("SENT_START") else (doc[:],):

Was already missing at line 51

         getActiveSession = SparkSession.getActiveSession
-     except AttributeError:

Was already missing at lines 227-231

 if os.environ.get("TORCH_SHARING_STRATEGY"):
-     try:
-         torch.multiprocessing.set_sharing_strategy(os.environ["TORCH_SHARING_STRATEGY"])
-     except NameError:
-         pass

         def save_align_devices_hook(pickler: Any, obj: Any):
-             pickler.save_reduce(load_align_devices_hook, (obj.__dict__,), obj=obj)

         def load_align_devices_hook(state):
-             state["execution_device"] = MAP_LOCATION
  ...
-         AlignDevicesHook = None

-             new_batch_iterator = None

                     else:
-                         batch = gpu_pipe.prepare_batch(docs, device=device)
-                         inputs = None
                     active_batches[batch_id] = (docs, task_id, inputs)

         if isinstance(outputs, BaseException):
-             raise outputs

                 if v is not None:
-                     os.environ[k] = v

Was already missing at lines 207-209

         def converter(doc):
-             res = results_extractor(doc)
-             return (
                 [{"note_id": doc._.note_id, **row} for row in res]

Was already missing at lines 401-403

             if self.reference_mode == "synonym":
-                 embeds = embeds.to(new_lin.weight)
-                 new_lin.weight.data = embeds
             else:

Was already missing at line 250

         if self.labels is not None and not self.infer_span_setter:
-             return

             if callable(self.target_span_getter):
-                 for span in get_spans(doc, self.target_span_getter):
-                     inferred_labels.add(span.label_)
             else:

Was already missing at line 21

     # out: 2 * N * O
-     return (log_A.unsqueeze(-1) + log_B.unsqueeze(-3)).logsumexp(-2)

     # out: 2 * N * O
-     return (log_A.unsqueeze(-1) + log_B.unsqueeze(-3)).max(-2)

         if learnable_transitions:
-             self.transitions = torch.nn.Parameter(
                 torch.zeros_like(forbidden_transitions, dtype=torch.float)

         if learnable_transitions and with_start_end_transitions:
-             self.start_transitions = torch.nn.Parameter(
                 torch.zeros(num_tags, dtype=torch.float)

         if learnable_transitions and with_start_end_transitions:
-             self.end_transitions = torch.nn.Parameter(
                 torch.zeros(num_tags, dtype=torch.float)

Was already missing at line 165

         if quantization is not None:
-             kwargs["quantization_config"] = quantization

Was already missing at lines 18-22

         return "REPORTED"
-     elif token._.rspeech is False:
-         return "DIRECT"
-     else:
-         return None

Was already missing at line 22

     else:
-         return None

Was already missing at line 21

     else:
-         return None

Was already missing at lines 20-26

 def history_getter(token: Union[Token, Span]) -> Optional[str]:
-     if token._.history is True:
-         return "ATCD"
-     elif token._.history is False:
-         return "CURRENT"
-     else:
-         return None

                 )
-             except ValueError:
  ...
-                 note_datetime = None

                 )
-             except ValueError:
  ...
-                 birth_datetime = None

                         )
-                     except ValueError as e:
-                         absolute_date = None
-                         logger.warning(
                             "In doc {}, the following date {} raises this error: {}. "

Was already missing at line 21

     else:
-         return None

Was already missing at lines 156-158

                 value = TNM.parse_obj(groupdict)
-             except ValidationError:
-                 value = TNM.parse_obj({})

Was already missing at line 139

     def __str__(self):
-         return self.norm()

             )
-             exclude_unset = skip_defaults

Was already missing at line 32

             if not assigned:
-                 continue
             if assigned.get("method_max") is not None:

             else:
-                 method = "Non précisée"

Was already missing at line 26

         if x <= 5:
-             return 1

         else:
-             return 3
- 
-     except ValueError:
-         return None

Was already missing at lines 21-23

             return int(extracted_score)
-     except ValueError:
-         return None

Was already missing at line 154

             if value is None:
-                 continue
             normalized_value = self.score_normalization(value)

Was already missing at lines 114-117

         if use_tnm:
-             from edsnlp.pipes.ner.tnm import TNM
- 
-             self.tnm = TNM(nlp, pattern=None, attr="TEXT")

     def process_tnm(self, doc):
-         spans = self.tnm.process(doc)
  ...
-             yield span

         if self.use_tnm:
-             yield from self.process_tnm(doc)

Was already missing at line 106

                 if "peripheral" not in span._.assigned.keys():
-                     continue

Was already missing at line 133

                 # Mostly FP
-                 continue

             elif self.has_far_complications(span):
-                 span._.status = 2

         if next(iter(self.complication_matcher(context)), None) is not None:
-             return True
         return False

Was already missing at line 102

                 # Huge change of FP / Title section
-                 continue

Was already missing at lines 119-122

             dfg_value = float(dfg_span.text.replace(",", ".").strip())
-         except ValueError:
-             logger.trace(f"DFG value couldn't be extracted from {dfg_span.text}")
-             return False

Was already missing at lines 110-112

             if span._.source == "ischemia":
-                 if "brain" not in span._.assigned.keys():
-                     continue

Was already missing at line 15

     def norm(self) -> str:
-         return self.code

     def __str__(self):
-         return self.norm()

Was already missing at line 126

         if sections is None:
-             sections = patterns.sections
         sections = dict(sections)

Was already missing at line 152

                     else:
-                         d["month"] = note_datetime.month
                 if self.day is None:

             else:
-                 if self.year is None:
  ...
-                     d["day"] = default_day

                 return dt
-             except ValueError:
-                 return None

         else:
-             return None

         if self.second:
-             norm += f"{self.second:02}s"

Was already missing at line 248

         if isinstance(absolute, str):
-             absolute = [absolute]
         if isinstance(relative, str):

         if isinstance(relative, str):
-             relative = [relative]
         if isinstance(duration, str):

         if isinstance(duration, str):
-             relative = [duration]
         if isinstance(false_positive, str):

             if self.merge_mode == "align":
-                 alignments = align_spans(matches, spans, sort_by_overlap=True)
  ...
-                         matches.append(span)

             elif d1 in seen or v1.bound is None or v2.bound is None:
-                 continue

                 if v1.mode == Mode.DURATION:
-                     m1 = Bound.FROM if v2.bound == Bound.UNTIL else Bound.UNTIL
-                     m2 = v2.mode or Bound.FROM
                 elif v2.mode == Mode.DURATION:

Was already missing at line 131

         else:
-             self.date_matcher = None

         if not consultation_mention:
-             consultation_mention = []
         elif consultation_mention is True:

Was already missing at line 7

 def excluded_or_space_getter(t):
-     return t.is_space or t.tag_ == "EXCLUDED"

Was already missing at lines 151-155

         if end_lines_model is None:
-             path = build_path(__file__, "base_model.pkl")
- 
-             with open(path, "rb") as inp:
-                 self.model = pickle.load(inp)
         elif isinstance(end_lines_model, str):

                 self.model = pickle.load(inp)
-         elif isinstance(end_lines_model, EndLinesModel):
-             self.model = end_lines_model
         else:

         ):
-             return "ENUMERATION"

         if np.isnan(sigma):
-             sigma = 1

Was already missing at lines 19-23

     if isinstance(v, list):
-         assert (
-             len(v) == 2
-         ), "`window` should be a tuple/list of two integer, or a single integer"
-         v = tuple(v)
     if isinstance(v, int):

Was already missing at line 94

             )
-             label = label_name
         if label is None:

                 if assigned is None:
-                     continue
                 if replace_entity:

Was already missing at lines 67-69

             # if module is reloaded.
-             existing_func = registry.factories.get(internal_name)
-             if not util.is_same_func(factory_func, existing_func):
                 raise ValueError(

Was already missing at line 32

     def param_groups(self, value):
-         self.optim.param_groups = value

     def state(self):
-         return self.optim.state

     def state(self, value):
-         self.optim.state = value

     def __init__(self, groups):
-         self.param_groups = groups

Was already missing at line 280

     if custom:
-         attr = attr[1:].lower()

             if custom:
-                 token_text = getattr(token._, attr)
             else:

Was already missing at line 103

             if last != begin:
-                 logger.warning(
                     "Missed some characters during"

Was already missing at line 43

     def __init__(self, ann_file, line):
-         super().__init__(f"File {ann_file}, unrecognized Brat line {line}")

     if not len(ann_paths):
-         return {
             "text": text,

                         )
-                 except Exception:
                     raise Exception(

Was already missing at line 26

         if hasattr(data, "collect"):
-             data = data.collect()
         assert isinstance(data, pl.DataFrame)

Was already missing at line 94

                     if not is_jsonl:
-                         obj[FILENAME] = filename
                     results.append(obj)

                     results.append(obj)
-             except Exception:
                 raise Exception(f"Cannot parse {filename}")

Was already missing at line 659

     if isinstance(converter, type) or kwargs_to_init:
-         return converter(**kwargs), {}
     return converter, validate_kwargs(converter, kwargs)

Was already missing at lines 174-180

     """
-     data = LazyCollection.ensure_lazy(data)
-     if converter:
-         converter, kwargs = get_doc2dict_converter(converter, kwargs)
-         data = data.map(converter, kwargs=kwargs)
- 
-     return data

Was already missing at line 390

             if hasattr(self, "compiled"):
-                 res = self.compiled(batch)
             else:

         """
-         return self.preprocess(doc)

Was already missing at line 78

             if obj.error is not None:
-                 raise obj.error

Was already missing at line 552

             if name in exclude:
-                 continue
             if name not in components:

Was already missing at line 51

     def __call__(self, *args, **kwargs):
-         return self.forward(*args, **kwargs)

         for name, pipe, *_ in self.torch_components():
-             pipe.to(device)
         return self

Was already missing at line 69

         if not isinstance(row.ents, list):
-             continue

             else:
-                 doc.spans[span.label_].append(span)

     if df.note_id.isna().any():
-         df["note_id"] = range(len(df))

         if i > 0:
-             df.term_modifiers += ";"
         df.term_modifiers += ext + "=" + df[ext].astype(str)