csv-detective 0.7.5.dev1277__py3-none-any.whl → 0.7.5.dev1298__py3-none-any.whl

csv_detective/load_tests.py

@@ -0,0 +1,62 @@
+import os
+from typing import Union
+
+# flake8: noqa
+from csv_detective import detect_fields, detect_labels
+
+
+def get_all_packages(detect_type) -> list:
+    root_dir = os.path.dirname(os.path.abspath(__file__)) + "/" + detect_type
+    modules = []
+    for dirpath, _, filenames in os.walk(root_dir):
+        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]
+                )
+                if module:
+                    modules.append(detect_type + module)
+    return modules
+
+
+def return_all_tests(
+    user_input_tests: Union[str, list],
+    detect_type: str,
+) -> list:
+    """
+    returns all tests that have a method _is and are listed in the user_input_tests
+    the function can select a sub_package from csv_detective
+    user_input_tests may look like this:
+        - "ALL": all possible tests are made
+        - "FR.other.siren" (or any other path-like string to one of the tests, or a group of tests, like "FR.geo"):
+        this specifc (group of) test(s) only
+        - ["FR.temp.mois_de_annee", "geo", ...]: only the specified tests will be made ; you may also skip
+        specific (groups of) tests by add "-" at the start (e.g "-temp.date")
+    """
+    assert detect_type in ["detect_fields", "detect_labels"]
+    all_packages = get_all_packages(detect_type=detect_type)
+
+    if isinstance(user_input_tests, str):
+        user_input_tests = [user_input_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] == "-"
+    ]
+    all_tests = [
+        # this is why we need to import detect_fields/labels
+        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)
+    ]
+    return all_tests

csv_detective/output/__init__.py

@@ -0,0 +1,64 @@
+import json
+import os
+from typing import Union
+
+import pandas as pd
+
+from csv_detective.utils import is_url
+from .dataframe import cast_df
+from .profile import create_profile
+from .schema import generate_table_schema
+
+
+def generate_output(
+    table: pd.DataFrame,
+    analysis: dict,
+    file_path: str,
+    num_rows: int = 500,
+    limited_output: bool = True,
+    save_results: Union[bool, str] = True,
+    output_profile: bool = False,
+    output_schema: bool = False,
+    output_df: bool = False,
+    cast_json: bool = True,
+    verbose: bool = False,
+    sheet_name: Union[str, int] = None,
+) -> Union[dict, tuple[dict, pd.DataFrame]]:
+
+    if output_profile:
+        analysis["profile"] = create_profile(
+            table=table,
+            dict_cols_fields=analysis["columns"],
+            num_rows=num_rows,
+            limited_output=limited_output,
+            verbose=verbose,
+        )
+
+    if save_results:
+        if isinstance(save_results, str):
+            output_path = save_results
+        else:
+            output_path = os.path.splitext(file_path)[0]
+            if is_url(output_path):
+                output_path = output_path.split('/')[-1]
+            if analysis.get("sheet_name"):
+                output_path += "_sheet-" + str(sheet_name)
+            output_path += ".json"
+        with open(output_path, "w", encoding="utf8") as fp:
+            json.dump(analysis, fp, indent=4, separators=(",", ": "), ensure_ascii=False)
+
+    if output_schema:
+        analysis["schema"] = generate_table_schema(
+            analysis,
+            save_file=False,
+            verbose=verbose
+        )
+
+    if output_df:
+        return analysis, cast_df(
+            df=table,
+            columns=analysis["columns"],
+            cast_json=cast_json,
+            verbose=verbose,
+        )
+    return analysis

csv_detective/output/example.py

@@ -17,12 +17,12 @@ def create_example_csv_file(
     fields: Optional[dict] = None,
     schema_path: Optional[str] = None,
     file_length: int = 10,
-    output_name: str = 'example_file.csv',
-    output_sep: str = ';',
-    encoding: str = 'utf-8',
+    output_name: Optional[str] = "example_file.csv",
+    output_sep: str = ";",
+    encoding: str = "utf-8",
     ignore_required: bool = False,
 ) -> pd.DataFrame:
