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

valediction/data_types/data_type_helpers.py

@@ -62,14 +62,14 @@ def infer_datetime_format(
 
 
 def get_date_type(datetime_format: str) -> DataType | None:
-    """Identifies if a datetime format string corresponds to a Date or Datetime data
+    """Identifies if a datetime format string corresponds to a Date or Timestamp data
     type.
 
     Args:
         datetime_format (str): datetime format string
 
     Returns:
-        DataType | None: DataType of Date, Datetime, or None if not found.
+        DataType | None: DataType of Date, Timestamp, or None if not found.
     """
     config = get_config()
     return config.date_formats.get(datetime_format)

valediction/data_types/data_types.py

@@ -8,7 +8,7 @@ class DataType(Enum):
     INTEGER = "Integer"
     FLOAT = "Float"
     DATE = "Date"
-    DATETIME = "Datetime"
+    TIMESTAMP = "Timestamp"
     FILE = "File"
 
     def __str__(self) -> str:
@@ -32,9 +32,9 @@ class DataType(Enum):
             "number": cls.FLOAT,
             "numeric": cls.FLOAT,
             "date": cls.DATE,
-            "datetime": cls.DATETIME,
-            "datetime64": cls.DATETIME,
-            "timestamp": cls.DATETIME,
+            "datetime": cls.TIMESTAMP,
+            "datetime64": cls.TIMESTAMP,
+            "timestamp": cls.TIMESTAMP,
             "file": cls.FILE,
             "blob": cls.FILE,
             "binary": cls.FILE,
@@ -49,10 +49,10 @@ class DataType(Enum):
         return self in {DataType.TEXT}
 
     def valid_for_primary_key(self) -> bool:
-        """PKs can only be Text, Integer, Date, Datetime."""
+        """PKs can only be Text, Integer, Date, Timestamp."""
         return self in {
             DataType.TEXT,
             DataType.INTEGER,
             DataType.DATE,
-            DataType.DATETIME,
+            DataType.TIMESTAMP,
         }

valediction/data_types/type_inference.py

@@ -4,6 +4,7 @@ import re
 import warnings
 
 import pandas as pd
+from pandas.api.types import is_object_dtype, is_string_dtype
 
 from valediction.data_types.data_type_helpers import infer_datetime_format
 from valediction.data_types.data_types import DataType
@@ -53,8 +54,8 @@ class ColumnState:
             return DataType.FLOAT, None
         if self.data_type == DataType.DATE:
             return DataType.DATE, None
-        if self.data_type == DataType.DATETIME:
-            return DataType.DATETIME, None
+        if self.data_type == DataType.TIMESTAMP:
+            return DataType.TIMESTAMP, None
 
         return DataType.TEXT, _len1()
 
@@ -123,7 +124,7 @@ class TypeInferer:
             _handling_function: callable = {
                 DataType.TEXT: self._handle_state_text,
                 DataType.DATE: self._handle_state_date,
-                DataType.DATETIME: self._handle_state_datetime,
+                DataType.TIMESTAMP: self._handle_state_datetime,
                 DataType.INTEGER: self._handle_state_integer,
                 DataType.FLOAT: self._handle_state_float,
             }.get(state.data_type, self._handle_state_text)
@@ -141,20 +142,31 @@ class TypeInferer:
         self, s: pd.Series
     ) -> tuple[pd.Series, pd.Series, pd.Series, int | None]:
         self.__begin_step(step="Trimming whitespace")
-        trimmed = s.str.strip()
+        is_text = is_string_dtype(s) or is_object_dtype(s)
+
+        if is_text:
+            trimmed = s.astype("string").str.strip()
+        else:
+            trimmed = s
         self.__complete_step()
 
         self.__begin_step(step="Checking nulls")
-        nulls = trimmed.isna() | trimmed.str.lower().isin(self.null_tokens)
+        if is_text:
+            nulls = trimmed.isna() | trimmed.str.lower().isin(self.null_tokens)
+        else:
+            nulls = trimmed.isna()
         self.__complete_step()
 
         self.__begin_step(step="Checking max length")
-        lengths = s.str.len()
-        max_len = int(lengths.max(skipna=True)) if lengths.notna().any() else None
+        if is_text:
+            lengths = trimmed.str.len()
+            max_len = int(lengths.max(skipna=True)) if lengths.notna().any() else None
+        else:
+            max_len = None
         self.__complete_step()
 
         self.__begin_step(step="Setting non-null mask")
-        nonnull_mask = (~nulls) & s.notna()
+        nonnull_mask = (~nulls) & trimmed.notna()
         self.__complete_step()
 
         return trimmed, nulls, nonnull_mask, max_len
@@ -193,7 +205,7 @@ class TypeInferer:
             if ok.all():
                 self._transition(
                     st,
-                    DataType.DATETIME if has_time.any() else DataType.DATE,
+                    DataType.TIMESTAMP if has_time.any() else DataType.DATE,
                     f"cached datetime format={st.cached_datetime_format!r}",
                 )
                 self.__complete_step()
@@ -210,7 +222,7 @@ class TypeInferer:
                     st.cached_datetime_format = fmt
                     self._transition(
                         st,
-                        DataType.DATETIME if has_time.any() else DataType.DATE,
+                        DataType.TIMESTAMP if has_time.any() else DataType.DATE,
                         f"explicit datetime format={fmt!r}",
                     )
                     self.__complete_step()
@@ -276,7 +288,7 @@ class TypeInferer:
             st.lock_text_permanent = True
             self._transition(st, DataType.TEXT, "datetime parse failures")
         elif has_time.any():
-            self._transition(st, DataType.DATETIME, "time component detected")
+            self._transition(st, DataType.TIMESTAMP, "time component detected")
 
         self.__complete_step()
 
@@ -334,7 +346,7 @@ class TypeInferer:
             if ok.all():
                 self._transition(
                     st,
-                    DataType.DATETIME if has_time.any() else DataType.DATE,
+                    DataType.TIMESTAMP if has_time.any() else DataType.DATE,
                     f"cached datetime format={st.cached_datetime_format!r}",
                 )
                 return True
@@ -377,7 +389,7 @@ class TypeInferer:
         if ok.all():
             self._transition(
                 st,
-                DataType.DATETIME if has_time.any() else DataType.DATE,
+                DataType.TIMESTAMP if has_time.any() else DataType.DATE,
                 f"explicit datetime format={st.cached_datetime_format!r}",
             )
             return True

valediction/demo/demo_dictionary.py

@@ -103,7 +103,7 @@ def demo_dictionary() -> Dictionary:
                 foreign_key="DEMOGRAPHICS.PATIENT_HASH",
             ),
             Column(
-                name="OBSERVATION_TIME", order=2, data_type="datetime", primary_key=2
+                name="OBSERVATION_TIME", order=2, data_type="timestamp", primary_key=2
             ),
             Column(
                 name="OBSERVATION_TYPE",

valediction/dictionary/generation.py

@@ -257,7 +257,7 @@ class Generator:
             table.add_column(col)
 
     def _set_datetime_format(self, column_state: ColumnState, column: Column) -> None:
-        if column.data_type in (DataType.DATE, DataType.DATETIME):
+        if column.data_type in (DataType.DATE, DataType.TIMESTAMP):
             datetime_format = getattr(column_state, "cached_datetime_format", None)
             if datetime_format and hasattr(column, "datetime_format"):
                 column.datetime_format = datetime_format

valediction/dictionary/helpers.py

@@ -106,7 +106,7 @@ def _check_primary_key(primary_key: int | None, data_type: DataType) -> list[str
     ):
         errors.append(
             f"invalid data type '{data_type.value}' for primary key column; "
-            "primary keys must be Text, Integer, Date, or Datetime"
+            "primary keys must be Text, Integer, Date, or Timestamp"
         )
 
     return errors

valediction/dictionary/importing.py

@@ -364,7 +364,7 @@ class ExcelDataDictionary:
         enumeration_flag_col_header = header_map.get("enumerations")
         primary_key_col_header = header_map.get("primary_key")
         foreign_key_col_header = header_map.get("foreign_key_target")
-        description_col_header = header_map.get("description")
+        description_col_header = header_map.get("column_description")
         return (
             table_col_header,
             column_col_header,

valediction/integrity.py

@@ -77,20 +77,21 @@ class Config:
             "%d-%m-%Y": DataType.DATE,
             "%m/%d/%Y": DataType.DATE,
             "%m-%d-%Y": DataType.DATE,
-            "%Y-%m-%d %H:%M:%S": DataType.DATETIME,
-            "%Y-%m-%d %H:%M": DataType.DATETIME,
-            "%d/%m/%Y %H:%M:%S": DataType.DATETIME,
-            "%d/%m/%Y %H:%M": DataType.DATETIME,
-            "%m/%d/%Y %H:%M:%S": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%S": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%S.%f": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%S%z": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%S.%f%z": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%SZ": DataType.DATETIME,
-            "%Y-%m-%dT%H:%M:%S.%fZ": DataType.DATETIME,
+            "%Y-%m-%d %H:%M:%S": DataType.TIMESTAMP,
+            "%Y-%m-%d %H:%M": DataType.TIMESTAMP,
+            "%d/%m/%Y %H:%M:%S": DataType.TIMESTAMP,
+            "%d/%m/%Y %H:%M": DataType.TIMESTAMP,
+            "%m/%d/%Y %H:%M:%S": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%S": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%S.%f": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%S%z": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%S.%f%z": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%SZ": DataType.TIMESTAMP,
+            "%Y-%m-%dT%H:%M:%S.%fZ": DataType.TIMESTAMP,
         }
         self.enforce_no_null_columns: bool = True
         self.enforce_primary_keys: bool = True
+        self.allow_bigint: bool = True
         _apply_external_injections(self)
 
     def __repr__(self):
@@ -110,6 +111,7 @@ class Config:
             f" - default_null_values={self.null_values}\n"
             f" - forbidden_characters={self.forbidden_characters}\n"
             f" - date_formats=[{date_list}\n  ]\n"
+            f" - allow_bigint={self.allow_bigint}\n"
             ")"
         )
 

valediction/validation/helpers.py

@@ -241,7 +241,7 @@ def invalid_mask_datetime(column: Series, fmt: str | None) -> Series:
         ok = parsed.notna()
         return notnull & (~ok)
 
-    allowed = _allowed_formats_for(DataType.DATETIME)
+    allowed = _allowed_formats_for(DataType.TIMESTAMP)
     ok_any = _parse_ok_any(column, allowed)
     return notnull & (~ok_any)
 
@@ -300,7 +300,7 @@ def apply_data_types(df: DataFrame, table_dictionary: Table) -> DataFrame:
             )
             df[col] = dtv.dt.normalize()  # midnight
 
-        elif data_type == DataType.DATETIME:
+        elif data_type == DataType.TIMESTAMP:
             df[col] = to_datetime(
                 df[col], format=datetime_format, errors="raise", utc=False
             )
@@ -310,3 +310,62 @@ def apply_data_types(df: DataFrame, table_dictionary: Table) -> DataFrame:
             df[col] = df[col].astype("string")
 
     return df
+
+
+# Bigint Checks
+_PG_INT4_MIN_STR_ABS = "2147483648"  # abs(-2147483648)
+_PG_INT4_MAX_STR_ABS = "2147483647"
+_PG_INT4_MIN_LEN = len(_PG_INT4_MIN_STR_ABS)
+_PG_INT4_MAX_LEN = len(_PG_INT4_MAX_STR_ABS)
+
+
+def invalid_mask_integer_out_of_range(
+    series: Series,
+    invalid_integer_mask: Series | None = None,
+) -> Series:
+    """
+    Returns a boolean mask for values that:
+      - are integer-like under Valediction's integer rules, AND
+      - fall outside PostgreSQL INTEGER (int4) range.
+    """
+
+    # Start with all-False mask
+    out = series.isna() & False
+
+    # Use caller-provided invalid mask to avoid recomputing if available
+    if invalid_integer_mask is None:
+        from valediction.validation.helpers import invalid_mask_integer  # avoid cycles
+
+        invalid_integer_mask = invalid_mask_integer(series)
+
+    # We only check range for values that already pass integer validation
+    valid = (~invalid_integer_mask) & series.notna()
+    if not valid.any():
+        return out
+
+    # String-normalise for safe compare (works for object/int dtype)
+    s = series[valid].astype("string", copy=False).str.strip()
+
+    # Sign handling
+    neg = s.str.startswith("-")
+    abs_str = s.str.lstrip("+-")
+
+    # Lengths
+    abs_len = abs_str.str.len()
+
+    # Positive overflow:
+    #   abs_len > 10 OR (abs_len == 10 AND abs_str > 2147483647)
+    pos = ~neg
+    pos_over = (abs_len > _PG_INT4_MAX_LEN) | (
+        (abs_len == _PG_INT4_MAX_LEN) & (abs_str > _PG_INT4_MAX_STR_ABS)
+    )
+
+    # Negative overflow (too small):
+    #   abs_len > 10 OR (abs_len == 10 AND abs_str > 2147483648)
+    neg_over = (abs_len > _PG_INT4_MIN_LEN) | (
+        (abs_len == _PG_INT4_MIN_LEN) & (abs_str > _PG_INT4_MIN_STR_ABS)
+    )
+
+    # Combine back into the full index
+    out.loc[valid] = (pos & pos_over) | (neg & neg_over)
+    return out

valediction/validation/issues.py

@@ -26,6 +26,7 @@ class IssueType(Enum):
     TYPE_MISMATCH = "TypeMismatch"
     TEXT_TOO_LONG = "TextTooLong"
     FORBIDDEN_CHARACTER = "ForbiddenCharacter"
+    INTEGER_OUT_OF_RANGE = "IntegerOutOfRange"
 
 
 # Settings

valediction/validation/validation.py

@@ -14,6 +14,7 @@ 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,
@@ -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,
@@ -151,7 +153,7 @@ 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:
@@ -298,12 +300,7 @@ class Validator:
         if missing_keys:
             for name in dict_names:
                 if _normalise(name) in missing_keys:
-                    self.issues.add(
-                        issue_type=IssueType.MISSING_COLUMN,
-                        table=self.table_name,
-                        column=name,
-                        parent=self.dataset_item,
-                    )
+                    self._save_issues(IssueType.MISSING_COLUMN, name)
 
         self.__complete_step()
 
@@ -320,12 +317,7 @@ class Validator:
         if extra_keys:
             for col in df_cols:
                 if _normalise(col) in extra_keys:
-                    self.issues.add(
-                        issue_type=IssueType.EXTRA_COLUMN,
-                        table=self.table_name,
-                        column=col,  # report the actual df label
-                        parent=self.dataset_item,
-                    )
+                    self._save_issues(IssueType.EXTRA_COLUMN, col)
 
         self.__complete_step()
 
@@ -363,13 +355,7 @@ class Validator:
             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:
@@ -391,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
@@ -427,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
@@ -453,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))
@@ -515,11 +487,50 @@ class Validator:
 
         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 _normalise(str(col)) in self._column_names
         ]
+        config = get_config()
         for col in present:
             dtype = self._find_data_type(col)
             if dtype == DataType.TEXT:
@@ -527,26 +538,24 @@ 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:
@@ -560,13 +569,7 @@ class Validator:
             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:
@@ -579,13 +582,7 @@ class Validator:
                 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
@@ -593,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.2.0.dist-info → valediction-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: valediction
-Version: 1.2.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.2.0.dist-info → valediction-1.5.0.dist-info}/RECORD

@@ -1,38 +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=2x1xpz1J3dmXCPRSGHPpnbLEvdlJDUuQ9B1y0baZ-mk,5151
+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=iqcpSPBoFZybkTMHBmxrlv56ZRg8PbqSLtVsuJXC2G0,2282
-valediction/data_types/data_types.py,sha256=MJv_io_hvbLo0G0N38kwj71goXlAo0isPFyS3TU05II,1605
-valediction/data_types/type_inference.py,sha256=11SGYgpvfAfwrDwyOewVIwvfA6pQtDo6i94_xfebYM8,19952
+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=wj1JG8dHgdALVwV0zSSYnyWMomMTzrHxGFRm491wM_A,45308
+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=OQcmKpKuRmLQuidYr2KIVF3_78crki5HU8E6RuFm01s,4410
+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=CsmQcW6joFGQe-PkhzOXj0uv97hiq7rN3kZKliqox9A,12305
-valediction/dictionary/helpers.py,sha256=DtEbtn__CSs9LWi0oVZD3DtZonRjHeoQA9de-xQ1z3I,5288
-valediction/dictionary/importing.py,sha256=PbE5gLv-y29MAl540ClBCzoTGT8U4Ss0xbzG_GJOpzo,19557
+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=ZsWmJsSBHvh3ADfrntmeVMWI9Vp_q7zqrTgp7rGd-AI,41721
+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=rJl_t0XCwt_X3LZAEz5pMihsAKoAIn-qkANNcm4lLf0,10195
-valediction/validation/issues.py,sha256=fBeGjbGGmwGg5XfENU4FtsYhvFfwdqAFSYGNF3UBEI8,9327
-valediction/validation/validation.py,sha256=XgYnRslQTCZCpAHi_AYUkZw4mXM7yjwBw6-iYJXhcao,22961
-valediction-1.2.0.dist-info/METADATA,sha256=vDocxg062EAic20YXBd3rQmfk95hkybDdnpLDQvV0W0,612
-valediction-1.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-valediction-1.2.0.dist-info/RECORD,,
+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,,