csv-detective 0.8.1.dev1674__py3-none-any.whl → 0.8.1.dev1720__py3-none-any.whl

csv_detective/detect_fields/FR/temp/mois_de_annee/__init__.py

@@ -2,37 +2,37 @@ from unidecode import unidecode
 
 PROPORTION = 1
 mois = {
-    'janvier',
-    'fevrier',
-    'mars',
-    'avril',
-    'mai',
-    'juin',
-    'juillet',
-    'aout',
-    'septembre',
-    'octobre',
-    'novembre',
-    'decembre',
-    'jan',
-    'fev',
-    'mar',
-    'avr',
-    'mai',
-    'jun',
-    'jui',
-    'juil',
-    'aou',
-    'sep',
-    'sept',
-    'oct',
-    'nov',
-    'dec'
+    "janvier",
+    "fevrier",
+    "mars",
+    "avril",
+    "mai",
+    "juin",
+    "juillet",
+    "aout",
+    "septembre",
+    "octobre",
+    "novembre",
+    "decembre",
+    "jan",
+    "fev",
+    "mar",
+    "avr",
+    "mai",
+    "jun",
+    "jui",
+    "juil",
+    "aou",
+    "sep",
+    "sept",
+    "oct",
+    "nov",
+    "dec",
 }
 
 
 def _is(val):
-    '''Renvoie True si les champs peuvent être des mois de l'année'''
+    """Renvoie True si les champs peuvent être des mois de l'année"""
     if not isinstance(val, str):
         return False
     val = unidecode(val.lower())

csv_detective/detect_fields/geo/iso_country_code_alpha2/__init__.py

@@ -1,15 +1,15 @@
-from os.path import dirname, join
 import re
+from os.path import dirname, join
 
 PROPORTION = 1
 
-with open(join(dirname(__file__), 'iso_country_code_alpha2.txt'), 'r') as iofile:
-    liste_pays = iofile.read().split('\n')
+with open(join(dirname(__file__), "iso_country_code_alpha2.txt"), "r") as iofile:
+    liste_pays = iofile.read().split("\n")
 liste_pays = set(liste_pays)
 
 
 def _is(val):
-    '''Renvoie True si val peut etre un code iso pays alpha-2, False sinon'''
-    if not isinstance(val, str) or not bool(re.match(r'[A-Z]{2}$', val)):
+    """Renvoie True si val peut etre un code iso pays alpha-2, False sinon"""
+    if not isinstance(val, str) or not bool(re.match(r"[A-Z]{2}$", val)):
         return False
     return val in liste_pays

csv_detective/detect_fields/geo/iso_country_code_alpha3/__init__.py

@@ -1,14 +1,14 @@
-from os.path import dirname, join
 import re
+from os.path import dirname, join
 
 PROPORTION = 1
 
-with open(join(dirname(__file__), 'iso_country_code_alpha3.txt'), 'r') as iofile:
-    liste_pays = iofile.read().split('\n')
+with open(join(dirname(__file__), "iso_country_code_alpha3.txt"), "r") as iofile:
+    liste_pays = iofile.read().split("\n")
 
 
 def _is(val):
-    '''Renvoie True si val peut etre un code iso pays alpha-3, False sinon'''
-    if not isinstance(val, str) or not bool(re.match(r'[A-Z]{3}$', val)):
+    """Renvoie True si val peut etre un code iso pays alpha-3, False sinon"""
+    if not isinstance(val, str) or not bool(re.match(r"[A-Z]{3}$", val)):
         return False
     return val in set(liste_pays)

csv_detective/detect_fields/geo/iso_country_code_numeric/__init__.py

@@ -1,15 +1,15 @@
-from os.path import dirname, join
 import re
+from os.path import dirname, join
 
 PROPORTION = 1
 
-with open(join(dirname(__file__), 'iso_country_code_numeric.txt'), 'r') as iofile:
-    liste_pays = iofile.read().split('\n')
+with open(join(dirname(__file__), "iso_country_code_numeric.txt"), "r") as iofile:
+    liste_pays = iofile.read().split("\n")
 liste_pays = set(liste_pays)
 
 
 def _is(val):