-    '''
+    """
     Create an example file based on a list of dicts like follows:
     fields = [
         {
@@ -33,7 +33,7 @@ def create_example_csv_file(
         ...
     ]
     Or from a TableSchema
-    '''
+    """
     # need to make a CLI command
 
     if not (fields or schema_path):
@@ -53,65 +53,65 @@ def create_example_csv_file(
         enum: Optional[str] = None,
     ) -> str:
         if potential_skip(required):
-            return ''
+            return ""
         if pattern is not None:
             return rstr.xeger(pattern)
         elif enum is not None:
             return random.choice(enum)
         else:
             letters = string.ascii_lowercase
-            return ''.join(random.choice(letters) for i in range(length))
+            return "".join(random.choice(letters) for i in range(length))
 
     def _id(
         required: bool = True,
     ) -> str:
         if potential_skip(required):
-            return ''
+            return ""
         return str(uuid.uuid4())
 
     def _date(
         date_range: Union[None, list[str]] = None,
-        format: str = '%Y-%m-%d',
+        format: str = "%Y-%m-%d",
         required: bool = True,
     ) -> str:
         # the bounds specified in date_range are expected in the same format as the desired output format
-        assert all([k in format for k in ['%d', '%m', '%Y']])
+        assert all([k in format for k in ["%d", "%m", "%Y"]])
         if potential_skip(required):
-            return ''
+            return ""
         if date_range is None:
             return fake.date(format)
         else:
             if len(date_range) != 2:
-                raise ValueError('"date_range" must have exactly two elements.')
+                raise ValueError("'date_range' must have exactly two elements.")
             return fake.date_between_dates(
                 datetime.strptime(date_range[0], format),
                 datetime.strptime(date_range[1], format),
             ).strftime(format)
 
     def _time(
-        format: str = '%H:%M:%S',
+        format: str = "%H:%M:%S",
         required: bool = True,
     ) -> str:
-        assert all([k in format for k in ['%H', '%M', '%S']])
+        assert all([k in format for k in ["%H", "%M", "%S"]])
         if potential_skip(required):
-            return ''
+            return ""
         # maybe add a time_range argument?
         return fake.time(format)
 
     def _datetime(
         datetime_range: Optional[list[str]] = None,
-        format: str = '%Y-%m-%d %H-%M-%S',
+        format: str = "%Y-%m-%d %H-%M-%S",
         required: bool = True,
     ) -> str:
         # the bounds specified in datetime_range are expected in the same format as the desired output format
-        assert all([k in format for k in ['%d', '%m', '%Y', '%H', '%M', '%S']])
+        assert all([k in format for k in ["%d", "%m", "%Y", "%H", "%M", "%S"]])
         if potential_skip(required):
-            return ''
+            return ""
         if datetime_range is None:
             return fake.date_time().strftime(format)
         else:
             if len(datetime_range) != 2:
-                raise ValueError('"date_range" must have exactly two elements.')
+                raise ValueError("'date_range' must have exactly two elements.")
             return fake.date_time_between(
                 datetime.strptime(datetime_range[0], format),
                 datetime.strptime(datetime_range[1], format),
@@ -119,8 +119,8 @@ def create_example_csv_file(
 
     def _url(required: bool = True) -> str:
         if potential_skip(required):
-            return ''
-        return f'http://{rstr.domainsafe()}.{rstr.letters(3)}/{rstr.urlsafe()}'
+            return ""
+        return f"http://{rstr.domainsafe()}.{rstr.letters(3)}/{rstr.urlsafe()}"
 
     def _number(
         num_type: Type[Union[int, float]] = int,
@@ -130,7 +130,7 @@ def create_example_csv_file(
     ) -> Union[int, float]:
         assert num_range is None or len(num_range) == 2
         if potential_skip(required):
-            return ''
+            return ""
         if enum:
             return random.choice(enum)
         if num_range is None:
@@ -142,100 +142,100 @@ def create_example_csv_file(
 
     def _bool(required: bool = True) -> bool:
         if potential_skip(required):
-            return ''
+            return ""
         return random.randint(0, 1) == 0
 
     def _array(enum: list[Any], required: bool = True) -> str:
         if potential_skip(required):
-            return ''
+            return ""
         return f"[{','.join(random.sample(enum, random.randint(1, len(enum))))}]"
 
     def build_args_from_constraints(constraints: dict) -> dict:
         args = {}
-        args['required'] = constraints.get('required', False)
-        for _ in ['pattern', 'enum', 'format']:
+        args["required"] = constraints.get("required", False)
+        for _ in ["pattern", "enum", "format"]:
             if _ in constraints:
                 args[_] = constraints[_]
-        if 'minimum' in constraints and 'maximum' in constraints:
-            args['num_range'] = [constraints['minimum'], constraints['maximum']]
+        if "minimum" in constraints and "maximum" in constraints:
+            args["num_range"] = [constraints["minimum"], constraints["maximum"]]
         # maybe there are better values than these?
-        elif 'minimum' in constraints:
-            args['num_range'] = [constraints['minimum'], 10 + constraints['minimum']]
-        elif 'maximum' in constraints:
-            args['num_range'] = [constraints['maximum'] - 10, constraints['maximum']]
-        if 'minLength' in constraints:
-            args['length'] = constraints['minLength']
-        if 'maxLength' in constraints:
-            args['length'] = constraints['maxLength']
+        elif "minimum" in constraints:
+            args["num_range"] = [constraints["minimum"], 10 + constraints["minimum"]]
+        elif "maximum" in constraints:
+            args["num_range"] = [constraints["maximum"] - 10, constraints["maximum"]]
+        if "minLength" in constraints:
+            args["length"] = constraints["minLength"]
+        if "maxLength" in constraints:
+            args["length"] = constraints["maxLength"]
         return args
 
     schema_types_to_python = {
-        'number': 'float',
-        'integer': 'int',
-        'string': 'str',
-        'year': 'year',
-        'boolean': 'bool',
-        'date': 'date',
-        'yearmonth': 'date',
-        'time': 'time',
-        'datetime': 'datetime',
-        'array': 'array'
+        "number": "float",
+        "integer": "int",
+        "string": "str",
+        "year": "year",
+        "boolean": "bool",
+        "date": "date",
+        "yearmonth": "date",
+        "time": "time",
+        "datetime": "datetime",
+        "array": "array"
     }
 
     if schema_path:
-        if schema_path.startswith('http'):
+        if schema_path.startswith("http"):
             schema = requests.get(schema_path).json()
         else:
             with open(schema_path, encoding=encoding) as jsonfile:
                 schema = json.load(jsonfile)
-        if not ('fields' in schema.keys()):
-            raise ValueError('The schema must have a "fields" key.')
+        if not ("fields" in schema.keys()):
+            raise ValueError("The schema must have a 'fields' key.")
         else:
             fields = [
                 {
-                    'name': f['name'],
-                    'type': schema_types_to_python.get(f['type'], 'str'),
+                    "name": f["name"],
+                    "type": schema_types_to_python.get(f["type"], "str"),
                     # when frformat is supported in TableSchema, we can build args for French standards
                     # linked to https://github.com/datagouv/fr-format/issues/26
-                    'args': (
-                        build_args_from_constraints(f['constraints']) if 'constraints' in f.keys()
-                        else build_args_from_constraints(f['arrayItem']['constraints'])
-                        if 'arrayItem' in f.keys() and 'constraints' in f['arrayItem'].keys()
+                    "args": (
+                        build_args_from_constraints(f["constraints"]) if "constraints" in f.keys()
+                        else build_args_from_constraints(f["arrayItem"]["constraints"])
+                        if "arrayItem" in f.keys() and "constraints" in f["arrayItem"].keys()
                         else {}
                     )
-                } for f in schema['fields']
+                } for f in schema["fields"]
             ]
 
     for k in range(len(fields)):
-        if 'args' not in fields[k]:
-            fields[k]['args'] = {}
-        if fields[k]['type'] == 'float':
-            fields[k]['args']['num_type'] = float
-        elif fields[k]['type'] == 'int':
-            fields[k]['args']['num_type'] = int
-        elif fields[k]['type'] == 'year':
-            fields[k]['args']['num_type'] = int
-            fields[k]['args']['num_range'] = [1990, 2050]
+        if "args" not in fields[k]:
+            fields[k]["args"] = {}
+        if fields[k]["type"] == "float":
+            fields[k]["args"]["num_type"] = float
+        elif fields[k]["type"] == "int":
+            fields[k]["args"]["num_type"] = int
+        elif fields[k]["type"] == "year":
+            fields[k]["args"]["num_type"] = int
+            fields[k]["args"]["num_range"] = [1990, 2050]
 
     types_to_func = {
-        'int': _number,
-        'float': _number,
-        'date': _date,
-        'time': _time,
-        'str': _string,
-        'url': _url,
-        'id': _id,
-        'year': _number,
-        'bool': _bool,
-        'datetime': _datetime,
-        'array': _array,
+        "int": _number,
+        "float": _number,
+        "date": _date,
+        "time": _time,
+        "str": _string,
+        "url": _url,
+        "id": _id,
+        "year": _number,
+        "bool": _bool,
+        "datetime": _datetime,
+        "array": _array,
     }
 
     # would it be better to create by column or by row (as for now)?
     output = pd.DataFrame(
         [
             [
-                types_to_func.get(f['type'], 'str')(**f['args'])
+                types_to_func.get(f["type"], "str")(**f["args"])
                 for f in fields
             ] for _ in range(file_length)
         ],

csv_detective/utils.py

@@ -2,6 +2,8 @@ import logging
 import math
 from typing import Optional
 
+logging.basicConfig(level=logging.INFO)
+
 
 def display_logs_depending_process_time(prompt: str, duration: float):
     '''

csv_detective/validate.py

@@ -0,0 +1,70 @@
+import logging
+from typing import Union
+
+import pandas as pd
+
+from csv_detective.load_tests import return_all_tests
+from .parsing.load import load_file
+
+logging.basicConfig(level=logging.INFO)
+
+tests = {
+    t.__name__.split(".")[-1]: t._is
+    for t in return_all_tests("ALL", "detect_fields")
+}
+
+
+def validate(
+    file_path: str,
+    previous_analysis: dict,
+    num_rows: int = 500,
+    encoding: str = None,
+    sep: str = None,
+    verbose: bool = False,
+    skipna: bool = True,
+    sheet_name: Union[str, int] = None,
+) -> tuple[bool, pd.DataFrame, dict]:
+    """
+    Verify is the given file has the same fields and types as in the previous analysis.
+    """
+    table, analysis = load_file(
+        file_path=file_path,
+        num_rows=num_rows,
+        encoding=encoding,
+        sep=sep,
+        verbose=verbose,
+        sheet_name=sheet_name,
+    )
+    if verbose:
+        logging.info("Comparing table with the previous analysis")
+        logging.info("- Checking if all columns match")
+    if (
+        any(col_name not in list(table.columns) for col_name in previous_analysis["columns"])
+        or any(col_name not in list(previous_analysis["columns"].keys()) for col_name in table.columns)
+    ):
+        logging.warning("> Columns do not match, proceeding with full analysis")
+        return False, table, analysis
+    for col_name, args in previous_analysis["columns"].items():
+        if verbose:
+            logging.info(f"- Testing {col_name} for {args['format']}")
+        if args["format"] == "string":
+            # no test for columns that have not been recognized as a specific format
+            continue
+        test_func = tests[args["format"]]
+        col_data = table[col_name]
+        if skipna:
+            col_data = col_data.loc[~col_data.isna()]
+        if not col_data.apply(test_func).all():
+            logging.warning("> Test failed, proceeding with full analysis")
+            return False, table, analysis
+    if verbose:
+        logging.info("> All checks successful")
+    return True, table, analysis | {
+        k: previous_analysis[k] for k in [
+            "categorical",
+            "columns",
+            "columns_fields",
+            "columns_labels",
+            "formats",
+        ]
+    }

{csv_detective-0.7.5.dev1277.data → csv_detective-0.7.5.dev1298.data}/data/share/csv_detective/CHANGELOG.md

@@ -13,7 +13,9 @@
 - Handle csv.gz files [#110](https://github.com/datagouv/csv-detective/pull/110)
 - Refactor file tests [#110](https://github.com/datagouv/csv-detective/pull/110)
 - Restructure repo (breaking changes) [#111](https://github.com/datagouv/csv-detective/pull/111)
+- Add validation function and associated flow [#112](https://github.com/datagouv/csv-detective/pull/112)
 - Better float detection [#113](https://github.com/datagouv/csv-detective/pull/113)
+- Refactor fields tests [#114](https://github.com/datagouv/csv-detective/pull/114)
 
 ## 0.7.4 (2024-11-15)
 

{csv_detective-0.7.5.dev1277.dist-info → csv_detective-0.7.5.dev1298.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csv_detective
-Version: 0.7.5.dev1277
+Version: 0.7.5.dev1298
 Summary: Detect CSV column content
 Home-page: https://github.com/etalab/csv_detective
 Author: Etalab

{csv_detective-0.7.5.dev1277.dist-info → csv_detective-0.7.5.dev1298.dist-info}/RECORD

@@ -1,9 +1,11 @@
-csv_detective/__init__.py,sha256=GCHgu0BhH5ACV7cf-1gDr9nRyvSoeQ1vRw9SjEHeMT4,143
+csv_detective/__init__.py,sha256=vpK7WMkIQbcJzu6HKOwcn7PpHsNCCaXZ1YLMS5Wq9tM,165
 csv_detective/cli.py,sha256=itooHtpyfC6DUsL_DchPKe1xo7m0MYJIp1L4R8eqoTk,1401
-csv_detective/explore_csv.py,sha256=FmgJ2h1SxV8b_wOWia4xsswyVJTlCCW66e0nhltz-0s,14511
+csv_detective/explore_csv.py,sha256=ocWlUEtuwZ-6bjDc6gfhC2-6DljMVhvXhHrfICCXGfQ,8986
+csv_detective/load_tests.py,sha256=GILvfkd4OVI-72mA4nzbPlZqgcXZ4wznOhGfZ1ucWkM,2385
 csv_detective/s3_utils.py,sha256=1cIVdQUYY2ovErbMwp72Gqtqx2bkB8nfVhn-QaOFTT0,1451
-csv_detective/utils.py,sha256=KAYfSJXnPuAXnSc38Jm57oQ_JP_0kUkmI1OV6gN5_ys,1116
-csv_detective/detect_fields/__init__.py,sha256=NVfE3BQVExgXb-BPbhDvlkM5-0naEVLpZ4aM_OGHYfE,931
+csv_detective/utils.py,sha256=Bx_1k4Sdpd5PCjuAy4AeayCmmw7TMR_zgtKIHNLi5g0,1157
+csv_detective/validate.py,sha256=o4Qulf8E-x1zsWT9OD4Fpw83Gku1WA3JlX83j7bu0DA,2314
+csv_detective/detect_fields/__init__.py,sha256=qkwT_o_S7qvLEsRssICpoGmCc3h5y2MVy1XI56LFcV0,959
 csv_detective/detect_fields/FR/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 csv_detective/detect_fields/FR/geo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 csv_detective/detect_fields/FR/geo/adresse/__init__.py,sha256=NqV8ULf9gY9iFnA1deKR-1Yobr96WwCsn5JfbP_MjiY,1675
@@ -48,15 +50,17 @@ csv_detective/detect_fields/geo/iso_country_code_numeric/__init__.py,sha256=wJAy
 csv_detective/detect_fields/geo/iso_country_code_numeric/iso_country_code_numeric.txt,sha256=2GtEhuporsHYV-pU4q9kfXU5iOtfW5C0GYBTTKQtnnA,1004
 csv_detective/detect_fields/geo/json_geojson/__init__.py,sha256=FPHOfTrfXJs62-NgeOcNGOvwPd7I1fEVp8lTdMNfj3w,433
 csv_detective/detect_fields/geo/latitude_wgs/__init__.py,sha256=ArS6PuYEd0atZwSqNDZhXZz1TwzdiwdV8ovRYTOacpg,327
-csv_detective/detect_fields/geo/latlon_wgs/__init__.py,sha256=3nlBqFYD4kVSVxw4b9DTPcxW59oL0T3Kj0OxPlyP9og,268
+csv_detective/detect_fields/geo/latlon_wgs/__init__.py,sha256=7_mnO9uC_kI7e2WR8xIer7Kqw8zi-v-JKaAD4zcoGbE,342
 csv_detective/detect_fields/geo/longitude_wgs/__init__.py,sha256=G7afWOKiGh_Tv7gwDNGt1a4B_A8hkCBkIxn3THDCUFk,330
 csv_detective/detect_fields/other/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 csv_detective/detect_fields/other/booleen/__init__.py,sha256=wn_yyTAmGxqo0l0b7JRpGb0da_E27iGxES9zWCrnsqc,497
 csv_detective/detect_fields/other/email/__init__.py,sha256=O9tgJmq0O8Q-8iin63NqEEDhlsUJjxFZNaNFM4GZaws,178
-csv_detective/detect_fields/other/float/__init__.py,sha256=7bXuPAmBuIhKJEhq7d20B60WVol1AUpqRkWhreQpWfU,578
+csv_detective/detect_fields/other/float/__init__.py,sha256=AT4Kpgwoz5PuAoLx00u0SL8DjjXZxsE8zSRbN18uAv4,578
 csv_detective/detect_fields/other/int/__init__.py,sha256=QN3kQJLYqLRBiubUK7g4Xq03PlA5wqVwx2pPPIO9FdI,320
 csv_detective/detect_fields/other/json/__init__.py,sha256=DhzyvT12kOqgum89silIu3uoSYXmC_s_AaxLtXAD4eU,540
+csv_detective/detect_fields/other/money/__init__.py,sha256=g_ZwBZXl9LhldwFYQotC5WqLiE8qQCZHtoI9eJvl_9M,232
 csv_detective/detect_fields/other/mongo_object_id/__init__.py,sha256=7fcrHsOZAqXp2_N0IjPskYJ_qi4xRlo9iyNNDQVLzsU,156
+csv_detective/detect_fields/other/percent/__init__.py,sha256=vgpekNOPBRuunoVBXMi81rwHv4uSOhe78pbVtQ5SBO8,177
 csv_detective/detect_fields/other/twitter/__init__.py,sha256=qbwLKsTBRFQ4PyTNVeEZ5Hkf5Wwi3ZKclLER_V0YO3g,154
 csv_detective/detect_fields/other/url/__init__.py,sha256=9WaTqCglEsw_lJG_xZsBMdxJXg2yuQ92_fkX6CXWNV0,286
 csv_detective/detect_fields/other/uuid/__init__.py,sha256=3-z0fDax29SJc57zPjNGR6DPICJu6gfuNGC5L3jh4d0,223
@@ -126,12 +130,14 @@ csv_detective/detect_labels/temp/year/__init__.py,sha256=3U9j8Hux432KdGtIyArq_-v
 csv_detective/detection/columns.py,sha256=vfE-DKESA6J9Rfsl-a8tjgZfE21VmzArO5TrbzL0KmE,2905
 csv_detective/detection/encoding.py,sha256=tpjJEMNM_2TcLXDzn1lNQPnSRnsWYjs83tQ8jNwTj4E,973
 csv_detective/detection/engine.py,sha256=HiIrU-l9EO5Fbc2Vh8W_Uy5-dpKcQQzlxCqMuWc09LY,1530
+csv_detective/detection/formats.py,sha256=VwFazRAFJN6eaYUK7IauVU88vuUBHccESY4UD8EgGUo,5386
 csv_detective/detection/headers.py,sha256=wrVII2RQpsVmHhrO1DHf3dmiu8kbtOjBlskf41cnQmc,1172
 csv_detective/detection/rows.py,sha256=3qvsbsBcMxiqqfSYYkOgsRpX777rk22tnRHDwUA97kU,742
 csv_detective/detection/separator.py,sha256=XjeDBqhiBxVfkCPJKem9BAgJqs_hOgQltc_pxrH_-Tg,1547
 csv_detective/detection/variables.py,sha256=3qEMtjZ_zyIFXvTnFgK7ZMDx8C12uQXKfFjEj2moyJc,3558
+csv_detective/output/__init__.py,sha256=XDS4Dgvv6oloIao9JquHa0m1nnlQ_q2gHuEPGlaETic,1890
 csv_detective/output/dataframe.py,sha256=89iQRE59cHQyQQEsujQVIKP2YAUYpPklWkdDOqZE-wE,2183
-csv_detective/output/example.py,sha256=i8PkdXxidF7qR_9aK8vh12JpZdJQryhBgyrMS8iy5rk,8642
+csv_detective/output/example.py,sha256=26rY7XNXK47e9xJMl-Js8jJwFIuv7V7B7e256VecKuk,8652
 csv_detective/output/profile.py,sha256=B8YU541T_YPDezJGh4dkHckOShiwHSrZd9GS8jbmz7A,2919
 csv_detective/output/schema.py,sha256=ZDBWDOD8IYp7rcB0_n8l9JXGIhOQ6bTZHFWfTmnNNEQ,13480
 csv_detective/output/utils.py,sha256=HbmvCCCmFo7NJxhD_UsJIveuw-rrfhrvYckv1CJn_10,2301
@@ -141,18 +147,19 @@ csv_detective/parsing/csv.py,sha256=11mibDnJhIjykXLGZvA5ZEU5U7KgxIrbyO6BNv6jlro,
 csv_detective/parsing/excel.py,sha256=AslE2S1e67o8yTIAIhp-lAnJ6-XqeBBRz1-VMFqhZBM,7055
 csv_detective/parsing/load.py,sha256=SpP0pfxswOAPPpwbZfoP1blh0EKV5VMs0TpTgQJKzjs,3621
 csv_detective/parsing/text.py,sha256=rsfk66BCmdpsCOd0kDJ8tmqMsEWd-OeBkEisWc4Ej9k,1246
-csv_detective-0.7.5.dev1277.data/data/share/csv_detective/CHANGELOG.md,sha256=tgIIm6s4qoP4RGJK1cmqf-Cm5aHmXmBrwi37NVIYedg,7796
-csv_detective-0.7.5.dev1277.data/data/share/csv_detective/LICENSE.AGPL.txt,sha256=2N5ReRelkdqkR9a-KP-y-shmcD5P62XoYiG-miLTAzo,34519
-csv_detective-0.7.5.dev1277.data/data/share/csv_detective/README.md,sha256=Qr8xRXc-dxQ-tdXCpCTCKp1Uliqq84r0UOlPRNuGCpI,9506
-csv_detective-0.7.5.dev1277.dist-info/licenses/LICENSE.AGPL.txt,sha256=2N5ReRelkdqkR9a-KP-y-shmcD5P62XoYiG-miLTAzo,34519
+csv_detective-0.7.5.dev1298.data/data/share/csv_detective/CHANGELOG.md,sha256=Y8aL18x5EGGvA9AqukEi4tn78se_Lzisa2J32kOSer8,7984
+csv_detective-0.7.5.dev1298.data/data/share/csv_detective/LICENSE.AGPL.txt,sha256=2N5ReRelkdqkR9a-KP-y-shmcD5P62XoYiG-miLTAzo,34519
+csv_detective-0.7.5.dev1298.data/data/share/csv_detective/README.md,sha256=Qr8xRXc-dxQ-tdXCpCTCKp1Uliqq84r0UOlPRNuGCpI,9506
+csv_detective-0.7.5.dev1298.dist-info/licenses/LICENSE.AGPL.txt,sha256=2N5ReRelkdqkR9a-KP-y-shmcD5P62XoYiG-miLTAzo,34519
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_example.py,sha256=0NfChooJQlFxTo2nY5FOQIcsK4zzWA_SBmt2LwVQovY,2014
-tests/test_fields.py,sha256=LPLx09cX5u9XHAh65XvTgIqzKylToiHZxXzKhpV0wsk,11148
-tests/test_file.py,sha256=EleTssys5fCP4N0W1eTZN35uijzoF15e3dIcuIlrMsk,7865
+tests/test_example.py,sha256=JeHxSK0IVDcSrOhSZlNGSQv4JAc_r6mzvJM8PfmLTMw,2018
+tests/test_fields.py,sha256=0hce2XtDHY9dTLCYhrm2s4I41OeKsQbbaKmDZ4XctUw,9824
+tests/test_file.py,sha256=9APE1d43lQ8Dk8lwJFNUK_YekYYsQ0ae2_fgpcPE9mk,8116
 tests/test_labels.py,sha256=6MOKrGznkwU5fjZ_3oiB6Scmb480Eu-9geBJs0UDLds,159
-tests/test_structure.py,sha256=SVsnluVoIIprYw_67I1_gB3cp9m1wlO8C7SpdsLW8cM,1161
-csv_detective-0.7.5.dev1277.dist-info/METADATA,sha256=RgcnqpKqQ1us0lmVf6McKYJs38DC1sqvAh10XgnJOY8,1386
-csv_detective-0.7.5.dev1277.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-csv_detective-0.7.5.dev1277.dist-info/entry_points.txt,sha256=JjweTReFqKJmuvkegzlew2j3D5pZzfxvbEGOtGVGmaY,56
-csv_detective-0.7.5.dev1277.dist-info/top_level.txt,sha256=M0Nv646VHo-49zWjPkwo2C48UmtfddV8_9mEZeIxy8Q,20
-csv_detective-0.7.5.dev1277.dist-info/RECORD,,
+tests/test_structure.py,sha256=bv-tjgXohvQAxwmxzH0BynFpK2TyPjcxvtIAmIRlZmA,1393
+tests/test_validation.py,sha256=VwtBcnGAQ_eSFrBibWnMSTDjuy6y2JLlqvc3Zb667NY,479
+csv_detective-0.7.5.dev1298.dist-info/METADATA,sha256=cy8kKhsbQVd8DQ2UMJe7z1nyxoGEvmFnQfsTdCTwXXc,1386
+csv_detective-0.7.5.dev1298.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+csv_detective-0.7.5.dev1298.dist-info/entry_points.txt,sha256=JjweTReFqKJmuvkegzlew2j3D5pZzfxvbEGOtGVGmaY,56
+csv_detective-0.7.5.dev1298.dist-info/top_level.txt,sha256=M0Nv646VHo-49zWjPkwo2C48UmtfddV8_9mEZeIxy8Q,20
+csv_detective-0.7.5.dev1298.dist-info/RECORD,,

{csv_detective-0.7.5.dev1277.dist-info → csv_detective-0.7.5.dev1298.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any