csv-detective 0.9.3.dev2258__py3-none-any.whl → 0.9.3.dev2348__py3-none-any.whl

csv_detective/output/__init__.py

@@ -4,12 +4,11 @@ from typing import Iterator
 
 import pandas as pd
 
+from csv_detective.output.dataframe import cast_df_chunks
+from csv_detective.output.profile import create_profile
+from csv_detective.output.schema import generate_table_schema
 from csv_detective.utils import is_url
 
-from .dataframe import cast_df_chunks
-from .profile import create_profile
-from .schema import generate_table_schema
-
 
 def generate_output(
     table: pd.DataFrame,

csv_detective/output/dataframe.py

@@ -5,9 +5,9 @@ from typing import Iterator
 
 import pandas as pd
 
-from csv_detective.detect_fields.other.booleen import bool_casting
-from csv_detective.detect_fields.other.float import float_casting
-from csv_detective.detect_fields.temp.date import date_casting
+from csv_detective.formats.booleen import bool_casting
+from csv_detective.formats.date import date_casting
+from csv_detective.formats.float import float_casting
 from csv_detective.parsing.csv import CHUNK_SIZE
 from csv_detective.utils import display_logs_depending_process_time
 

csv_detective/output/profile.py

@@ -1,12 +1,11 @@
 import logging
 from collections import defaultdict
 from time import time
-from typing import Optional
 
 import numpy as np
 import pandas as pd
 
-from csv_detective.detect_fields.other.float import float_casting
+from csv_detective.formats.float import float_casting
 from csv_detective.utils import cast_prevent_nan, display_logs_depending_process_time
 
 
@@ -17,7 +16,7 @@ def create_profile(
     limited_output: bool = True,
     cast_json: bool = True,
     verbose: bool = False,
-    _col_values: Optional[dict[str, pd.Series]] = None,
+    _col_values: dict[str, pd.Series] | None = None,
 ) -> dict:
     if verbose:
         start = time()

csv_detective/output/schema.py

@@ -103,7 +103,7 @@ def get_validata_type(format: str) -> str:
         "datetime_aware": "datetime",
         "datetime_naive": "datetime",
         "datetime_rfc822": "datetime",
-        "json_geojson": "geojson",
+        "geojson": "geojson",
         "latitude": "number",
         "latitude_l93": "number",
         "latitude_wgs": "number",
@@ -150,7 +150,7 @@ def get_example(format: str) -> str:
         "iso_country_code_alpha3": "FRA",
         "iso_country_code_numeric": 250,
         "jour_de_la_semaine": "lundi",
-        "json_geojson": '{"type": "Point", "coordinates": [0, 0]}',
+        "geojson": '{"type": "Point", "coordinates": [0, 0]}',
         "latitude": 42.42,
         "latitude_l93": 6037008,
         "latitude_wgs": 42.42,

csv_detective/parsing/columns.py

@@ -5,6 +5,7 @@ from typing import Callable
 import pandas as pd
 from more_itertools import peekable
 
+from csv_detective.format import Format
 from csv_detective.parsing.csv import CHUNK_SIZE
 from csv_detective.utils import display_logs_depending_process_time
 
@@ -14,15 +15,13 @@ MAX_NUMBER_CATEGORICAL_VALUES = 25
 
 def test_col_val(
     serie: pd.Series,
-    test_func: Callable,
-    proportion: float = 0.9,
+    format: Format,
     skipna: bool = True,
     limited_output: bool = False,
     verbose: bool = False,
 ) -> float:
     """Tests values of the serie using test_func.
-         - skipna : if True indicates that NaNs are not counted as False
-         - proportion :  indicates the proportion of values that have to pass the test
+         - skipna : if True indicates that NaNs are considered True
     for the serie to be detected as a certain format
     """
     if verbose:
@@ -34,28 +33,28 @@ def test_col_val(
 
     try:
         if skipna:
-            serie = serie[serie.notnull()]
+            serie = serie.loc[serie.notnull()]
         ser_len = len(serie)
         if ser_len == 0:
             # being here means the whole column is NaN, so if skipna it's a pass
             return 1.0 if skipna else 0.0
         if not limited_output:
-            result = apply_test_func(serie, test_func, ser_len).sum() / ser_len
-            return result if result >= proportion else 0.0
+            result = apply_test_func(serie, format.func, ser_len).sum() / ser_len
+            return result if result >= format.proportion else 0.0
         else:
-            if proportion == 1:
+            if format.proportion == 1:
                 # early stops (1 then 5 rows) to not waste time if directly unsuccessful
                 for _range in [
                     min(1, ser_len),
                     min(5, ser_len),
                     ser_len,
                 ]:
-                    if not all(apply_test_func(serie, test_func, _range)):
+                    if not all(apply_test_func(serie, format.func, _range)):
                         return 0.0
                 return 1.0
             else:
-                result = apply_test_func(serie, test_func, ser_len).sum() / ser_len
-                return result if result >= proportion else 0.0
+                result = apply_test_func(serie, format.func, ser_len).sum() / ser_len
+                return result if result >= format.proportion else 0.0
     finally:
         if verbose and time() - start > 3:
             display_logs_depending_process_time(
@@ -64,42 +63,27 @@ def test_col_val(
             )
 
 
-def test_col_label(
-    label: str, test_func: Callable, proportion: float = 1, limited_output: bool = False
-):
-    """Tests label (from header) using test_func.
-    - proportion :  indicates the minimum score to pass the test for the serie
-    to be detected as a certain format
-    """
-    if not limited_output:
-        return test_func(label)
-    else:
-        result = test_func(label)
-        return result if result >= proportion else 0
-
-
 def test_col(
     table: pd.DataFrame,
-    all_tests: dict[str, dict],
+    formats: dict[str, Format],
     limited_output: bool,
     skipna: bool = True,
     verbose: bool = False,
 ):
     if verbose:
         start = time()
-        logging.info("Testing columns to get types")
+        logging.info("Testing columns to get formats")
     return_table = pd.DataFrame(columns=table.columns)
-    for idx, (name, attributes) in enumerate(all_tests.items()):
+    for idx, (label, format) in enumerate(formats.items()):
         if verbose:
             start_type = time()
-            logging.info(f"\t- Starting with type '{name}'")
+            logging.info(f"\t- Starting with format '{label}'")
         # improvement lead : put the longest tests behind and make them only if previous tests not satisfactory
         # => the following needs to change, "apply" means all columns are tested for one type at once
-        return_table.loc[name] = table.apply(
+        return_table.loc[label] = table.apply(
             lambda serie: test_col_val(
                 serie,
-                attributes["func"],
-                attributes["prop"],
+                format,
                 skipna=skipna,
                 limited_output=limited_output,
                 verbose=verbose,
@@ -107,7 +91,7 @@ def test_col(
         )
         if verbose:
             display_logs_depending_process_time(
-                f'\t> Done with type "{name}" in {round(time() - start_type, 3)}s ({idx + 1}/{len(all_tests)})',
+                f'\t> Done with type "{label}" in {round(time() - start_type, 3)}s ({idx + 1}/{len(formats)})',
                 time() - start_type,
             )
     if verbose:
@@ -118,23 +102,20 @@ def test_col(
 
 
 def test_label(
-    columns: list[str], all_tests: dict[str, dict], limited_output: bool, verbose: bool = False
+    columns: list[str], formats: dict[str, Format], limited_output: bool, verbose: bool = False
 ):
     if verbose:
         start = time()
         logging.info("Testing labels to get types")
 
     return_table = pd.DataFrame(columns=columns)
-    for idx, (key, value) in enumerate(all_tests.items()):
+    for idx, (label, format) in enumerate(formats.items()):
         if verbose:
             start_type = time()
-        return_table.loc[key] = [
-            test_col_label(col_name, value["func"], value["prop"], limited_output=limited_output)
-            for col_name in columns
-        ]
+        return_table.loc[label] = [format.is_valid_label(col_name) for col_name in columns]
         if verbose:
             display_logs_depending_process_time(
-                f'\t- Done with type "{key}" in {round(time() - start_type, 3)}s ({idx + 1}/{len(all_tests)})',
+                f'\t- Done with type "{label}" in {round(time() - start_type, 3)}s ({idx + 1}/{len(formats)})',
                 time() - start_type,
             )
     if verbose:
@@ -148,23 +129,28 @@ def test_col_chunks(
     table: pd.DataFrame,
     file_path: str,
     analysis: dict,
-    all_tests: list,
+    formats: dict[str, Format],
     limited_output: bool,
     skipna: bool = True,
     verbose: bool = False,
 ) -> tuple[pd.DataFrame, dict, dict[str, pd.Series]]:
     def build_remaining_tests_per_col(return_table: pd.DataFrame) -> dict[str, list[str]]:
+        # returns a dict with the table's columns as keys and the list of remaining format labels to apply
         return {
-            col: [test for test in return_table.index if return_table.loc[test, col] > 0]
+            col: [
+                fmt_label
+                for fmt_label in return_table.index
+                if return_table.loc[fmt_label, col] > 0
+            ]
             for col in return_table.columns
         }
 
     if verbose:
         start = time()
-        logging.info("Testing columns to get types on chunks")
+        logging.info("Testing columns to get formats on chunks")
 
     # analysing the sample to get a first guess
-    return_table = test_col(table, all_tests, limited_output, skipna=skipna, verbose=verbose)
+    return_table = test_col(table, formats, limited_output, skipna=skipna, verbose=verbose)
     remaining_tests_per_col = build_remaining_tests_per_col(return_table)
 
     # hashing rows to get nb_duplicates
@@ -217,23 +203,22 @@ def test_col_chunks(
         if not any(remaining_tests for remaining_tests in remaining_tests_per_col.values()):
             # no more potential tests to do on any column, early stop
             break
-        for col, tests in remaining_tests_per_col.items():
+        for col, fmt_labels in remaining_tests_per_col.items():
             # testing each column with the tests that are still competing
             # after previous batchs analyses
-            for test in tests:
+            for label in fmt_labels:
                 batch_col_test = test_col_val(
                     batch[col],
-                    all_tests[test]["func"],
-                    all_tests[test]["prop"],
+                    formats[label],
                     limited_output=limited_output,
                     skipna=skipna,
                 )
-                return_table.loc[test, col] = (
+                return_table.loc[label, col] = (
                     # if this batch's column tested 0 then test fails overall
                     0
                     if batch_col_test == 0
                     # otherwise updating the score with weighted average
-                    else ((return_table.loc[test, col] * idx + batch_col_test) / (idx + 1))
+                    else ((return_table.loc[label, col] * idx + batch_col_test) / (idx + 1))
                 )
         remaining_tests_per_col = build_remaining_tests_per_col(return_table)
         batch, batch_number = [], batch_number + 1

csv_detective/parsing/csv.py

@@ -1,6 +1,6 @@
 import logging
 from time import time
-from typing import Optional, TextIO
+from typing import TextIO
 
 import pandas as pd
 
@@ -18,7 +18,7 @@ def parse_csv(
     skiprows: int,
     random_state: int = 42,
     verbose: bool = False,
-) -> tuple[pd.DataFrame, Optional[int], Optional[int]]:
+) -> tuple[pd.DataFrame, int | None, int | None]:
     if verbose:
         start = time()
         logging.info("Parsing table")

csv_detective/parsing/load.py

@@ -12,14 +12,13 @@ from csv_detective.detection.engine import (
 )
 from csv_detective.detection.headers import detect_headers
 from csv_detective.detection.separator import detect_separator
-from csv_detective.utils import is_url
-
-from .compression import unzip
-from .csv import parse_csv
-from .excel import (
+from csv_detective.parsing.compression import unzip
+from csv_detective.parsing.csv import parse_csv
+from csv_detective.parsing.excel import (
     XLS_LIKE_EXT,
     parse_excel,
 )
+from csv_detective.utils import is_url
 
 
 def load_file(

csv_detective/validate.py

@@ -2,13 +2,13 @@ import logging
 
 import pandas as pd
 
-from csv_detective.load_tests import return_all_tests
+from csv_detective.format import FormatsManager
 from csv_detective.parsing.columns import MAX_NUMBER_CATEGORICAL_VALUES, test_col_val
 
 VALIDATION_CHUNK_SIZE = int(1e5)
 logging.basicConfig(level=logging.INFO)
 
-tests = return_all_tests("ALL", "detect_fields")
+formats = FormatsManager().formats
 
 
 def validate(
@@ -19,6 +19,12 @@ def validate(
 ) -> tuple[bool, pd.DataFrame | None, dict | None, dict[str, pd.Series] | None]:
     """
     Verify is the given file has the same fields and types as in the given analysis.
+
+    Args:
+        file_path: the path of the file to validate
+        previous_analysis: the previous analysis to validate against (expected in the same structure as the output of the routine)
+        verbose: whether the code displays the steps it's going through
+        skipna: whether to ignore NaN values in the checks
     """
     try:
         if previous_analysis.get("separator"):
@@ -101,8 +107,7 @@ def validate(
                 continue
             test_result: float = test_col_val(
                 serie=chunk[col_name],
-                test_func=tests[args["format"]]["func"],
-                proportion=tests[args["format"]]["prop"],
+                format=formats[args["format"]],
                 skipna=skipna,
             )
             if not bool(test_result):

{csv_detective-0.9.3.dev2258.dist-info → csv_detective-0.9.3.dev2348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csv-detective
-Version: 0.9.3.dev2258
+Version: 0.9.3.dev2348
 Summary: Detect tabular files column content
 Author-email: Etalab <opendatateam@data.gouv.fr>
 License: MIT
@@ -33,7 +33,7 @@ Dynamic: license-file
 
 This is a package to **automatically detect column content in tabular files**. The script reads either the whole file or the first few rows and performs various checks (regex, casting, comparison with official lists...) to see for each column if it matches with various content types.
 
-Currently supported file types: csv, xls, xlsx, ods.
+Currently supported file types: csv(.gz), xls, xlsx, ods.
 
 You can also directly feed the URL of a remote file (from data.gouv.fr for instance).
 
@@ -65,7 +65,8 @@ inspection_results = routine(
   num_rows=-1, # Value -1 will analyze all lines of your file, you can change with the number of lines you wish to analyze
   save_results=False, # Default False. If True, it will save result output into the same directory as the analyzed file, using the same name as your file and .json extension
   output_profile=True, # Default False. If True, returned dict will contain a property "profile" indicating profile (min, max, mean, tops...) of every column of you csv
-  output_schema=True, # Default False. If True, returned dict will contain a property "schema" containing basic [tableschema](https://specs.frictionlessdata.io/table-schema/) of your file. This can be use to validate structure of other csv which should match same structure. 
+  output_schema=True, # Default False. If True, returned dict will contain a property "schema" containing basic [tableschema](https://specs.frictionlessdata.io/table-schema/) of your file. This can be use to validate structure of other csv which should match same structure.
+  tags=["fr"],  # Default None. If set as a list of strings, only performs checks related to the specified tags (you can see the available tags with FormatsManager().available_tags())
 )
 ```
 
@@ -73,7 +74,7 @@ inspection_results = routine(
 
 ### Output
 
-The program creates a `Python` dictionnary with the following information :
+The program creates a `python` dictionnary with the following information :
 
 ```
 {
@@ -216,7 +217,7 @@ Only the format with highest score is present in the output.
 ## Improvement suggestions
 
 - Smarter refactors
-- Improve performances
+- Performances improvements
 - Test other ways to load and process data (`pandas` alternatives)
 - Add more and more detection modules...
 

csv_detective-0.9.3.dev2348.dist-info/RECORD

@@ -0,0 +1,102 @@
+csv_detective/__init__.py,sha256=zlYElTOp_I2_VG7ZdOTuAu0wuCXSc0cr3sH6gtk2bcg,152
+csv_detective/cli.py,sha256=mu5anmBmaDk52_uZGiA4T37wYZCuV43gZAepjs1Cqzc,1389
+csv_detective/explore_csv.py,sha256=-LCHr7vyT0Q0oLtXeOO8pEevJ6-8Ib9JP3D7nVgZM8o,7090
+csv_detective/format.py,sha256=XX_cSTQc0jlsQq3GUqHi7Cz36AiRrpjrwPmeoOTLMvo,2396
+csv_detective/utils.py,sha256=RJ_zFOJ1DRY8HtDrKPiCdNk5gU6-KwOrOKOyfSkBZZY,1118
+csv_detective/validate.py,sha256=XldlbGkUlPaIh0y4z9iaWlmmahwCrD1900s5Cxlq5wI,5430
+csv_detective/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+csv_detective/detection/columns.py,sha256=_JtZHBr3aoEmSWh2xVe2ISnt-G7hpnA9vqlvcaGd0Go,2887
+csv_detective/detection/encoding.py,sha256=KZ8W8BPfZAq9UiP5wgaeupYa5INU8KPz98E2L3XpX2Y,999
+csv_detective/detection/engine.py,sha256=wQeDKpp2DKF-HcS1R8H6GgQyaUgQme4szPtEHgAjBII,1552
+csv_detective/detection/formats.py,sha256=uxmWz7J3btAwaOONIACxiL9vTZ8Iv7NdTSUqAOPQy0o,5381
+csv_detective/detection/headers.py,sha256=95pTL524Sy5PGxyQ03ofFUaamvlmkxTJQe8u6HfzOkU,1051
+csv_detective/detection/rows.py,sha256=quf3ZTTFPOo09H-faZ9cRKibb1QGHEKHlpivFRx2Va4,742
+csv_detective/detection/separator.py,sha256=XjeDBqhiBxVfkCPJKem9BAgJqs_hOgQltc_pxrH_-Tg,1547
+csv_detective/detection/variables.py,sha256=-QtZOB96z3pWbqnZ-c1RU3yzoYqcO61A0JzeS6JbkxY,3576
+csv_detective/formats/__init__.py,sha256=Egiy29kcG3Oz2eE2maYhD3wP29zOSOWyRlOpGD5LGvU,318
+csv_detective/formats/adresse.py,sha256=jALDpEDAWyAcgqEfNVRg_W1r6XaYuJKD_jAaP2l-bxk,1943
+csv_detective/formats/booleen.py,sha256=AnDDKShkSYpWO4POhwY2V7_C4yPWbmqBu8CJPgQ9Gwc,648
+csv_detective/formats/code_commune_insee.py,sha256=MhwCPVAhwWH-MyaNAIVRNbqKfeNe3oiCpzEGfpHkpJY,504
+csv_detective/formats/code_csp_insee.py,sha256=_JQ-YbnHMenNnwIg1xBmNVqgCa1tLD2hbPN1soODhDk,656
+csv_detective/formats/code_departement.py,sha256=odwVbmktgjEhL-dSFHXuCRVwhkF8bL8G7VlpVTnMY2A,628
+csv_detective/formats/code_fantoir.py,sha256=nFVFYJEP2HHE2TyhR_dhGdPCMLfCROBO_B8wxwQn7T8,366
+csv_detective/formats/code_import.py,sha256=N5NVvnHkRwC7ARHoM77R-2cYSeyNmPoRIn6JL3Fbnjs,346
+csv_detective/formats/code_postal.py,sha256=C6XMkiVTxhMFvfyvJmGp3iwvh722EzMwD_UdqQU4aR0,427
+csv_detective/formats/code_region.py,sha256=VFKh1rGYVYTNWBJZ2_m0xS4rhJlrI_Gr8q8RXuZCr-w,366
+csv_detective/formats/code_rna.py,sha256=WExlQtlAUfOFT4N3MKsMBhZVxTdNzgexFjmXhZdRM1w,512
+csv_detective/formats/code_waldec.py,sha256=kJEJfikbhMfVwtA8hBpup0tpeSFoY_rWrEdXQxgNwhg,297
+csv_detective/formats/commune.py,sha256=oVpwINGqpwMOT43KkasozipJ9hBeoQ5FrKV_wIeVJGE,532
+csv_detective/formats/csp_insee.py,sha256=HE6NK6Sw91mLFeAAKwWUXZZfXX6fiA0zK4RI4YdkUFY,656
+csv_detective/formats/date.py,sha256=X4ohXaFO8cXPJktUSumc3bfdlbDIWEYTG8S9ugVRcsE,2730
+csv_detective/formats/date_fr.py,sha256=3hTw5RommrhcgECFRSt9KgyB9zyi1j4W3UygEHmRgoE,502
+csv_detective/formats/datetime_aware.py,sha256=-1ZBix6vYlYXTvhXrijP-98AN7iPB0x_DbbwU1QjMCI,1470
+csv_detective/formats/datetime_naive.py,sha256=nvA8qT1fb2RmpXN5_Cw9YZA6pC4BryX_B0V-E6O2UbU,1521
+csv_detective/formats/datetime_rfc822.py,sha256=l-SLb34hSuHxC2JQ-9SD-nG38JqzoozwUZiGtoybb0A,601
+csv_detective/formats/departement.py,sha256=UP9UF23BFq_-mIS8N10K5XkoCXwPmDeSoa_7lCAkI4w,768
+csv_detective/formats/email.py,sha256=Qen2EBDYY5TtWXwxrrTGWRrbIybz0ySlVpl4ZRk8pzA,517
+csv_detective/formats/float.py,sha256=tWs_tW64OuacNQENu3uk5GOEVQMQls2iiteFOacQRAQ,832
+csv_detective/formats/geojson.py,sha256=udbBxCBRmb0o6TD8z5ryemfqdinBz6njNJU0XcbfMig,757
+csv_detective/formats/insee_ape700.py,sha256=cLs3Eersqm4wX6oqsqp0Vb3WGPJb2xY5Za_vh0uLgKc,780
+csv_detective/formats/insee_canton.py,sha256=Q5jczsOmh1wPP2KtDkcmqZ7Hlv50Zz9YvPIbxy46qs0,531
+csv_detective/formats/int.py,sha256=ZBUOn50luMtlNKWPyOaMIkY3J4f4hA0MqwcoFtksozU,482
+csv_detective/formats/iso_country_code_alpha2.py,sha256=vIep_j0xuqlXKyuvk8c8GaJC73HuJqKfQ4QzQKHsPc0,613
+csv_detective/formats/iso_country_code_alpha3.py,sha256=yOmm91O8ot6KoUBfss5cqykDfeeMNCwafDAvPNvbufA,668
+csv_detective/formats/iso_country_code_numeric.py,sha256=989ypOmjIrNTV9vFnrBlbpRWQ9whd3Rv9gNasdF_O4g,685
+csv_detective/formats/jour_de_la_semaine.py,sha256=c5QBw9eZfwRs_jL_Ckm95UH-TxlExdFmfZNYW7-_iZI,606
+csv_detective/formats/json.py,sha256=E-s7IHW0q5WgAJVK0I-5Rv7W_RdofROB5wnIXbNegZQ,446
+csv_detective/formats/latitude_l93.py,sha256=GteGpxAht-jeOBLr_deCuEXA_LliVYIAmyr_7jFAWgI,986
+csv_detective/formats/latitude_wgs.py,sha256=HPcFlLzJNqynLugDQ07vO04rOCNBuAabVJEP8FQ89Q0,780
+csv_detective/formats/latitude_wgs_fr_metropole.py,sha256=ruGzQLJPiMV2AlnsBneQIhMzstseddzWA0bDg5gfTG4,791
+csv_detective/formats/latlon_wgs.py,sha256=CbNi4Y-ZgBfNyYi54xwcZGLpEusiLAWVpFP1YgHtI1M,1224
+csv_detective/formats/longitude_l93.py,sha256=vJE4k_DyQOjAruqu_Q0E2sJKZB4mXGGN6bS9WCelsbs,768
+csv_detective/formats/longitude_wgs.py,sha256=DUZCUxJQl53HHVQbXlz_lWXoAZhy3MvJWcPNdiK5cCM,552
+csv_detective/formats/longitude_wgs_fr_metropole.py,sha256=wPlJP06K0BVWfrx1wwEAKK93AKIqvsuw705gKAlWAfQ,550
+csv_detective/formats/lonlat_wgs.py,sha256=BgtTl2ReI0hSQB-7mcR4TDxx-QzvA1B9fiZWxTb5xPI,1005
+csv_detective/formats/mois_de_lannee.py,sha256=4_mmdr9S83utVCgPaK_epkeBm2mhwdUWQEoB_Fhdh2o,759
+csv_detective/formats/money.py,sha256=HpjrmfUmbG8sXF557XbYzQ7TLtpNVRgpC991gGokO8I,414
+csv_detective/formats/mongo_object_id.py,sha256=XsiP4iMxfBBIeuL-4g5bm3jgS6yUMJC2X5CmrEJ40oI,296
+csv_detective/formats/pays.py,sha256=FRvoQwIWiKbm0RC62Sus1X0Y_yJ-cfvdB5RYhkY-4NY,693
+csv_detective/formats/percent.py,sha256=s6eQBMwJr2uyTZMUCK1_ifA0c4Rt2iEe9_E_hKKU_mk,308
+csv_detective/formats/region.py,sha256=CkN7JTsZB1X3bH5xohbtMCxL5BX9MSpith36_1mHMd4,1483
+csv_detective/formats/sexe.py,sha256=yioD4W6EkgUgo74rxn6KLZtN_0XYXtmA4mqVyI7e1mU,387
+csv_detective/formats/siren.py,sha256=ieLe50vdSnkXadcUI8VXnnId9GFGHyIBWVTP6bJtyMo,758
+csv_detective/formats/siret.py,sha256=ehkZgOH-HggN6IgxF4G0DMut_6giZ3gc4g9wMdwZFHQ,997
+csv_detective/formats/tel_fr.py,sha256=yKCqIlqKO2yKucCoCjYfSjqNKfTjqFcmNXxg6THG0WE,624
+csv_detective/formats/uai.py,sha256=uT5gjdTmoFH9QPZdTFkJgiyuKLW0B6KmT6yqHQeaeOU,711
+csv_detective/formats/url.py,sha256=GYE9j_i4kpEQueBXa1Fla0wk8_sc0n230GL3KaIRvwY,932
+csv_detective/formats/username.py,sha256=y38OggfWpEQsGi0JnD9QRM30musa29lO6nz-qybR24U,249
+csv_detective/formats/uuid.py,sha256=ekMEFfzQtz0cLudzmu3AoCM0Yf5pu23qAcFNFgHWJ1A,346
+csv_detective/formats/year.py,sha256=pkAfYPKZdy0g1ZoHGgJNpgTS5y5weGEKXCVMGaxIX8k,472
+csv_detective/formats/data/csp_insee.txt,sha256=kgKaKc-5PHu5U4--ugLjpFyMNtTU9CGdZ9ANU3YAsM4,32879
+csv_detective/formats/data/insee_ape700.txt,sha256=nKgslakENwgE7sPkVNHqR23iXuxF02p9-v5MC2_ntx8,4398
+csv_detective/formats/data/iso_country_code_alpha2.txt,sha256=YyPlDqCdz65ecf4Wes_r0P4rDSJG35niXtjc4MmctXM,1740
+csv_detective/formats/data/iso_country_code_alpha3.txt,sha256=aYqKSohgXuBtcIBfF52f8JWYDdxL_HV_Ol1srGnWBp4,1003
+csv_detective/formats/data/iso_country_code_numeric.txt,sha256=2GtEhuporsHYV-pU4q9kfXU5iOtfW5C0GYBTTKQtnnA,1004
+csv_detective/output/__init__.py,sha256=ALSq_tgX7rGyh--7rmbKz8wHkmResN0h7mNujndow3w,2103
+csv_detective/output/dataframe.py,sha256=TyBc2ObaVUns_ydJWOMKmCYvuj7ddxag0QN3z37g3GE,3219
+csv_detective/output/example.py,sha256=8LWheSBYCeDFfarbnmzBrdCbTd8Alh1U4pfXMKfabOw,8630
+csv_detective/output/profile.py,sha256=VUQp0VJ22dfY4R5TybTpuQW_TOX_rLEp98cOzu-Jf44,4876
+csv_detective/output/schema.py,sha256=XoKljXPXP00DfqPCiz1ydwTHYGAFsvNxnaPCNBuuBIo,10443
+csv_detective/output/utils.py,sha256=tbji3dEH7bDc6gLCeVSVquqU3xaHA1CQOMuaJT4Hub8,3297
+csv_detective/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+csv_detective/parsing/columns.py,sha256=CqtZRZYMYDNMopxnqs4eZLSABi-ms61wqv5M9vWJ7iU,9343
+csv_detective/parsing/compression.py,sha256=Fnw5tj-PpBNI8NYsWj5gD-DUoWcVLnsVpiKm9MpxmIA,350
+csv_detective/parsing/csv.py,sha256=0T0gpaXzwJo-sq41IoLQD704GiMUYeDVVASVbat-zWg,1726
+csv_detective/parsing/excel.py,sha256=oAVTuoDccJc4-kVjHXiIPLQx3lq3aZRRZQxkG1c06JQ,6992
+csv_detective/parsing/load.py,sha256=f-8aKiNpy_47qg4Lq-UZUR4NNrbJ_-KEGvcUQZ8cmb0,4317
+csv_detective/parsing/text.py,sha256=uz8wfmNTQnOd_4fjrIZ_5rxmFmgrg343hJh2szB73Hc,1770
+csv_detective-0.9.3.dev2348.dist-info/licenses/LICENSE,sha256=A1dQrzxyxRHRih02KwibWj1khQyF7GeA6SqdOU87Gk4,1088
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_example.py,sha256=uTWswvUzBWEADGXZmMAdZvKhKvIjvT5zWOVVABgCDN4,1987
+tests/test_fields.py,sha256=EWHIKwRSdIh74bBSoozYmZBETf7V03JMWpglyxA0ci0,5616
+tests/test_file.py,sha256=MxJOWwhRG2Xm1_m3C9x8CS9FepjUebET-6EsMi3DvmY,13125
+tests/test_labels.py,sha256=kDPerWC3_J3l1p5I3-MHwz7BmhcuxZAws_wSgHCHUuI,536
+tests/test_structure.py,sha256=XDbviuuvk-0Mu9Y9PI6He2e5hry2dXVJ6yBVwEqF_2o,1043
+tests/test_validation.py,sha256=9djBT-PDhu_563OFgWyE20o-wPEWEIQGXp6Pjh0_MQM,3463
+venv/bin/activate_this.py,sha256=wS7qPipy8R-dS_0ICD8PqqUQ8F-PrtcpiJw2DUPngYM,1287
+venv/bin/runxlrd.py,sha256=YlZMuycM_V_hzNt2yt3FyXPuwouMCmMhvj1oZaBeeuw,16092
+csv_detective-0.9.3.dev2348.dist-info/METADATA,sha256=0sy4vWAscpleL8quByGyJX5tw0OGkJfX_2lHsOetvy4,11038
+csv_detective-0.9.3.dev2348.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+csv_detective-0.9.3.dev2348.dist-info/entry_points.txt,sha256=JjweTReFqKJmuvkegzlew2j3D5pZzfxvbEGOtGVGmaY,56
+csv_detective-0.9.3.dev2348.dist-info/top_level.txt,sha256=cYKb4Ok3XgYA7rMDOYtxysjSJp_iUA9lJjynhVzue8g,30
+csv_detective-0.9.3.dev2348.dist-info/RECORD,,