-    '''Renvoie True si val peut etre un code iso pays numerique, False sinon'''
-    if not isinstance(val, str) or not bool(re.match(r'[0-9]{3}$', val)):
+    """Renvoie True si val peut etre un code iso pays numerique, False sinon"""
+    if not isinstance(val, str) or not bool(re.match(r"[0-9]{3}$", val)):
         return False
     return val in liste_pays

csv_detective/detect_fields/geo/latitude_wgs/__init__.py

@@ -4,7 +4,7 @@ PROPORTION = 0.9
 
 
 def _is(val):
-    '''Renvoie True si val peut etre une latitude'''
+    """Renvoie True si val peut etre une latitude"""
     try:
         return is_float(val) and float(val) >= -90 and float(val) <= 90
     except ValueError:

csv_detective/detect_fields/geo/longitude_wgs/__init__.py

@@ -4,7 +4,7 @@ PROPORTION = 0.9
 
 
 def _is(val):
-    '''Renvoie True si val peut etre une longitude'''
+    """Renvoie True si val peut etre une longitude"""
     try:
         return is_float(val) and float(val) >= -180 and float(val) <= 180
     except ValueError:

csv_detective/detect_fields/other/booleen/__init__.py

@@ -23,5 +23,5 @@ def bool_casting(val: str) -> bool:
 
 
 def _is(val: str) -> bool:
-    '''Détecte les booléens'''
+    """Détecte les booléens"""
     return isinstance(val, str) and val.lower() in liste_bool

csv_detective/detect_fields/other/email/__init__.py

@@ -4,5 +4,7 @@ PROPORTION = 1
 
 
 def _is(val):
