valediction 1.1.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

valediction/validation/issues.py

@@ -8,7 +8,7 @@ from pandas import DataFrame, concat
 
 from valediction.datasets.datasets_helpers import DatasetItemLike
 from valediction.io.csv_readers import CsvReadConfig, read_csv_ranges
-from valediction.support import _normalise_name, list_as_bullets
+from valediction.support import _strip, list_as_bullets
 
 
 class IssueType(Enum):
@@ -26,6 +26,7 @@ class IssueType(Enum):
     TYPE_MISMATCH = "TypeMismatch"
     TEXT_TOO_LONG = "TextTooLong"
     FORBIDDEN_CHARACTER = "ForbiddenCharacter"
+    INTEGER_OUT_OF_RANGE = "IntegerOutOfRange"
 
 
 # Settings
@@ -107,6 +108,7 @@ class Issue:
         merged.append(cur)
         self.ranges = merged
 
+    # Inspect
     def inspect(
         self,
         additional_columns: bool | str | list[str] | None = None,
@@ -132,9 +134,9 @@ class Issue:
             ValueError: if the issue has no parent DatasetItem
         """
         # Guard
-        if not self.parent:
-            raise ValueError("Issue has no parent DatasetItem")
+        self.__guard_parent()
         header = self.__repr__() if print_header else ""
+
         # Not applicable
         if self.type in APPLIES_WHOLE_COLUMN:
             print(f"{header}: applies to whole column")
@@ -143,22 +145,8 @@ class Issue:
         # Column Inclusion
         if print_header:
             print(f"{header}:")
-        if additional_columns is True:
-            columns = None
-        else:
-            additional_columns = (
-                [additional_columns]
-                if isinstance(additional_columns, str)
-                else additional_columns
-            )
-            base = (
-                set(self.parent.primary_keys)
-                if self.type in PRIMARY_KEY_ISSUES
-                else {self.column}
-            )
-            base |= set(additional_columns or [])
-            base.discard(None)
-            columns = list(base) if base else None
+
+        columns = self.__select_columns(additional_columns)
 
         if not self.ranges:
             return DataFrame(columns=columns) if columns else DataFrame()
@@ -194,6 +182,31 @@ class Issue:
 
         return out if columns is None else out.loc[:, columns]
 
+    # Inspect Helpers
+    def __guard_parent(self):
+        if not self.parent:
+            raise ValueError("Issue has no parent DatasetItem")
+
+    def __select_columns(self, additional_columns: bool | str | list[str]) -> list:
+        if additional_columns is True:
+            columns = None
+        else:
+            additional_columns = (
+                [additional_columns]
+                if isinstance(additional_columns, str)
+                else additional_columns
+            )
+            base = (
+                set(self.parent.primary_keys)
+                if self.type in PRIMARY_KEY_ISSUES
+                else {self.column}
+            )
+            base |= set(additional_columns or [])
+            base.discard(None)
+            columns = list(base) if base else None
+
+        return columns
+
 
 @dataclass
 class Issues:
@@ -235,8 +248,8 @@ class Issues:
         parent: DatasetItemLike | None = None,
     ) -> Issue:
         key = (
-            _normalise_name(table),
-            _normalise_name(column) if column is not None else None,
+            _strip(table),
+            _strip(column) if column is not None else None,
             issue_type,
         )
         issue = self._index.get(key)
@@ -255,8 +268,8 @@ class Issues:
         issue_type: IssueType | None = None,
     ) -> list[Issue]:
         """Case-insensitive filter; any arg can be None to act as a wildcard."""
-        table = _normalise_name(table)
-        column = _normalise_name(column) if column is not None else None
+        table = _strip(table)
+        column = _strip(column) if column is not None else None
         output: list[Issue] = []
         if issue_type is not None:
             # direct index lookup where possible
@@ -268,9 +281,9 @@ class Issues:
 
         # otherwise scan (still cheap; we maintain a compact list)
         for item in self._items:
-            if _normalise_name(item.table) != table:
+            if _strip(item.table) != table:
                 continue
-            if column is not None and (_normalise_name(item.column) or "") != column:
+            if column is not None and (_strip(item.column) or "") != column:
                 continue
             output.append(item)
         return output

valediction/validation/validation.py

@@ -14,13 +14,14 @@ from valediction.data_types.data_types import DataType
 from valediction.datasets.datasets_helpers import DataLike, DatasetItemLike
 from valediction.dictionary.model import Table
 from valediction.exceptions import DataDictionaryImportError, DataIntegrityError
+from valediction.integrity import get_config
 from valediction.io.csv_readers import (
     CsvReadConfig,
     FrameChunk,
     iter_csv_chunks,
 )
 from valediction.progress import Progress
-from valediction.support import _get_runtime_string, calculate_runtime
+from valediction.support import _get_runtime_string, _normalise, calculate_runtime
 from valediction.validation.helpers import (
     _column_has_values,
     _set_nulls,
@@ -29,6 +30,7 @@ from valediction.validation.helpers import (
     invalid_mask_datetime,
     invalid_mask_float,
     invalid_mask_integer,
+    invalid_mask_integer_out_of_range,
     invalid_mask_text_forbidden_characters,
     invalid_mask_text_too_long,
     mask_to_ranges,
@@ -86,7 +88,9 @@ class Validator:
         self._dt_needs_infer: set[str] = set()
 
         #  Helpers
-        self._column_names: set = set(self.table_dictionary.get_column_names())
+        self._column_names: set[str] = {
+            _normalise(n) for n in self.table_dictionary.get_column_names()
+        }
 
         # Progress Tracking
         self.progress: Progress | None = None
@@ -149,12 +153,26 @@ class Validator:
             datetime_format = column.datetime_format
             data_type = column.data_type
 
-            if data_type in (DataType.DATE, DataType.DATETIME):
+            if data_type in (DataType.DATE, DataType.TIMESTAMP):
                 self._dt_format_cache[name] = datetime_format
 
                 if not datetime_format:
                     self._dt_needs_infer.add(name)
 
+    # Column Scanning
+    def _resolve_df_col(self, df: DataFrame, name: str) -> str | None:
+        """Return the actual df column label matching name case-insensitively."""
+        target = _normalise(name)
+        return next((c for c in df.columns if _normalise(str(c)) == target), None)
+
+    def _resolve_df_cols(self, df: DataFrame, names: list[str]) -> list[str]:
+        resolved: list[str] = []
+        for n in names:
+            c = self._resolve_df_col(df, n)
+            if c is not None:
+                resolved.append(c)
+        return resolved
+
     # Validate
     def validate(self):
         """
@@ -272,28 +290,35 @@ class Validator:
     # Validation: Start Helpers
     def _check_for_missing_columns(self, df: DataFrame):
         self.__begin_step(step="Checking for missing columns")
-        missing = self._column_names - set(df.columns)
-        if missing:
-            for column in missing:
-                self.issues.add(
-                    issue_type=IssueType.MISSING_COLUMN,
-                    table=self.table_name,
-                    column=column,
-                    parent=self.dataset_item,
-                )
+
+        dict_names = self.table_dictionary.get_column_names()
+        dict_keys = {_normalise(name) for name in dict_names}
+
+        df_keys = {_normalise(str(column)) for column in df.columns}
+
+        missing_keys = dict_keys - df_keys
+        if missing_keys:
+            for name in dict_names:
+                if _normalise(name) in missing_keys:
+                    self._save_issues(IssueType.MISSING_COLUMN, name)
+
         self.__complete_step()
 
     def _check_for_extra_columns(self, df: DataFrame):
         self.__begin_step(step="Checking for extra columns")
-        extra = set(df.columns) - self._column_names
-        if extra:
-            for column in extra:
-                self.issues.add(
-                    issue_type=IssueType.EXTRA_COLUMN,
-                    table=self.table_name,
-                    column=column,
-                    parent=self.dataset_item,
-                )
+
+        dict_keys = {
+            _normalise(name) for name in self.table_dictionary.get_column_names()
+        }
+        df_cols = [str(column) for column in df.columns]
+        df_keys = {_normalise(column) for column in df_cols}
+
+        extra_keys = df_keys - dict_keys
+        if extra_keys:
+            for col in df_cols:
+                if _normalise(col) in extra_keys:
+                    self._save_issues(IssueType.EXTRA_COLUMN, col)
+
         self.__complete_step()
 
     # Validation: Chunk Helpers
@@ -319,21 +344,18 @@ class Validator:
 
         # Check for whitespace (text cols only)
         self.__begin_step(step="Checking for primary key whitespace")
-        pk_cols_text = []
-        for column in self.table_dictionary:
-            if column.name in pk_cols and column.data_type in [DataType.TEXT]:
-                pk_cols_text.append(column.name)
+        pk_keys = {_normalise(p) for p in pk_cols}
+        pk_cols_text = [
+            column.name
+            for column in self.table_dictionary
+            if _normalise(column.name) in pk_keys and column.data_type is DataType.TEXT
+        ]
 
         if pk_cols_text:
-            space_mask = pk_contains_whitespace_mask(df[pk_cols_text])
+            pk_cols_text_df = self._resolve_df_cols(df, pk_cols_text)
+            space_mask = pk_contains_whitespace_mask(df[pk_cols_text_df])
             if space_mask.any():
-                self.issues.add(
-                    issue_type=IssueType.PK_WHITESPACE,
-                    table=self.table_name,
-                    column=None,
-                    ranges=mask_to_ranges(space_mask, start_row),
-                    parent=self.dataset_item,
-                )
+                self._save_issues(IssueType.PK_WHITESPACE, None, space_mask, start_row)
         self.__complete_step()
 
     def _check_primary_key_integrity(self, df, start_row: int) -> None:
@@ -343,7 +365,9 @@ class Validator:
 
         # Create primary key hashes
         self.__begin_step(step="Creating primary key hashes")
-        pk_hashes = create_pk_hashes(df[pk_cols])
+        pk_cols_df = self._resolve_df_cols(df, pk_cols)
+        pk_hashes = create_pk_hashes(df[pk_cols_df])
+
         self.__complete_step()
 
         # Primary Key Nulls
@@ -353,13 +377,7 @@ class Validator:
         pk_hashes_non_null = pk_hashes[non_null]
 
         if null.any():
-            self.issues.add(
-                IssueType.PK_NULL,
-                table=self.table_name,
-                column=None,
-                ranges=mask_to_ranges(null, start_row),
-                parent=self.dataset_item,
-            )
+            self._save_issues(IssueType.PK_NULL, None, null, start_row)
         self.__complete_step()
 
         # 2) In-chunk collisions
@@ -389,22 +407,14 @@ class Validator:
 
         # 7) Emit in-chunk collisions Issues
         if in_chunk_collision.any():
-            self.issues.add(
-                IssueType.PK_COLLISION,
-                table=self.table_name,
-                column=None,
-                ranges=mask_to_ranges(in_chunk_collision, start_row),
-                parent=self.dataset_item,
+            self._save_issues(
+                IssueType.PK_COLLISION, None, in_chunk_collision, start_row
             )
 
         # 7) Emit cross-chunk collisions Issues
         if cross_chunk_collision.any():
-            self.issues.add(
-                IssueType.PK_COLLISION,
-                table=self.table_name,
-                column=None,
-                ranges=mask_to_ranges(cross_chunk_collision, start_row),
-                parent=self.dataset_item,
+            self._save_issues(
+                IssueType.PK_COLLISION, None, cross_chunk_collision, start_row
             )
 
             # Add the original PK row as a collision
@@ -415,7 +425,7 @@ class Validator:
                         IssueType.PK_COLLISION,
                         table=self.table_name,
                         column=None,
-                        ranges=[Range(first_row, first_row)],
+                        ranges=[Range(first_row, first_row)],  # add directly
                         parent=self.dataset_item,
                     )
                     self.tracker_pk_reported_first.add(int(h))
@@ -437,44 +447,90 @@ class Validator:
             self.__complete_step()
             return
 
-        columns = [col for col in self._dt_needs_infer if col in df.columns]
-        if not columns:
+        cols = [
+            (dict_col, df_col)
+            for dict_col in self._dt_needs_infer
+            if (df_col := self._resolve_df_col(df, dict_col)) is not None
+        ]
+        if not cols:
             self.__complete_step()
             return
 
-        for column in columns:
-            series = df[column].astype("string", copy=False).str.strip()
-            unique = series.dropna().unique()
+        from valediction.validation.helpers import _allowed_formats_for
+
+        for dict_col, df_col in cols:
+            unique = (
+                df[df_col].astype("string", copy=False).str.strip().dropna().unique()
+            )
             if len(unique) == 0:
                 continue
 
             try:
-                fmt_or_false = infer_datetime_format(Series(unique, dtype="string"))
+                fmt = infer_datetime_format(Series(unique, dtype="string"))
             except ValueError:
-                # ambiguous - try again in later chunk
                 continue
 
-            if fmt_or_false and fmt_or_false is not False:
-                col_dtype = self._find_data_type(column)
-                from valediction.validation.helpers import _allowed_formats_for
-
-                allowed = _allowed_formats_for(col_dtype)
-                if fmt_or_false in allowed:
-                    self._dt_format_cache[column] = fmt_or_false
-                    self._dt_needs_infer.discard(column)
-
-                    # Persist in the dictionary
-                    try:
-                        self.table_dictionary.get_column(
-                            column
-                        ).datetime_format = fmt_or_false
-                    except Exception:
-                        pass
+            if not fmt or fmt is False:
+                continue
+
+            col_dtype = self._find_data_type(dict_col)  # case-insensitive getter
+            if fmt not in _allowed_formats_for(col_dtype):
+                continue
+
+            self._dt_format_cache[dict_col] = fmt
+            self._dt_needs_infer.discard(dict_col)
+
+            try:
+                self.table_dictionary.get_column(dict_col).datetime_format = fmt
+            except Exception:
+                pass
+
         self.__complete_step()
 
+    def _save_issues(
+        self,
+        issue_type: IssueType,
+        column: str | None = None,
+        invalid: Series | None = None,
+        start_row: int | None = None,
+    ) -> None:
+        if invalid is not None and start_row is None:
+            raise ValueError(
+                "'start_row' must be provided when 'invalid' mask is provided"
+            )
+
+        ranges = None if invalid is None else mask_to_ranges(invalid, start_row)
+        self.issues.add(
+            issue_type=issue_type,
+            table=self.table_name,
+            column=column,
+            ranges=ranges,
+            parent=self.dataset_item,
+        )
+
+    def _check_column_types_integer(
+        self, col: str, series: Series, start_row: int, allow_bigint: bool
+    ) -> None:
+        invalid = invalid_mask_integer(series)
+        if invalid.any():
+            self._save_issues(IssueType.TYPE_MISMATCH, col, invalid, start_row)
+
+        # Check for out of range integers
+        if allow_bigint is False:
+            out_of_range = invalid_mask_integer_out_of_range(
+                series, invalid_integer_mask=invalid
+            )
+            if out_of_range.any():
+                self._save_issues(
+                    IssueType.INTEGER_OUT_OF_RANGE, col, out_of_range, start_row
+                )
+
     def _check_column_types(self, df: DataFrame, start_row: int) -> None:
         self.__begin_step(step="Checking column types")
-        present = [col for col in df.columns if col in self._column_names]
+        present = [
+            col for col in df.columns if _normalise(str(col)) in self._column_names
+        ]
+        config = get_config()
         for col in present:
             dtype = self._find_data_type(col)
             if dtype == DataType.TEXT:
@@ -482,61 +538,51 @@ class Validator:
 
             series = df[col]
             if dtype == DataType.INTEGER:
-                invalid = invalid_mask_integer(series)
-            elif dtype == DataType.FLOAT:
+                self._check_column_types_integer(
+                    col, series, start_row, config.allow_bigint
+                )
+                continue
+
+            if dtype == DataType.FLOAT:
                 invalid = invalid_mask_float(series)
             elif dtype == DataType.DATE:
                 fmt = self._dt_format_cache.get(col) or self._find_datetime_format(col)
                 invalid = invalid_mask_date(series, fmt)
-            elif dtype == DataType.DATETIME:
+            elif dtype == DataType.TIMESTAMP:
                 fmt = self._dt_format_cache.get(col) or self._find_datetime_format(col)
                 invalid = invalid_mask_datetime(series, fmt)
             else:
                 continue
 
             if invalid.any():
-                self.issues.add(
-                    IssueType.TYPE_MISMATCH,
-                    table=self.table_name,
-                    column=col,
-                    ranges=mask_to_ranges(invalid, start_row),
-                    parent=self.dataset_item,
-                )
+                self._save_issues(IssueType.TYPE_MISMATCH, col, invalid, start_row)
         self.__complete_step()
 
     def _check_text_lengths(self, df: DataFrame, start_row: int) -> None:
         self.__begin_step(step="Checking text lengths")
-        present = [col for col in df.columns if col in self._column_names]
+        present = [
+            col for col in df.columns if _normalise(str(col)) in self._column_names
+        ]
         for col in present:
             if self._find_data_type(col) != DataType.TEXT:
                 continue
             max_len = self._find_max_length(col)
             invalid = invalid_mask_text_too_long(df[col], max_len)
             if invalid.any():
-                self.issues.add(
-                    IssueType.TEXT_TOO_LONG,
-                    table=self.table_name,
-                    column=col,
-                    ranges=mask_to_ranges(invalid, start_row),
-                    parent=self.dataset_item,
-                )
+                self._save_issues(IssueType.TEXT_TOO_LONG, col, invalid, start_row)
         self.__complete_step()
 
     def _check_text_forbidden_chars(self, df: DataFrame, start_row: int) -> None:
         self.__begin_step(step="Checking for forbidden characters")
-        present = [col for col in df.columns if col in self._column_names]
+        present = [
+            col for col in df.columns if _normalise(str(col)) in self._column_names
+        ]
         for col in present:
             if self._find_data_type(col) != DataType.TEXT:
                 continue
             mask = invalid_mask_text_forbidden_characters(df[col])
             if mask.any():
-                self.issues.add(
-                    IssueType.FORBIDDEN_CHARACTER,
-                    table=self.table_name,
-                    column=col,
-                    ranges=mask_to_ranges(mask, start_row),
-                    parent=self.dataset_item,
-                )
+                self._save_issues(IssueType.FORBIDDEN_CHARACTER, col, mask, start_row)
         self.__complete_step()
 
     # Validation: Final Helpers
@@ -544,12 +590,7 @@ class Validator:
         self.__begin_step(step="Checking for fully null columns")
         for column, seen in self.tracker_seen_non_nulls.items():
             if not seen:
-                self.issues.add(
-                    issue_type=IssueType.FULLY_NULL_COLUMN,
-                    table=self.table_name,
-                    column=column,
-                    parent=self.dataset_item,
-                )
+                self._save_issues(IssueType.FULLY_NULL_COLUMN, column)
         self.__complete_step()
 
     # Progress Helpers

{valediction-1.1.0.dist-info → valediction-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valediction
-Version: 1.1.0
+Version: 1.5.0
 Summary: Valediction is a convenience data validation package that allows generation, import, and constraint enforcement of user-defined data dictionaries against datasets.
 Author-email: Cai Davis <Cai.Davis@uhs.nhs.uk>
 Requires-Python: <4.0,>=3.11

valediction-1.5.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+valediction/__init__.py,sha256=HJy57qHyaeENZ0xGf5-jkkal-P92n242UU6vIqtsnaw,511
+valediction/convenience.py,sha256=gDSNcI_T9VKO3Lk1Van4YQCt6hp_fqPyJnUJD8QNP_o,1438
+valediction/exceptions.py,sha256=OtAq_ShVCZeoNx0hWCzJVlVdl3Gm55l72IP1KrKUMR0,748
+valediction/integrity.py,sha256=P18v_5BaUNZTTDfp0OLB9N-eM0IoqzxSVjhmEhNOQKY,5254
+valediction/progress.py,sha256=fXld7BRhp8kk7xPCG50PbRPXvF8RV7Br2hENHuOUlbo,5974
+valediction/support.py,sha256=dhKwhtL6dgG709T6fkGaLZDvjYtnxIO9cMmgz477m-I,2207
+valediction/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valediction/data_types/data_type_helpers.py,sha256=EyADhEHaLwKL7JaLsp2EgIsqo9O5r34WqiawWZKWVHI,2284
+valediction/data_types/data_types.py,sha256=kluHvBdSwAjB5eBEM1xYH-SjiruhDaXiRMI2Bl0Lw7Y,1612
+valediction/data_types/type_inference.py,sha256=a6er1jFZrhwAU0z2h1FsrmooPXUmwu6qkI2cHaciOb4,20315
+valediction/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valediction/datasets/datasets.py,sha256=uweSdVkk5-zDBzL8M-cHnC6LETZXnubakajFi0J6L_c,30089
+valediction/datasets/datasets_helpers.py,sha256=AdB3ws5MYFpiXTmHXmSsdm2wZVwDXkXDOtYLvSYhs4I,1159
+valediction/demo/DEMO - Data Dictionary.xlsx,sha256=upbwe14U5haXNarJndSW7ur6rd7RAssyEV2x2D7avao,45271
+valediction/demo/DEMOGRAPHICS.csv,sha256=ochj8tiHdRByvK2YbZTw5UR3UxbjYxA2xVbA1BfUlbU,3437
+valediction/demo/DIAGNOSES.csv,sha256=tJYtjeyLEbLvgulsbLA2MQg07AN_vGDSRGUn33xdiwM,19784
+valediction/demo/LAB_TESTS.csv,sha256=ii1tdQWmm2JiG6MdywB8in_R8vXBJzalD1TEvxG3abw,80401
+valediction/demo/VITALS.csv,sha256=npyaJAP5pLNndz3P3gQ4VbwI5_KwvCrXjSXjNLVJ1g0,46643
+valediction/demo/__init__.py,sha256=trPaz5YRP_HCUJCVZhHdU8uQaaNjAISpFWCRx89ewBg,200
+valediction/demo/demo_dictionary.py,sha256=etTvXk3r9OkPOL9C8Ws9RGZ3DgPsGT-JWt4gRmDgLfg,4411
+valediction/dictionary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valediction/dictionary/exporting.py,sha256=uRcnVzY5Uj0Yfju4y8sWsjTSP7ywATV9CQDYZMmnws0,18617
+valediction/dictionary/exporting_helpers.py,sha256=O2pOMAHsRIyhLzxrSFrHIHJEf0wEteJguSI2JK9Rxcw,12434
+valediction/dictionary/generation.py,sha256=XVGabsZgoFFC6nyr8vRrypdXnyfajAUTWWLs3miamm8,12306
+valediction/dictionary/helpers.py,sha256=C8LM5FjQmWiOzLLDck08ihGbuVSuXQwCgkVWPKaOoOE,5289
+valediction/dictionary/importing.py,sha256=e_jfVzW2tyfD1eR78_FL0MsFkA17RUDP6n9taX2Bxqk,19564
+valediction/dictionary/integrity.py,sha256=k0RLRyNs8dsHyOivl2WCS6jxlhPsW9wfXB48owyokfs,787
+valediction/dictionary/model.py,sha256=WtTGb5gZAtg7JiurvaWuD1K4DnNkygU-PoEVTZIgBCc,21617
+valediction/dictionary/template/PROJECT - Data Dictionary.xltx,sha256=1boUdgNE1zYUu3pko9QREEi-hn29gp85PQqVwISyS2U,41691
+valediction/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valediction/io/csv_readers.py,sha256=sKYP_xtOuxwm6ce2eDrphQ_wagxP0RYMXiMlEtkybBg,9812
+valediction/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valediction/validation/helpers.py,sha256=RZsFeRGJqHJlxtSbXItV093-4SuXoI74X9539ZyqswY,12034
+valediction/validation/issues.py,sha256=UO5bFxCOfT76rwi3SWi7wdn6Ux2wxxPC02RGvl0dL9Y,9374
+valediction/validation/validation.py,sha256=ezWr4-RRq3w5P-IT3nC9g-KIz0FWXkFdNY-_ouOJxzo,22688
+valediction-1.5.0.dist-info/METADATA,sha256=7OF5xMdNJnOVhEaz1ffd1lJqz61qJqje_T_r9PkKa7o,612
+valediction-1.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+valediction-1.5.0.dist-info/RECORD,,

valediction-1.1.0.dist-info/RECORD

@@ -1,38 +0,0 @@
-valediction/__init__.py,sha256=HJy57qHyaeENZ0xGf5-jkkal-P92n242UU6vIqtsnaw,511
-valediction/convenience.py,sha256=gDSNcI_T9VKO3Lk1Van4YQCt6hp_fqPyJnUJD8QNP_o,1438
-valediction/exceptions.py,sha256=OtAq_ShVCZeoNx0hWCzJVlVdl3Gm55l72IP1KrKUMR0,748
-valediction/integrity.py,sha256=_4kTywJFSoQIkQ3tFbxMJH1---N8ML9SY0C7j2ZXA-c,3352
-valediction/progress.py,sha256=fXld7BRhp8kk7xPCG50PbRPXvF8RV7Br2hENHuOUlbo,5974
-valediction/support.py,sha256=Kmjopx62dGUnLcIcq-kMAk-YRFx6ip2pCHaCwBFxBIk,2156
-valediction/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valediction/data_types/data_type_helpers.py,sha256=iqcpSPBoFZybkTMHBmxrlv56ZRg8PbqSLtVsuJXC2G0,2282
-valediction/data_types/data_types.py,sha256=MJv_io_hvbLo0G0N38kwj71goXlAo0isPFyS3TU05II,1605
-valediction/data_types/type_inference.py,sha256=11SGYgpvfAfwrDwyOewVIwvfA6pQtDo6i94_xfebYM8,19952
-valediction/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valediction/datasets/datasets.py,sha256=uDDzmLLAWbzKwXhT_RtLaVH-2f_QEhxAFxNFDotTLdY,30069
-valediction/datasets/datasets_helpers.py,sha256=AdB3ws5MYFpiXTmHXmSsdm2wZVwDXkXDOtYLvSYhs4I,1159
-valediction/demo/DEMO - Data Dictionary.xlsx,sha256=wj1JG8dHgdALVwV0zSSYnyWMomMTzrHxGFRm491wM_A,45308
-valediction/demo/DEMOGRAPHICS.csv,sha256=ochj8tiHdRByvK2YbZTw5UR3UxbjYxA2xVbA1BfUlbU,3437
-valediction/demo/DIAGNOSES.csv,sha256=tJYtjeyLEbLvgulsbLA2MQg07AN_vGDSRGUn33xdiwM,19784
-valediction/demo/LAB_TESTS.csv,sha256=ii1tdQWmm2JiG6MdywB8in_R8vXBJzalD1TEvxG3abw,80401
-valediction/demo/VITALS.csv,sha256=npyaJAP5pLNndz3P3gQ4VbwI5_KwvCrXjSXjNLVJ1g0,46643
-valediction/demo/__init__.py,sha256=trPaz5YRP_HCUJCVZhHdU8uQaaNjAISpFWCRx89ewBg,200
-valediction/demo/demo_dictionary.py,sha256=OQcmKpKuRmLQuidYr2KIVF3_78crki5HU8E6RuFm01s,4410
-valediction/dictionary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valediction/dictionary/exporting.py,sha256=uRcnVzY5Uj0Yfju4y8sWsjTSP7ywATV9CQDYZMmnws0,18617
-valediction/dictionary/exporting_helpers.py,sha256=O2pOMAHsRIyhLzxrSFrHIHJEf0wEteJguSI2JK9Rxcw,12434
-valediction/dictionary/generation.py,sha256=eN8zBkvppp3fz7winWRx8wW0rhG5Ti88Z4QpXp7wJvE,12350
-valediction/dictionary/helpers.py,sha256=5QLt0isARdkoegVopWmHvTju9JOtz3yLBx7ID67QyHw,5460
-valediction/dictionary/importing.py,sha256=ucpTxAD1rwNdnUAFDeYkyLMppgNsM-LIByCmtAcAvjQ,18841
-valediction/dictionary/integrity.py,sha256=k0RLRyNs8dsHyOivl2WCS6jxlhPsW9wfXB48owyokfs,787
-valediction/dictionary/model.py,sha256=7p7FhTicudq16oXzCc7CgK1iF24AoKIjqgpBcGUJrtU,19107
-valediction/dictionary/template/PROJECT - Data Dictionary.xltx,sha256=ZsWmJsSBHvh3ADfrntmeVMWI9Vp_q7zqrTgp7rGd-AI,41721
-valediction/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valediction/io/csv_readers.py,sha256=6MAOZFZexvNwqiZz-8Er8Me8L4n9NVjLIj6oZOxzZ64,9830
-valediction/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valediction/validation/helpers.py,sha256=qSs_rlJzZ29TPO0pHHFFg9XqVdl1XRxu048NWDl78I0,10180
-valediction/validation/issues.py,sha256=bvHawjehs_e_2xQGoSvPdOt4t8dfASES3KBKHO3zFZo,9122
-valediction/validation/validation.py,sha256=ahYhWlY6wjwL7blYOfNhNIoRCyXCWnNrYn10G0AQGjU,21555
-valediction-1.1.0.dist-info/METADATA,sha256=tg9HnCfKQhYplzno5mOrw_hSICZZL3FyXPhNedYglOE,612
-valediction-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-valediction-1.1.0.dist-info/RECORD,,