-    '''Detects e-mails'''
-    return isinstance(val, str) and bool(re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$', val))
+    """Detects e-mails"""
+    return isinstance(val, str) and bool(
+        re.match(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$", val)
+    )

csv_detective/detect_fields/other/int/__init__.py

@@ -2,11 +2,11 @@ PROPORTION = 1
 
 
 def _is(val):
-    '''Detects integers'''
+    """Detects integers"""
     if (
         not isinstance(val, str)
-        or any([v in val for v in ['.', '_', '+']])
-        or (val.startswith('0') and len(val) > 1)
+        or any([v in val for v in [".", "_", "+"]])
+        or (val.startswith("0") and len(val) > 1)
     ):
         return False
     try:

csv_detective/detect_fields/other/mongo_object_id/__init__.py

@@ -4,5 +4,5 @@ PROPORTION = 0.8
 
 
 def _is(val):
-    '''Detects Mongo ObjectIds'''
-    return isinstance(val, str) and bool(re.match(r'^[0-9a-fA-F]{24}$', val))
+    """Detects Mongo ObjectIds"""
+    return isinstance(val, str) and bool(re.match(r"^[0-9a-fA-F]{24}$", val))

csv_detective/detect_fields/other/twitter/__init__.py

@@ -4,5 +4,5 @@ PROPORTION = 1
 
 
 def _is(val):
-    '''Detects twitter accounts'''
-    return isinstance(val, str) and bool(re.match(r'^@[A-Za-z0-9_]+$', val))
+    """Detects twitter accounts"""
+    return isinstance(val, str) and bool(re.match(r"^@[A-Za-z0-9_]+$", val))

csv_detective/detect_fields/other/uuid/__init__.py

@@ -4,8 +4,7 @@ PROPORTION = 0.8
 
 
 def _is(val):
-    '''Detects UUIDs'''
-    return isinstance(val, str) and bool(re.match(
-        r'^[{]?[0-9a-fA-F]{8}' + '-?([0-9a-fA-F]{4}-?)' + '{3}[0-9a-fA-F]{12}[}]?$',
-        val
-    ))
+    """Detects UUIDs"""
+    return isinstance(val, str) and bool(
+        re.match(r"^[{]?[0-9a-fA-F]{8}" + "-?([0-9a-fA-F]{4}-?)" + "{3}[0-9a-fA-F]{12}[}]?$", val)
+    )

csv_detective/detect_fields/temp/date/__init__.py

@@ -2,7 +2,8 @@ from datetime import datetime
 from typing import Optional
 
 from dateparser import parse as date_parser
-from dateutil.parser import parse as dateutil_parser, ParserError
+from dateutil.parser import ParserError
+from dateutil.parser import parse as dateutil_parser
 
 PROPORTION = 1
 # /!\ this is only for dates, not datetimes which are handled by other utils
@@ -22,7 +23,7 @@ threshold = 0.3
 
 
 def _is(val):
-    '''Renvoie True si val peut être une date, False sinon'''
+    """Renvoie True si val peut être une date, False sinon"""
     # early stops, to cut processing time
     if not isinstance(val, str) or len(val) > 20 or len(val) < 8:
         return False

csv_detective/detect_fields/temp/datetime_rfc822/__init__.py

@@ -4,15 +4,15 @@ PROPORTION = 1
 
 
 def _is(val):
-    '''Renvoie True si val peut être une date au format rfc822, False sinon
-    Exemple: Tue, 19 Dec 2023 15:30:45 +0000'''
+    """Renvoie True si val peut être une date au format rfc822, False sinon
+    Exemple: Tue, 19 Dec 2023 15:30:45 +0000"""
 
     return isinstance(val, str) and bool(
         re.match(
-            r'^[A-Za-z]{3}, (0[1-9]|[1-2][0-9]|3[01]) [A-Za-z]{3} \d{4} '
-            r'([0-2])([0-9]):([0-5])([0-9]):([0-5])([0-9]) '
-            r'(ut|gmt|est|edt|cst|cdt|mst|mdt|pst|pdt|[+\-](0[0-9]|1[0-3])00)$',
+            r"^[A-Za-z]{3}, (0[1-9]|[1-2][0-9]|3[01]) [A-Za-z]{3} \d{4} "
+            r"([0-2])([0-9]):([0-5])([0-9]):([0-5])([0-9]) "
+            r"(ut|gmt|est|edt|cst|cdt|mst|mdt|pst|pdt|[+\-](0[0-9]|1[0-3])00)$",
             val.lower(),
-            re.IGNORECASE
+            re.IGNORECASE,
         )
     )

csv_detective/detect_fields/temp/year/__init__.py

@@ -2,7 +2,7 @@ PROPORTION = 1
 
 
 def _is(val):
-    '''Returns True if val can be a year'''
+    """Returns True if val can be a year"""
     try:
         val = int(val)
     except ValueError:

csv_detective/detect_labels/FR/other/tel_fr/__init__.py

@@ -4,7 +4,6 @@ PROPORTION = 0.5
 
 
 def _is(header: str) -> float:
-
     words_combinations_list = [
         "telephone",
         "tel",

csv_detective/detect_labels/geo/lonlat_wgs/__init__.py

@@ -1,4 +1,5 @@
 from csv_detective.parsing.text import header_score
+
 from ..latlon_wgs import COMMON_COORDS_LABELS
 
 PROPORTION = 0.5

csv_detective/detect_labels/other/mongo_object_id/__init__.py

@@ -4,5 +4,5 @@ PROPORTION = 0.5
 
 
 def _is(header: str) -> float:
-    words_combinations_list = ['id', 'objectid']
+    words_combinations_list = ["id", "objectid"]
     return header_score(header, words_combinations_list)

csv_detective/detection/columns.py

@@ -1,6 +1,6 @@
 import logging
-from typing import TextIO
 from time import time
+from typing import TextIO
 
 from csv_detective.utils import display_logs_depending_process_time
 
@@ -47,19 +47,21 @@ def detect_heading_columns(file: TextIO, sep: str, verbose: bool = False) -> int
         if return_int == 0:
             if verbose:
                 display_logs_depending_process_time(
-                    f'No heading column detected in {round(time() - start, 3)}s',
+                    f"No heading column detected in {round(time() - start, 3)}s",
                     time() - start,
                 )
             return 0
     if verbose:
         display_logs_depending_process_time(
-            f'{return_int} heading columns detected in {round(time() - start, 3)}s',
+            f"{return_int} heading columns detected in {round(time() - start, 3)}s",
             time() - start,
         )
     return return_int
 
 
-def detect_trailing_columns(file: TextIO, sep: str, heading_columns: int, verbose: bool = False) -> int:
+def detect_trailing_columns(
+    file: TextIO, sep: str, heading_columns: int, verbose: bool = False
+) -> int:
     """Tests first 10 lines to see if there are empty trailing columns"""
     if verbose:
         start = time()
@@ -70,20 +72,18 @@ def detect_trailing_columns(file: TextIO, sep: str, heading_columns: int, verbos
         line = file.readline()
         return_int = min(
             return_int,
-            len(line.replace("\n", ""))
-            - len(line.replace("\n", "").strip(sep))
-            - heading_columns,
+            len(line.replace("\n", "")) - len(line.replace("\n", "").strip(sep)) - heading_columns,
         )
         if return_int == 0:
             if verbose:
                 display_logs_depending_process_time(
-                    f'No trailing column detected in {round(time() - start, 3)}s',
+                    f"No trailing column detected in {round(time() - start, 3)}s",
                     time() - start,
                 )
             return 0
     if verbose:
         display_logs_depending_process_time(
-            f'{return_int} trailing columns detected in {round(time() - start, 3)}s',
+            f"{return_int} trailing columns detected in {round(time() - start, 3)}s",
             time() - start,
         )
     return return_int

csv_detective/detection/encoding.py

@@ -1,6 +1,6 @@
 import logging
-from time import time
 from io import BytesIO
+from time import time
 
 from cchardet import detect
 
@@ -16,12 +16,14 @@ def detect_encoding(binary_file: BytesIO, verbose: bool = False) -> str:
         logging.info("Detecting encoding")
     encoding_dict = detect(binary_file.read())
     if not encoding_dict["encoding"]:
-        raise ValueError("Could not detect the file's encoding. Consider specifying it in the routine call.")
+        raise ValueError(
+            "Could not detect the file's encoding. Consider specifying it in the routine call."
+        )
     if verbose:
         message = f'Detected encoding: "{encoding_dict["encoding"]}"'
-        message += f' in {round(time() - start, 3)}s (confidence: {round(encoding_dict["confidence"]*100)}%)'
+        message += f" in {round(time() - start, 3)}s (confidence: {round(encoding_dict['confidence'] * 100)}%)"
         display_logs_depending_process_time(
             message,
             time() - start,
         )
-    return encoding_dict['encoding']
+    return encoding_dict["encoding"]

csv_detective/detection/engine.py

@@ -22,11 +22,11 @@ def detect_engine(file_path: str, verbose=False) -> Optional[str]:
     mapping = {
         "application/gzip": "gzip",
         "application/x-gzip": "gzip",
-        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'openpyxl',
-        'application/vnd.ms-excel': 'xlrd',
-        'application/vnd.oasis.opendocument.spreadsheet': 'odf',
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "openpyxl",
+        "application/vnd.ms-excel": "xlrd",
+        "application/vnd.oasis.opendocument.spreadsheet": "odf",
         # all these files could be recognized as zip, may need to check all cases then
-        'application/zip': 'openpyxl',
+        "application/zip": "openpyxl",
     }
     # if none of the above, we move forwards with the csv process
     if is_url(file_path):
@@ -37,7 +37,8 @@ def detect_engine(file_path: str, verbose=False) -> Optional[str]:
     if verbose:
         message = (
             f"File is not csv, detected {engine_to_file.get(engine, 'csv')}"
-            if engine else "Processing the file as a csv"
+            if engine
+            else "Processing the file as a csv"
         )
         display_logs_depending_process_time(
             message,

csv_detective/detection/formats.py

@@ -1,16 +1,17 @@
-from collections import defaultdict
 import logging
+from collections import defaultdict
 from typing import Union
 
 import numpy as np
 import pandas as pd
+
 from csv_detective.detection.variables import (
     detect_categorical_variable,
     # detect_continuous_variable,
 )
 from csv_detective.load_tests import return_all_tests
 from csv_detective.output.utils import prepare_output_dict
-from csv_detective.parsing.columns import test_col, test_label, MAX_ROWS_ANALYSIS
+from csv_detective.parsing.columns import MAX_ROWS_ANALYSIS, test_col, test_label
 from csv_detective.validate import validate
 
 
@@ -42,10 +43,12 @@ def detect_formats(
         #     detect_continuous_variable(table.iloc[:, ~categorical_mask.values], verbose=verbose)
         # )
 
-    analysis.update({
-        "categorical": res_categorical,
-        # "continuous": res_continuous,
-    })
+    analysis.update(
+        {
+            "categorical": res_categorical,
+            # "continuous": res_continuous,
+        }
+    )
 
     # list testing to be performed
     all_tests_fields = return_all_tests(
@@ -60,7 +63,9 @@ def detect_formats(
         return analysis
 
     # Perform testing on fields
-    scores_table_fields = test_col(table, all_tests_fields, limited_output, skipna=skipna, verbose=verbose)
+    scores_table_fields = test_col(
+        table, all_tests_fields, limited_output, skipna=skipna, verbose=verbose
+    )
     analysis["columns_fields"] = prepare_output_dict(scores_table_fields, limited_output)
 
     # Perform testing on labels
@@ -71,16 +76,14 @@ def detect_formats(
     # This is because the fields are more important than the labels and yields a max
     # of 1.5 for the final score.
     scores_table = scores_table_fields * (
-        1
-        + scores_table_labels.reindex(
-            index=scores_table_fields.index, fill_value=0
-        ).values / 2
+        1 + scores_table_labels.reindex(index=scores_table_fields.index, fill_value=0).values / 2
     )
 
     # To reduce false positives: ensure these formats are detected only if the label yields
     # a detection (skipping the ones that have been excluded by the users).
     formats_with_mandatory_label = [
-        f for f in [
+        f
+        for f in [
             "code_departement",
             "code_commune_insee",
             "code_postal",
@@ -90,7 +93,8 @@ def detect_formats(
             "longitude_wgs_fr_metropole",
             "latitude_l93",
             "longitude_l93",
-        ] if f in scores_table.index
+        ]
+        if f in scores_table.index
     ]
     scores_table.loc[formats_with_mandatory_label, :] = np.where(
         scores_table_labels.loc[formats_with_mandatory_label, :],
@@ -123,9 +127,7 @@ def detect_formats(
             analysis[detection_method] = {
                 col_name: [
                     {
-                        "python_type": metier_to_python_type.get(
-                            detection["format"], "string"
-                        ),
+                        "python_type": metier_to_python_type.get(detection["format"], "string"),
                         **detection,
                     }
                     for detection in detections
@@ -136,9 +138,7 @@ def detect_formats(
         for detection_method in ["columns_fields", "columns_labels", "columns"]:
             analysis[detection_method] = {
                 col_name: {
-                    "python_type": metier_to_python_type.get(
-                        detection["format"], "string"
-                    ),
+                    "python_type": metier_to_python_type.get(detection["format"], "string"),
                     **detection,
                 }
                 for col_name, detection in analysis[detection_method].items()

csv_detective/detection/headers.py

@@ -15,18 +15,16 @@ def detect_headers(file: TextIO, sep: str, verbose: bool = False) -> tuple[int,
         header = file.readline()
         position = file.tell()
         chaine = [c for c in header.replace("\n", "").split(sep) if c]
-        if chaine[-1] not in ["", "\n"] and all(
-            [mot not in ["", "\n"] for mot in chaine[1:-1]]
-        ):
+        if chaine[-1] not in ["", "\n"] and all([mot not in ["", "\n"] for mot in chaine[1:-1]]):
             next_row = file.readline()
             file.seek(position)
             if header != next_row:
                 if verbose:
                     display_logs_depending_process_time(
-                        f'Detected headers in {round(time() - start, 3)}s',
+                        f"Detected headers in {round(time() - start, 3)}s",
                         time() - start,
                     )
                 return i, chaine
     if verbose:
-        logging.info('No header detected')
+        logging.info("No header detected")
     return 0, None

csv_detective/detection/rows.py

@@ -5,7 +5,7 @@ def remove_empty_first_rows(table: pd.DataFrame) -> tuple[pd.DataFrame, int]:
     """Analog process to detect_headers for csv files, determines how many rows to skip
     to end up with the header at the right place"""
     idx = 0
-    if all([str(c).startswith('Unnamed:') for c in table.columns]):
+    if all([str(c).startswith("Unnamed:") for c in table.columns]):
         # there is on offset between the index in the file (idx here)
         # and the index in the dataframe, because of the header
         idx = 1

csv_detective/detection/variables.py

@@ -7,7 +7,9 @@ import pandas as pd
 from csv_detective.utils import display_logs_depending_process_time
 
 
-def detect_continuous_variable(table: pd.DataFrame, continuous_th: float = 0.9, verbose: bool = False):
+def detect_continuous_variable(
+    table: pd.DataFrame, continuous_th: float = 0.9, verbose: bool = False
+):
     """
     Detects whether a column contains continuous variables. We consider a continuous column
     one that contains a considerable amount of float values.
@@ -41,9 +43,7 @@ def detect_continuous_variable(table: pd.DataFrame, continuous_th: float = 0.9,
     if verbose:
         start = time()
         logging.info("Detecting continuous columns")
-    res = table.apply(
-        lambda serie: check_threshold(serie.apply(parses_to_integer), continuous_th)
-    )
+    res = table.apply(lambda serie: check_threshold(serie.apply(parses_to_integer), continuous_th))
     if verbose:
         display_logs_depending_process_time(
             f"Detected {sum(res)} continuous columns in {round(time() - start, 3)}s",

csv_detective/explore_csv.py

@@ -55,7 +55,10 @@ def routine(
         dict: a dict with information about the csv and possible types for each column
     """
 
-    if not (isinstance(save_results, bool) or (isinstance(save_results, str) and save_results.endswith(".json"))):
+    if not (
+        isinstance(save_results, bool)
+        or (isinstance(save_results, str) and save_results.endswith(".json"))
+    ):
         raise ValueError("`save_results` must be a bool or a valid path to a json file.")
 
     if verbose:
@@ -100,8 +103,7 @@ def routine(
     finally:
         if verbose:
             display_logs_depending_process_time(
-                f"Routine completed in {round(time() - start_routine, 3)}s",
-                time() - start_routine
+                f"Routine completed in {round(time() - start_routine, 3)}s", time() - start_routine
             )
 
 
@@ -119,7 +121,6 @@ def validate_then_detect(
     cast_json: bool = True,
     verbose: bool = False,
 ):
-
     if verbose:
         start_routine = time()
         if is_url(file_path):
@@ -170,8 +171,7 @@ def validate_then_detect(
     finally:
         if verbose:
             display_logs_depending_process_time(
-                f"Process completed in {round(time() - start_routine, 3)}s",
-                time() - start_routine
+                f"Process completed in {round(time() - start_routine, 3)}s", time() - start_routine
             )
 
 
@@ -226,8 +226,7 @@ def routine_minio(
         if location_dict is not None:
             if any(
                 [
-                    (location_key not in location_dict)
-                    or (location_dict[location_key] is None)
+                    (location_key not in location_dict) or (location_dict[location_key] is None)
                     for location_key in ["netloc", "bucket", "key"]
                 ]
             ):

csv_detective/load_tests.py

@@ -12,10 +12,7 @@ def get_all_packages(detect_type) -> list:
         for filename in filenames:
             file = os.path.join(dirpath, filename).replace(root_dir, "")
             if file.endswith("__init__.py"):
-                module = (
-                    file.replace("__init__.py", "")
-                    .replace("/", ".").replace("\\", ".")[:-1]
-                )
+                module = file.replace("__init__.py", "").replace("/", ".").replace("\\", ".")[:-1]
                 if module:
                     modules.append(detect_type + module)
     return modules
@@ -43,20 +40,15 @@ def return_all_tests(
     if "ALL" in user_input_tests or all(x[0] == "-" for x in user_input_tests):
         tests_to_do = [detect_type]
     else:
-        tests_to_do = [
-            f"{detect_type}.{x}" for x in user_input_tests if x[0] != "-"
-        ]
-    tests_skipped = [
-        f"{detect_type}.{x[1:]}" for x in user_input_tests if x[0] == "-"
-    ]
+        tests_to_do = [f"{detect_type}.{x}" for x in user_input_tests if x[0] != "-"]
+    tests_skipped = [f"{detect_type}.{x[1:]}" for x in user_input_tests if x[0] == "-"]
     all_tests = [
         # this is why we need to import detect_fields/labels
-        eval(x) for x in all_packages
+        eval(x)
+        for x in all_packages
         if any([y == x[: len(y)] for y in tests_to_do])
         and all([y != x[: len(y)] for y in tests_skipped])
     ]
     # to remove groups of tests
-    all_tests = [
-        test for test in all_tests if "_is" in dir(test)
-    ]
+    all_tests = [test for test in all_tests if "_is" in dir(test)]
     return all_tests