diff --git a/docs/user-guide/input-data.rst b/docs/user-guide/input-data.rst
index c5f2afabb..40e679bf5 100644
--- a/docs/user-guide/input-data.rst
+++ b/docs/user-guide/input-data.rst
@@ -77,8 +77,8 @@ Here we walk the file system, load all phenopacket JSON files, and transform the
   ...       pp_path = os.path.join(dirpath, filename)
   ...       with open(pp_path) as fh:
   ...         pp = Parse(fh.read(), Phenopacket())
-  ...       patient = patient_creator.create_patient(pp)
-  ...       patients.append(patient)
+  ...       output = patient_creator.process(pp)
+  ...       patients.append(output.outcome)
 
 
   >>> f'Loaded {len(patients)} phenopackets'
diff --git a/src/genophenocorr/data/_toy.py b/src/genophenocorr/data/_toy.py
index 7a918c1a4..76c90e35a 100644
--- a/src/genophenocorr/data/_toy.py
+++ b/src/genophenocorr/data/_toy.py
@@ -77,132 +77,132 @@ def get_toy_cohort() -> Cohort:
         Genotypes.empty())  # Not used in the patients below, hence `empty()`.
 
     patients = (
-        Patient('A',
+        Patient(SampleLabels('A'),
                 phenotypes=(arachnodactyly_T, spasticity_F, seizure_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('B',
+        Patient(SampleLabels('B'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('C',
+        Patient(SampleLabels('C'),
                 phenotypes=(arachnodactyly_F, spasticity_T, seizure_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('D',
+        Patient(SampleLabels('D'),
                 phenotypes=(arachnodactyly_T, spasticity_T, seizure_T),
                 variants=[snv, deletion],
                 proteins=[prot]
                 ),
-        Patient('E',
+        Patient(SampleLabels('E'),
                 phenotypes=(arachnodactyly_T, spasticity_T, seizure_F),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('F',
+        Patient(SampleLabels('F'),
                 phenotypes=(arachnodactyly_F, spasticity_F, seizure_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('G',
+        Patient(SampleLabels('G'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_T),
                 variants=[snv, deletion],
                 proteins=[prot]
                 ),
-        Patient('H',
+        Patient(SampleLabels('H'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_F),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('I',
+        Patient(SampleLabels('I'),
                 phenotypes=(arachnodactyly_F, spasticity_F, seizure_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('J',
+        Patient(SampleLabels('J'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('K',
+        Patient(SampleLabels('K'),
                 phenotypes=(arachnodactyly_F, spasticity_T, seizure_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('L',
+        Patient(SampleLabels('L'),
                 phenotypes=(arachnodactyly_F, seizure_F, spasticity_F),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('M',
+        Patient(SampleLabels('M'),
                 phenotypes=(arachnodactyly_T, seizure_F, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('N',
+        Patient(SampleLabels('N'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_F),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('O',
+        Patient(SampleLabels('O'),
                 phenotypes=(arachnodactyly_F, seizure_F, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('P',
+        Patient(SampleLabels('P'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_F),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('Q',
+        Patient(SampleLabels('Q'),
                 phenotypes=(arachnodactyly_T, seizure_F, spasticity_F),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('R',
+        Patient(SampleLabels('R'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_F),
                 variants=[snv, deletion],
                 proteins=[prot]
                 ),
-        Patient('S',
+        Patient(SampleLabels('S'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('T',
+        Patient(SampleLabels('T'),
                 phenotypes=(arachnodactyly_T, seizure_F, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('U',
+        Patient(SampleLabels('U'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('V',
+        Patient(SampleLabels('V'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('W',
+        Patient(SampleLabels('W'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('X',
+        Patient(SampleLabels('X'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
                 ),
-        Patient('Y',
+        Patient(SampleLabels('Y'),
                 phenotypes=(arachnodactyly_T, seizure_T, spasticity_T),
                 variants=[snv],
                 proteins=[prot]
                 ),
-        Patient('Z',
+        Patient(SampleLabels('Z'),
                 phenotypes=(arachnodactyly_F, seizure_T, spasticity_T),
                 variants=[deletion],
                 proteins=[prot]
diff --git a/src/genophenocorr/model/__init__.py b/src/genophenocorr/model/__init__.py
index 6144a9423..c6c2568ab 100644
--- a/src/genophenocorr/model/__init__.py
+++ b/src/genophenocorr/model/__init__.py
@@ -4,7 +4,7 @@
 and protein info.
 """
 from . import genome
-
+from ._base import SampleLabels
 from ._cohort import Cohort, Patient
 from ._gt import Genotype, Genotypes, Genotyped
 from ._phenotype import Phenotype
@@ -14,7 +14,7 @@
 from ._variant_effects import VariantEffect
 
 __all__ = [
-    'Cohort', 'Patient',
+    'Cohort', 'Patient', 'SampleLabels',
     'Phenotype',
     'Variant', 'VariantCoordinates', 'Genotype', 'Genotypes', 'Genotyped',
     'TranscriptAnnotation', 'VariantEffect', 'TranscriptInfoAware', 'TranscriptCoordinates',
diff --git a/src/genophenocorr/model/_base.py b/src/genophenocorr/model/_base.py
new file mode 100644
index 000000000..36716831e
--- /dev/null
+++ b/src/genophenocorr/model/_base.py
@@ -0,0 +1,60 @@
+import typing
+
+import hpotk
+
+
+class SampleLabels:
+    """
+    A data model for subject identifiers.
+
+    The subject has a mandatory :attr:`label` and an optional :attr:`meta_label`.
+
+    The identifiers support natural ordering, equality tests, and are hashable.
+    """
+
+    def __init__(self, label: str,
+                 meta_label: typing.Optional[str] = None):
+        self._label = hpotk.util.validate_instance(label, str, 'label')
+        self._meta_label = hpotk.util.validate_optional_instance(meta_label, str, 'meta_label')
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def meta_label(self) -> typing.Optional[str]:
+        return self._meta_label
+
+    def label_summary(self) -> str:
+        """
+        Summarize `label` and `meta_label` into a `str` where the sub-parts are inserted as ``<label>[<meta_label>]``.
+        """
+        return self._label if self._meta_label is None else f'{self._label}[{self._meta_label}]'
+
+    def __eq__(self, other):
+        return isinstance(other, SampleLabels) and self._label == other.label and self._meta_label == other._meta_label
+
+    def __lt__(self, other):
+        if isinstance(other, SampleLabels):
+            if self._label < other._label:
+                return True
+            elif self._label == other._label:
+                if self._meta_label is None or other._meta_label is None:
+                    if self._meta_label == other._meta_label:
+                        return False
+                    else:
+                        return True if self._meta_label is None else False  # `None` is less
+                else:
+                    return self._meta_label < other._meta_label
+            return False
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        return hash((self._label, self._meta_label))
+
+    def __str__(self):
+        return self.label_summary()
+
+    def __repr__(self):
+        return f'SampleLabels(label={self._label}, meta_label={self._meta_label})'
diff --git a/src/genophenocorr/model/_cohort.py b/src/genophenocorr/model/_cohort.py
index 6dfb6fff9..6678f9b2d 100644
--- a/src/genophenocorr/model/_cohort.py
+++ b/src/genophenocorr/model/_cohort.py
@@ -1,6 +1,7 @@
 import typing
 from collections import Counter
 
+from ._base import SampleLabels
 from ._phenotype import Phenotype
 from ._protein import ProteinMetadata
 from ._variant import Variant
@@ -10,25 +11,25 @@ class Patient:
     """A class that represents an individual patient
 
     Attributes:
-        patient_id (string): A string unique to this Patient object
+        patient_id (SampleLabels): The patient identifiers
         phenotypes (Sequence[Phenotype]): A list of Phenotype objects
         variants (Sequence[Variant]): A list of Variant objects
         proteins (Sequence[ProteinMetadata]): A list of ProteinMetadata objects
     """
 
-    def __init__(self, patient_id: str,
+    def __init__(self, labels: SampleLabels,
                  phenotypes: typing.Iterable[Phenotype],
                  variants: typing.Iterable[Variant],
                  proteins: typing.Iterable[ProteinMetadata]):
         """Constructs all necessary attributes for a Patient object
 
         Args:
-            patient_id (string): A string unique to this Patient object
+            labels (string): A string unique to this Patient object
             phenotypes (Iterable[Phenotype]): A list of Phenotype objects
             variants (Iterable[Variant]): A list of Variant objects
             proteins (Iterable[ProteinMetadata]): A list of ProteinMetadata objects
         """
-        self._id = patient_id
+        self._labels = labels
         self._phenotypes = tuple(phenotypes)
         self._variants = tuple(variants)
         self._proteins = tuple(proteins)
@@ -39,7 +40,14 @@ def patient_id(self) -> str:
         Returns:
             string: Patient ID unique to this Patient object
         """
-        return self._id
+        return self._labels.label_summary()
+
+    @property
+    def labels(self) -> SampleLabels:
+        """
+        Get the sample identifiers.
+        """
+        return self._labels
 
     @property
     def phenotypes(self) -> typing.Sequence[Phenotype]:
@@ -79,7 +87,7 @@ def excluded_phenotypes(self) -> typing.Iterator[Phenotype]:
 
     def __str__(self) -> str:
         return (f"Patient("
-                f"patient_id:{self.patient_id}, "
+                f"labels:{self._labels}, "
                 f"variants:{self.variants}, "
                 f"phenotypes:{[pheno.identifier for pheno in self.phenotypes]}, "
                 f"proteins:{[prot.protein_id for prot in self.proteins]})")
diff --git a/src/genophenocorr/model/_gt.py b/src/genophenocorr/model/_gt.py
index dd9159d92..9d73523a2 100644
--- a/src/genophenocorr/model/_gt.py
+++ b/src/genophenocorr/model/_gt.py
@@ -6,6 +6,8 @@
 
 import numpy as np
 
+from ._base import SampleLabels
+
 
 class Genotype(enum.Enum):
     """
@@ -35,8 +37,10 @@ class Genotypes(typing.Sized, typing.Iterable):
 
     Use one of the static methods to create an instance:
 
-    >>> gts = Genotypes.single('A', Genotype.HETEROZYGOUS)
-    >>> gts = Genotypes.from_mapping({'A': Genotype.HETEROZYGOUS, 'B': Genotype.HOMOZYGOUS_ALTERNATE})
+    >>> a = SampleLabels('A')
+    >>> b = SampleLabels('B')
+    >>> gts = Genotypes.single(a, Genotype.HETEROZYGOUS)
+    >>> _ = Genotypes.from_mapping({a: Genotype.HETEROZYGOUS, b: Genotype.HOMOZYGOUS_ALTERNATE})
 
     There are 2 genotypes in the container:
 
@@ -45,12 +49,12 @@ class Genotypes(typing.Sized, typing.Iterable):
 
     You can get a genotype for a sample ID:
 
-    >>> gts.for_sample('A')
+    >>> gts.for_sample(a)
     Genotype.HETEROZYGOUS
 
     You will get `None` if the sample is not present:
 
-    >>> gts.for_sample('UNKNOWN')
+    >>> gts.for_sample(SampleLabels('UNKNOWN'))
     None
 
     You can iterate over sample-genotype pairs:
@@ -66,24 +70,27 @@ def empty():
         return EMPTY
 
     @staticmethod
-    def single(sample_id: str, genotype: Genotype):
+    def single(sample_id: SampleLabels, genotype: Genotype):
         """
         A shortcut for creating `Genotypes` for a single sample:
 
-        >>> gts = Genotypes.single('A', Genotype.HOMOZYGOUS_ALTERNATE)
+        >>> a = SampleLabels('A')
+        >>> gts = Genotypes.single(a, Genotype.HOMOZYGOUS_ALTERNATE)
 
         >>> assert len(gts) == 1
-        >>> assert gts.for_sample('A') == Genotype.HOMOZYGOUS_ALTERNATE
+        >>> assert gts.for_sample(a) == Genotype.HOMOZYGOUS_ALTERNATE
         """
 
         return Genotypes((sample_id,), (genotype,))
 
     @staticmethod
-    def from_mapping(mapping: typing.Mapping[str, Genotype]):
+    def from_mapping(mapping: typing.Mapping[SampleLabels, Genotype]):
         """
         Create `Genotypes` from mapping between sample IDs and genotypes.
 
-        >>> gts = Genotypes.from_mapping({'A': Genotype.HETEROZYGOUS, 'B': Genotype.HOMOZYGOUS_ALTERNATE})
+        >>> a = SampleLabels('A')
+        >>> b = SampleLabels('B')
+        >>> gts = Genotypes.from_mapping({a: Genotype.HETEROZYGOUS, b: Genotype.HOMOZYGOUS_ALTERNATE})
 
         >>> assert len(gts) == 2
         """
@@ -91,7 +98,7 @@ def from_mapping(mapping: typing.Mapping[str, Genotype]):
         return Genotypes(*Genotypes._preprocess_mapping(mapping))
 
     @staticmethod
-    def _preprocess_mapping(genotypes: typing.Mapping[str, Genotype]) -> typing.Tuple[typing.Sequence[str], typing.Sequence[Genotype]]:
+    def _preprocess_mapping(genotypes: typing.Mapping[SampleLabels, Genotype]) -> typing.Tuple[typing.Sequence[str], typing.Sequence[Genotype]]:
         samples = np.empty(shape=(len(genotypes),), dtype=object)
         gts = np.empty(shape=(len(genotypes),), dtype=object)
 
@@ -103,17 +110,17 @@ def _preprocess_mapping(genotypes: typing.Mapping[str, Genotype]) -> typing.Tupl
 
         return samples[indices], gts[indices]
 
-    def __init__(self, samples: typing.Iterable[str], genotypes: typing.Iterable[Genotype]):
+    def __init__(self, samples: typing.Iterable[SampleLabels], genotypes: typing.Iterable[Genotype]):
         self._samples = tuple(samples)
         self._gts = tuple(genotypes)
         if len(self._samples) != len(self._gts):
             raise ValueError(f'Mismatch between the sample and genotype count: {len(self._samples)} != {len(self._gts)}')
 
-    def for_sample(self, sample_id: str) -> typing.Optional[Genotype]:
+    def for_sample(self, sample_id: SampleLabels) -> typing.Optional[Genotype]:
         """
         Get a genotype for a sample or `None` if the genotype is not present.
 
-        :param sample_id: a `str` with sample's identifier.
+        :param sample_id: a :class:`SampleLabels` with sample's identifier.
         """
         idx = bisect.bisect_left(self._samples, sample_id)
         if idx != len(self._samples) and self._samples[idx] == sample_id:
@@ -123,7 +130,7 @@ def for_sample(self, sample_id: str) -> typing.Optional[Genotype]:
     def __len__(self) -> int:
         return len(self._samples)
 
-    def __iter__(self) -> Iterator[typing.Tuple[str, Genotype]]:
+    def __iter__(self) -> Iterator[typing.Tuple[SampleLabels, Genotype]]:
         return zip(self._samples, self._gts)
 
     def __hash__(self):
@@ -154,10 +161,10 @@ class Genotyped(metaclass=abc.ABCMeta):
     def genotypes(self) -> Genotypes:
         pass
 
-    def genotype_for_sample(self, sample_id: str) -> typing.Optional[Genotype]:
+    def genotype_for_sample(self, sample_id: SampleLabels) -> typing.Optional[Genotype]:
         """
         Get a genotype for a sample or `None` if the genotype is not present.
 
-        :param sample_id: a `str` with sample's identifier.
+        :param sample_id: a :class:`SampleLabels` with sample's identifier.
         """
         return self.genotypes.for_sample(sample_id)
diff --git a/src/genophenocorr/preprocessing/_api.py b/src/genophenocorr/preprocessing/_api.py
index 36cc4cb7b..56faf3456 100644
--- a/src/genophenocorr/preprocessing/_api.py
+++ b/src/genophenocorr/preprocessing/_api.py
@@ -12,6 +12,9 @@ class VariantCoordinateFinder(typing.Generic[T], metaclass=abc.ABCMeta):
     def find_coordinates(self, item: T) -> typing.Tuple[VariantCoordinates, Genotype]:
         """
         Determine :class:`VariantCoordinates` and :class:`Genotype` from an `item` of some sort.
+
+        Raises:
+            ValueError: if there is an error of any kind.
         """
         pass
 
@@ -20,6 +23,13 @@ class FunctionalAnnotator(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def annotate(self, variant_coordinates: VariantCoordinates) -> typing.Sequence[TranscriptAnnotation]:
+        """
+        Compute functional annotations for the variant coordinates. The annotations can be empty.
+
+        Returns: a sequence of transcript annotations
+        Raises:
+            ValueError if the annotation cannot proceed due to the remote resource being offline, etc.
+        """
         pass
 
 
diff --git a/src/genophenocorr/preprocessing/_audit.py b/src/genophenocorr/preprocessing/_audit.py
new file mode 100644
index 000000000..67f9c6258
--- /dev/null
+++ b/src/genophenocorr/preprocessing/_audit.py
@@ -0,0 +1,90 @@
+import abc
+import enum
+import typing
+
+
+class Level(enum.Enum):
+    """
+    An enum to represent severity of the :class:`DataSanityIssue`.
+    """
+
+    WARN = enum.auto()
+    """
+    Warning is an issue when something not entirely right. However, unlike :class:`Level.ERROR`, the analysis should
+    complete albeit with sub-optimal results 😧.
+    """
+
+    ERROR = enum.auto()
+    """
+    Error is a serious issue in the input data and the downstream analysis may not complete or the analysis results
+    may be malarkey 😱.
+    """
+
+
+class DataSanityIssue:
+    """
+    `DataSanityIssue` summarizes an issue found in the input data.
+
+    The issue has a `level`, a `message` with human-friendly description, and the proposed `solution`
+    for removing the issue.
+    """
+
+    def __init__(self, level, message, solution):
+        self._level = level
+        self._message = message
+        self._solution = solution
+
+    @property
+    def level(self) -> Level:
+        return self._level
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def solution(self) -> str:
+        return self._solution
+
+
+IN = typing.TypeVar('IN')
+"""
+:class:`Auditor` input.
+"""
+
+OUT = typing.TypeVar('OUT')
+"""
+:class:`Auditor` output format.
+"""
+
+
+class AuditReport(typing.Generic[OUT]):
+    """
+    `AuditReport` includes the issues found by :class:`Auditor` and the outcome of the sanitation.
+    """
+
+    def __init__(self, outcome: OUT,
+                 issues: typing.Iterable[DataSanityIssue]):
+        self._outcome = outcome
+        self._issues = tuple(issues)
+
+    @property
+    def outcome(self) -> OUT:
+        return self._outcome
+
+    @property
+    def issues(self) -> typing.Sequence[DataSanityIssue]:
+        return self._issues
+
+
+class Auditor(typing.Generic[IN, OUT], metaclass=abc.ABCMeta):
+    """
+    `Auditor` checks the inputs for sanity issues and relates the issues with sanitized inputs
+    as :class:`SanitationResults`.
+
+    The input sanitation is optional so getting unsanitized input is permitted.
+    """
+
+    @abc.abstractmethod
+    def process(self, inputs: IN) -> AuditReport[OUT]:
+        pass
diff --git a/src/genophenocorr/preprocessing/_config.py b/src/genophenocorr/preprocessing/_config.py
index 1c90cd05d..474cc7127 100644
--- a/src/genophenocorr/preprocessing/_config.py
+++ b/src/genophenocorr/preprocessing/_config.py
@@ -51,8 +51,13 @@ def configure_patient_creator(hpo: hpotk.MinimalOntology,
                               genome_build: str = 'GRCh38.p13',
                               validation_runner: typing.Optional[hpotk.validate.ValidationRunner] = None,
                               variant_fallback: str = 'VEP',
-                              protein_fallback: str = 'UNIPROT') -> PhenopacketPatientCreator:
+                              protein_fallback: str = 'UNIPROT',
+                              validation: str = 'lenient') -> PhenopacketPatientCreator: #Rename to something more understandable by user
     """
+                                ^^^ none, lenient, strict - 
+                                none = run unless unrunnable
+                                lenient = fix what we can, abort unfixable
+                                strict = abort at any issue
     A convenience function for configuring a non-caching :class:`genophenocorr.preprocessing.PhenopacketPatientCreator`.
 
     To create the patient creator, we need hpo-toolkit's representation of HPO. Other options are optional
diff --git a/src/genophenocorr/preprocessing/_patient.py b/src/genophenocorr/preprocessing/_patient.py
index 58eae22a6..8c8689b94 100644
--- a/src/genophenocorr/preprocessing/_patient.py
+++ b/src/genophenocorr/preprocessing/_patient.py
@@ -4,24 +4,16 @@
 
 from genophenocorr.model import Patient
 
+from ._audit import Auditor
 
-T = typing.TypeVar('T')
 
+T = typing.TypeVar('T')
 
-class PatientCreator(typing.Generic[T], metaclass=abc.ABCMeta):
-    """A metaclass that can be used to establish a class that creates a Patient object 
 
-    Methods:
-        create_patient(item:Generic): Creates a Patient from the data in a given item
+class PatientCreator(typing.Generic[T], Auditor[T, Patient], metaclass=abc.ABCMeta):
     """
+    `PatientCreator` can create a `Patient` from some input `T`.
 
-    @abc.abstractmethod
-    def create_patient(self, item: T) -> Patient:
-        """Creates a Patient from the data in a given item
-
-        Args:
-            item (Generic[T]): An object with subject data
-        Returns:
-            Patient: A Patient object
-        """
-        pass
\ No newline at end of file
+    `PatientCreator` is an `Auditor`, hence the input is sanitized and any errors are reported to the caller.
+    """
+    pass
diff --git a/src/genophenocorr/preprocessing/_phenopacket.py b/src/genophenocorr/preprocessing/_phenopacket.py
index 57ca2de7a..7b3c08b48 100644
--- a/src/genophenocorr/preprocessing/_phenopacket.py
+++ b/src/genophenocorr/preprocessing/_phenopacket.py
@@ -1,6 +1,7 @@
 import logging
 import os
 import typing
+import re
 
 import hpotk
 
@@ -9,14 +10,13 @@
 from phenopackets import GenomicInterpretation, Phenopacket
 from tqdm import tqdm
 
+from genophenocorr.model import Patient, Cohort, SampleLabels
 from genophenocorr.model import Phenotype, ProteinMetadata, VariantCoordinates, Variant, Genotype, Genotypes
-from genophenocorr.model import Patient, Cohort
 from genophenocorr.model.genome import GenomeBuild, GenomicRegion, Strand
-
+from ._api import VariantCoordinateFinder, FunctionalAnnotator
+from ._audit import AuditReport, DataSanityIssue, Level
 from ._patient import PatientCreator
 from ._phenotype import PhenotypeCreator
-from ._api import VariantCoordinateFinder, FunctionalAnnotator
-
 
 
 class PhenopacketVariantCoordinateFinder(VariantCoordinateFinder[GenomicInterpretation]):
@@ -27,6 +27,7 @@ class PhenopacketVariantCoordinateFinder(VariantCoordinateFinder[GenomicInterpre
     :param build: genome build to use in `VariantCoordinates
     :param hgvs_coordinate_finder: the coordinate finder to use for parsing HGVS expressions
     """
+
     def __init__(self, build: GenomeBuild,
                  hgvs_coordinate_finder: VariantCoordinateFinder[str]):
         self._logger = logging.getLogger(__name__)
@@ -50,6 +51,9 @@ def find_coordinates(self, item: GenomicInterpretation) -> typing.Tuple[VariantC
         vc = None
         if self._vcf_is_available(variant_descriptor.vcf_record):
             # We have a VCF record.
+            if not self._check_assembly(variant_descriptor.vcf_record.genome_assembly):
+                raise ValueError(f"Variant id {variant_descriptor.id} for patient {item.subject_or_biosample_id} has a different Genome Assembly than what was given. " \
+                                 + f"{variant_descriptor.vcf_record.genome_assembly} is not {self._build.identifier}.")
             contig = self._build.contig_by_name(variant_descriptor.vcf_record.chrom)
             start = int(variant_descriptor.vcf_record.pos) - 1
             ref = variant_descriptor.vcf_record.ref
@@ -86,6 +90,8 @@ def find_coordinates(self, item: GenomicInterpretation) -> typing.Tuple[VariantC
                 if expression.syntax == 'hgvs.c':
                     vc = self._hgvs_finder.find_coordinates(expression.value)
                     break
+        else:
+            raise ValueError("Unable to find variant coordinates.")
 
         # Last, parse genotype.
         genotype = variant_descriptor.allelic_state.label
@@ -93,6 +99,15 @@ def find_coordinates(self, item: GenomicInterpretation) -> typing.Tuple[VariantC
 
         return vc, gt
 
+    def _check_assembly(self, genome_assembly: str) -> bool:
+        if '38' in genome_assembly and self._build.identifier == 'GRCh38.p13':
+            return True
+        elif ('37' in genome_assembly or '19' in genome_assembly) and self._build.identifier == 'GRCh37.p13':
+            return True
+        else:
+            return False
+
+
     @staticmethod
     def _vcf_is_available(vcf_record) -> bool:
         """
@@ -142,36 +157,32 @@ def __init__(self, build: GenomeBuild,
         self._phenotype_creator = hpotk.util.validate_instance(phenotype_creator, PhenotypeCreator, 'phenotype_creator')
         self._func_ann = hpotk.util.validate_instance(var_func_ann, FunctionalAnnotator, 'var_func_ann')
 
-    def create_patient(self, item: Phenopacket) -> Patient:
+    def process(self, inputs: Phenopacket) -> AuditReport[Patient]:
         """Creates a Patient from the data in a given Phenopacket
 
         Args:
-            item (Phenopacket): A Phenopacket object
+            inputs (Phenopacket): A Phenopacket object
         Returns:
             Patient: A Patient object
         """
-        sample_id = self._extract_id(item)
-        phenotypes = self._add_phenotypes(item)
-        if len(phenotypes) == 0:
-            self._logger.warning('Patient %s has no phenotypes listed and will not be included in this analysis.', sample_id)
-            return None
-        variants = self._add_variants(sample_id, item)
-        if len(variants) == 0:
-            self._logger.warning('Patient %s has no variants listed and will not be included in this analysis.', sample_id)
-            return None
-        protein_data = self._add_protein_data(variants)
-        return Patient(item.id, phenotypes, variants, protein_data)
+        sample_id = SampleLabels(label=inputs.subject.id, meta_label=inputs.id if len(inputs.id) > 0 else None)
 
-    @staticmethod
-    def _extract_id(pp: Phenopacket):
-        subject = pp.subject
-        if len(subject.id) > 0:
-            return subject.id
-        else:
-            return pp.id
+        # Validation - relay the errors found by `PhenotypeCreator`
+        # we report issues in any case
+        phenotypes = self._add_phenotypes(inputs)
+
+        # Validate
+        #  - there is >=1 variant in the subject
+        #    - mitigate: skip, warning
+        variants = self._add_variants(sample_id, inputs)
 
+        # TODO: clean up when the protein metadata are removed from the patient.
+        issues = []
 
-    def _add_variants(self, sample_id: str, pp: Phenopacket) -> typing.Sequence[Variant]:
+        patient = Patient(sample_id, phenotypes=phenotypes.outcome, variants=variants.outcome, proteins=())
+        return AuditReport(patient, issues)
+
+    def _add_variants(self, sample_id: SampleLabels, pp: Phenopacket) -> AuditReport[typing.Sequence[Variant]]:
         """Creates a list of Variant objects from the data in a given Phenopacket
 
         Args:
@@ -179,30 +190,46 @@ def _add_variants(self, sample_id: str, pp: Phenopacket) -> typing.Sequence[Vari
         Returns:
             Sequence[Variant]: A list of Variant objects
         """
-        variants_list = []
+        # Variant validation:
+        #
+        #  - for each variant:
+        #    - genomic interpretation must be a VCF record or a VRS CNV or an HGVS expression
+        #      - mitigate: skip, warning
+        #    - Lauren check the `vc.alt == 'N'` if it ever happens. I think we should not care if we do not have this
+        #      in our phenopackets. Maybe a regex check.
+        #    - there is at least 1 tx annotation. This can happen, since the `FunctionalAnnotator` is allowed to return
+        #      an empty sequence. This has pros and cons, but I judge that it is better to give the annotator some wiggle
+        #      room than to be really really really strict.
+        #      - mitigate: ADD the variant but emit a warning. We can still use the variant in the `VariantPredicate`
+        variants = []
+        issues = []
         for i, interp in enumerate(pp.interpretations):
             for genomic_interp in interp.diagnosis.genomic_interpretations:
-                vc, gt = self._coord_finder.find_coordinates(genomic_interp)
-                if vc == None:
-                    self._logger.warning('Expected a VCF record, a VRS CNV, or an expression with `hgvs.c` '
-                             'but did not find one in patient %s', pp.id)
+                try:
+                    vc, gt = self._coord_finder.find_coordinates(genomic_interp)
+                except ValueError:
+                    issues.append(DataSanityIssue(Level.WARN, f"Expected a VCF record, a VRS CNV, or an expression with `hgvs.c` but had an error retrieving any from patient {sample_id}.",
+                                                  "Remove variant from testing."))
                     continue
-                if "N" in vc.alt:
-                    self._logger.warning('Patient %s has unknown alternative variant %s, this variant will not be included.', pp.id, vc.variant_key)
+
+                try:
+                    tx_annotations = self._func_ann.annotate(vc)
+                except ValueError:
+                    issues.append(DataSanityIssue(Level.WARN, f"Patient {pp.id} has an error with variant {vc.variant_key}",
+                                                  "Try again or remove variant form testing."))
                     continue
-                tx_annotations = self._func_ann.annotate(vc)
-                if tx_annotations is None:
-                    self._logger.warning("Patient %s has an error with variant %s, this variant will not be included.", pp.id, vc.variant_key)
+
+                if len(tx_annotations) == 0:
+                    issues.append(DataSanityIssue(Level.WARN, f"Patient {pp.id} has an error with variant {vc.variant_key}",
+                                                  "Remove variant from testing."))
                     continue
+
                 genotype = Genotypes.single(sample_id, gt)
-                variant = Variant(vc, tx_annotations, genotype)
-                variants_list.append(variant)
+                variants.append(Variant(vc, tx_annotations, genotype))
 
-        if len(variants_list) == 0:
-            self._logger.warning('Expected at least one variant per patient, but received none for patient %s', pp.id)
-        return variants_list
+        return AuditReport(variants, issues)
 
-    def _add_phenotypes(self, pp: Phenopacket) -> typing.Sequence[Phenotype]:
+    def _add_phenotypes(self, pp: Phenopacket) -> AuditReport[typing.Sequence[Phenotype]]:
         """Creates a list of Phenotype objects from the data in a given Phenopacket
 
         Args:
@@ -213,10 +240,8 @@ def _add_phenotypes(self, pp: Phenopacket) -> typing.Sequence[Phenotype]:
         hpo_id_list = []
         for hpo_id in pp.phenotypic_features:
             hpo_id_list.append((hpo_id.type.id, not hpo_id.excluded))
-        if len(hpo_id_list) == 0:
-            self._logger.warning(f'Expected at least one HPO term per patient, but received none for patient {pp.id}')
-            return []
-        return self._phenotype_creator.create_phenotype(hpo_id_list)
+
+        return self._phenotype_creator.process(hpo_id_list)
 
     def _add_protein_data(self, variants: typing.Sequence[Variant]) -> typing.Collection[ProteinMetadata]:
         """Creates a list of ProteinMetadata objects from a given list of Variant objects
@@ -236,6 +261,7 @@ def _add_protein_data(self, variants: typing.Sequence[Variant]) -> typing.Collec
 
 def load_phenopacket_folder(pp_directory: str,
                             patient_creator: PhenopacketPatientCreator,
+                            # policy:str = "strict/lenient/etc",
                             include_patients_with_no_HPO: bool = False) -> Cohort:
     """
     Creates a Patient object for each phenopacket formatted JSON file in the given directory `pp_directory`.
@@ -245,6 +271,7 @@ def load_phenopacket_folder(pp_directory: str,
     :param patient_creator: patient creator for turning a phenopacket into a :class:`genophenocorr.Patient`
     :return: a cohort made of the phenopackets
     """
+    ## NOTE: Strict would stop code at error vs lenient would just print error but continue.
     if not os.path.isdir(pp_directory):
         raise ValueError("Could not find directory of Phenopackets.")
     hpotk.util.validate_instance(patient_creator, PhenopacketPatientCreator, 'patient_creator')
@@ -256,10 +283,13 @@ def load_phenopacket_folder(pp_directory: str,
 
     # turn phenopackets into patients using patient creator
     patients = []
+    issues = []
     for pp in tqdm(pps, desc='Patients Created'):
-        patient = patient_creator.create_patient(pp)
-        if patient is not None:
-            patients.append(patient)
+        audit_report = patient_creator.process(pp)
+        # TODO: handle potential sanity issues and decide about the sample's fate.
+        patients.append(audit_report.outcome)
+        issues.append(audit_report.issues)
+    print(issues)
 
     # create cohort from patients
     return Cohort.from_patients(patients, include_patients_with_no_HPO)
@@ -283,3 +313,4 @@ def load_phenopacket(phenopacket_path: str) -> Phenopacket:
     """
     with open(phenopacket_path) as f:
         return Parse(f.read(), Phenopacket())
+
diff --git a/src/genophenocorr/preprocessing/_phenotype.py b/src/genophenocorr/preprocessing/_phenotype.py
index cb226e54f..c8c97f114 100644
--- a/src/genophenocorr/preprocessing/_phenotype.py
+++ b/src/genophenocorr/preprocessing/_phenotype.py
@@ -4,6 +4,8 @@
 
 from genophenocorr.model import Phenotype
 
+from ._audit import Auditor, AuditReport
+
 
 class PhenotypeValidationException(BaseException):
 
@@ -15,46 +17,80 @@ def issues(self):
         return self._issues
 
 
-class PhenotypeCreator:
-    """A class that creates a Phenotype object 
+class PhenotypeCreator(Auditor[typing.Iterable[typing.Tuple[str, bool]], typing.Sequence[Phenotype]]):
+    """A class that creates a Phenotype object
 
     Methods:
         create_phenotype(term_ids:Iterable[Tuple[str, bool]]): Creates a list of Phenotype objects from a list of tuples.
                                                                Each tuple has the HPO ID and a boolean on if the phenotype is observed.
     """
+
     def __init__(self, hpo: hpotk.MinimalOntology,
                  validator: hpotk.validate.ValidationRunner):
         """Constructs all necessary attributes for a PhenotypeCreator object
 
         Args:
-            hpo (hpotk.ontology.Ontology): An Ontology object 
-            validator (hpotk.validate.ValidationRunner): A ValidationRunner object 
+            hpo (hpotk.ontology.Ontology): An Ontology object
+            validator (hpotk.validate.ValidationRunner): A ValidationRunner object
         """
         self._logger = logging.getLogger(__name__)
         self._hpo = hpotk.util.validate_instance(hpo, hpotk.MinimalOntology, 'hpo')
         self._validator = hpotk.util.validate_instance(validator, hpotk.validate.ValidationRunner, 'validator')
 
-    def create_phenotype(self, term_ids: typing.Iterable[typing.Tuple[str, bool]]) -> typing.Sequence[Phenotype]:
+    def process(self, inputs: typing.Iterable[typing.Tuple[str, bool]]) -> AuditReport[typing.Sequence[Phenotype]]:
         """Creates a list of Phenotype objects from term IDs and checks if the term IDs satisfy the validation requirements.
 
         Args:
-            term_ids (Iterable[Tuple[str, bool]]): A list of Tuples, structured (HPO IDs, boolean- True if observed)
+            inputs (Iterable[Tuple[str, bool]]): A list of Tuples, structured (HPO IDs, boolean- True if observed)
         Returns:
             A sequence of Phenotype objects
         Error:
             PhenotypeValidationException: An instance of an issue with the ValidationRunner
         """
+        # TODO(ielis): implement
+        # Validation:
+        # - `str` is a CURIE compact URI, NCIT_C12345, `HP:0001250`
+        #   - salvage: skip and warn
+        # - CURIE must be an HPO term, so `NCIT_C12345` is not allowed
+        #   - salvage: skip and warn
+        # - term must be in used HPO
+        #   - salvage: skip and warn
+        # - term ID is current and not obsolete
+        #   - salvage: update to primary and warn
+        # - HPO term must be a descendant of Phenotypic abnormality
+        #   - salvage: skip and warn
+        # - HPO terms must be unique
+        #   - salvage: remove the duplicates and warn
+        # - do we have >1 HPO term?
+        #   - salvage: ERROR!
+        # - logical consistency
+        #   - prune the excluded terms
+        #     - the terms do not include an excluded term and its excluded descendant
+        #       - salvage: skip the descendant and warn
+        #     - the terms do not include a present term and its present ancestor
+        #       - salvage: skip the ancestor and warn
+        #     - the terms do not include a present term and its excluded ancestor
+        #       - salvage: cannot save, the user must decide which term is kept
+        issues = ()
         terms = []
-        for term_id, observed in term_ids:
+        ignored_terms = []
+        for term_id, observed in inputs:
             term = self._hpo.get_term(term_id)
             if term is None:
-                self._logger.warning("Term %s cannot be found in HPO version %s. It will be ignored.", term_id, self._hpo.version)
+                self._logger.warning("Term %s cannot be found in HPO version %s. It will be ignored.", term_id,
+                                     self._hpo.version)
+                ignored_terms.append(term_id)
             else:
                 terms.append((term, observed))
-        validation_results = self._validator.validate_all([term[0] for term in terms])
-        if validation_results.is_ok:
-            return tuple(Phenotype.from_term(term, observed) for term, observed in terms)
-        else:
-            # We return the messages for now. We may provide more details in future, if necessary.
-            issues = [r.message for r in validation_results.results]
-            raise PhenotypeValidationException(issues)
+
+
+        # validation_results = self._validator.validate_all([term[0] for term in terms])
+        # if validation_results.is_ok:
+        #
+        #
+        # else:
+        #     # We return the messages for now. We may provide more details in future, if necessary.
+        #     issues = [r.message for r in validation_results.results]
+        #     raise PhenotypeValidationException(issues)
+
+        return AuditReport(tuple(Phenotype.from_term(term, observed) for term, observed in terms), issues)
diff --git a/src/genophenocorr/preprocessing/_test_vep.py b/src/genophenocorr/preprocessing/_test_vep.py
index a0afdf39c..b5b7d7ff4 100644
--- a/src/genophenocorr/preprocessing/_test_vep.py
+++ b/src/genophenocorr/preprocessing/_test_vep.py
@@ -8,7 +8,7 @@
 from genophenocorr.model import VariantCoordinates, VariantEffect
 from genophenocorr.model.genome import GenomicRegion, Strand, GRCh38
 
-from ._vep import verify_start_end_coordinates, VepFunctionalAnnotator
+from ._vep import format_coordinates_for_vep_query, VepFunctionalAnnotator
 
 from ._test_variant import variant_annotator
 
@@ -55,7 +55,7 @@ def test_verify_start_end_coordinates(contig_name, start, end, ref, alt, chlen,
     contig = GRCh38.contig_by_name(contig_name)
     region = GenomicRegion(contig, start, end, Strand.POSITIVE)
     vc = VariantCoordinates(region, ref, alt, chlen)
-    out = verify_start_end_coordinates(vc)
+    out = format_coordinates_for_vep_query(vc)
     assert out == expected
 
 
diff --git a/src/genophenocorr/preprocessing/_vep.py b/src/genophenocorr/preprocessing/_vep.py
index c6960b51b..bcc620242 100644
--- a/src/genophenocorr/preprocessing/_vep.py
+++ b/src/genophenocorr/preprocessing/_vep.py
@@ -8,7 +8,8 @@
 from genophenocorr.model.genome import Region
 from ._api import FunctionalAnnotator, ProteinMetadataService
 
-def verify_start_end_coordinates(vc: VariantCoordinates):
+
+def format_coordinates_for_vep_query(vc: VariantCoordinates) -> str:
     """
     Converts the 0-based VariantCoordinates to ones that will be interpreted
     correctly by VEP
@@ -53,6 +54,7 @@ class VepFunctionalAnnotator(FunctionalAnnotator):
         protein_annotator (ProteinMetadataService): a service for getting protein data
         include_computational_txs (bool): Include computational transcripts, such as
         RefSeq `XM_`.
+        timeout (int): Timeout in seconds
     """
 
     NONCODING_EFFECTS = {
@@ -76,7 +78,8 @@ class VepFunctionalAnnotator(FunctionalAnnotator):
     """
 
     def __init__(self, protein_annotator: ProteinMetadataService,
-                 include_computational_txs: bool = False):
+                 include_computational_txs: bool = False,
+                 timeout: int = 10):
         self._logger = logging.getLogger(__name__)
         self._protein_annotator = protein_annotator
         self._url = 'https://rest.ensembl.org/vep/human/region/%s?LoF=1&canonical=1' \
@@ -84,6 +87,7 @@ def __init__(self, protein_annotator: ProteinMetadataService,
                     '&mutfunc=1&numbers=1&protein=1&refseq=1&mane=1' \
                     '&transcript_version=1&variant_class=1'
         self._include_computational_txs = include_computational_txs
+        self._timeout = timeout
 
 
     def annotate(self, variant_coordinates: VariantCoordinates) -> typing.Sequence[TranscriptAnnotation]:
@@ -94,12 +98,13 @@ def annotate(self, variant_coordinates: VariantCoordinates) -> typing.Sequence[T
         Returns:
             typing.Sequence[TranscriptAnnotation]: A sequence of transcript
             annotations for the variant coordinates
+        Raises:
+            ValueError if VEP times out or does not return a response or if the response is not formatted as we expect.
         """
         response = self._query_vep(variant_coordinates)
         annotations = []
         if 'transcript_consequences' not in response:
-            self._logger.error('The VEP response lacked the required `transcript_consequences` field. %s', response)
-            return None
+            raise ValueError('The VEP response for `%s` lacked the required `transcript_consequences` field. %s', variant_coordinates, response)
         for trans in response['transcript_consequences']:
             annotation = self._process_item(trans)
             if annotation is not None:
@@ -116,8 +121,8 @@ def _parse_variant_effect(self, effect: str) -> typing.Optional[VariantEffect]:
         try:
             var_effect = VariantEffect[effect]
         except KeyError:
-            self._logger.warning("VariantEffect %s was not found in our record of possible effects. Please report this issue to the genophenocorr GitHub.", effect)
-            return None
+            # A missing variant effect, pls submit an issue to the genophenocorr GitHub repository.
+            raise ValueError("VariantEffect %s was not found in our record of possible effects.", effect)
         return var_effect
 
     def _process_item(self, item: typing.Dict) -> typing.Optional[TranscriptAnnotation]:
@@ -170,17 +175,17 @@ def _process_item(self, item: typing.Dict) -> typing.Optional[TranscriptAnnotati
                                     protein_effect)
 
     def _query_vep(self, variant_coordinates: VariantCoordinates) -> dict:
-        api_url = self._url % (verify_start_end_coordinates(variant_coordinates))
-        r = requests.get(api_url, headers={'Content-Type': 'application/json'})
+        api_url = self._url % (format_coordinates_for_vep_query(variant_coordinates))
+        r = requests.get(api_url, headers={'Accept': 'application/json'}, timeout=self._timeout)
+        #Throw an exception rather than errors so we can skip the variant in _phenopackets
         if not r.ok:
             self._logger.error("Expected a result but got an Error for variant: %s", variant_coordinates.variant_key)
             self._logger.error(r.text)
-            return None
+            raise ValueError('Expected a result but got an Error. See log for details.')
         results = r.json()
         if not isinstance(results, list):
             self._logger.error(results.get('error'))
-            raise ConnectionError(
-                f"Expected a result but got an Error. See log for details.")
+            raise ValueError("Expected a result but got an Error. See log for details.")
         if len(results) > 1:
             self._logger.error("Expected only one variant per request but received %s different variants.", len(results))
             self._logger.error([result.id for result in results])
diff --git a/tests/fixtures.py b/tests/fixtures.py
index 87108c921..59b4476e7 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -39,36 +39,36 @@ def toy_cohort() -> Cohort:
                       TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.6691dup', False, [VariantEffect.FRAMESHIFT_VARIANT], [9],
                                            [prot], Region(2230, 2231))
                   ],
-                  Genotypes.from_mapping({'HetSingleVar': Genotype.HETEROZYGOUS}))
+                  Genotypes.from_mapping({SampleLabels('HetSingleVar'): Genotype.HETEROZYGOUS}))
     indel = Variant(VariantCoordinates(make_region("16", 89284600, 89284602), ref='GG', alt='A', change_length=-1),
                     [
                         TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.1940_1941delinsT', False, [VariantEffect.FRAMESHIFT_VARIANT],
                                              [9], [prot], Region(646, 647))
                     ],
-                    Genotypes.from_mapping({'HetDoubleVar1': Genotype.HETEROZYGOUS}))
+                    Genotypes.from_mapping({SampleLabels('HetDoubleVar1'): Genotype.HETEROZYGOUS}))
     snv_stop_gain = Variant(VariantCoordinates(make_region("16", 89280751, 89280752), ref='G', alt='T', change_length=0),
                             [
                                 TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.5790C>A', False, [VariantEffect.STOP_GAINED], [9], [prot],
                              Region(1929, 1930))],
-                            Genotypes.from_mapping({'HetDoubleVar1': Genotype.HETEROZYGOUS}))
+                            Genotypes.from_mapping({SampleLabels('HetDoubleVar1'): Genotype.HETEROZYGOUS}))
     snv_missense = Variant(VariantCoordinates(make_region("16", 89275127, 89275128), ref='G', alt='A', change_length=0),
                            [
                                TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.7534C>T', False, [VariantEffect.MISSENSE_VARIANT], [10],
                              [prot], Region(2511, 2512))
                            ],
-                           Genotypes.from_mapping({'HetDoubleVar2': Genotype.HETEROZYGOUS}))
+                           Genotypes.from_mapping({SampleLabels('HetDoubleVar2'): Genotype.HETEROZYGOUS}))
     del_frameshift = Variant(VariantCoordinates(make_region("16", 89279707, 89279725), ref='AGTGTTCGGGGCGGGGCC', alt='A', change_length=-17),
                              [
                                  TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.6817_6833del', False, [VariantEffect.FRAMESHIFT_VARIANT],
                               [9], [prot], Region(2272, 2278))
                              ],
-                             Genotypes.from_mapping({'HetDoubleVar2': Genotype.HETEROZYGOUS}))
+                             Genotypes.from_mapping({SampleLabels('HetDoubleVar2'): Genotype.HETEROZYGOUS}))
     del_small = Variant(VariantCoordinates(make_region("16", 89279457, 89279459), ref='TG', alt='T', change_length=-1),
                         [
                             TranscriptAnnotation('ANKRD11', 'NM_013275.6', 'NM_013275.6:c.7083del', False, [VariantEffect.FRAMESHIFT_VARIANT], [9],
                              [prot], Region(2360, 2362))
                         ],
-                        Genotypes.from_mapping({'HomoVar': Genotype.HOMOZYGOUS_ALTERNATE}))
+                        Genotypes.from_mapping({SampleLabels('HomoVar'): Genotype.HOMOZYGOUS_ALTERNATE}))
     del_large = Variant(VariantCoordinates(make_region("16", 89_190_070, 89_439_815), ref='N', alt='<DEL>', change_length=-249_745),
                         [
                             TranscriptAnnotation('ANKRD11', 'NM_013275.6', None, False,
@@ -76,30 +76,30 @@ def toy_cohort() -> Cohort:
                                   VariantEffect.THREE_PRIME_UTR_VARIANT, VariantEffect.INTRON_VARIANT], [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
                                  [prot], None)
                         ],
-                        Genotypes.from_mapping({'LargeCNV': Genotype.HETEROZYGOUS}))
+                        Genotypes.from_mapping({SampleLabels('LargeCNV'): Genotype.HETEROZYGOUS}))
 
     patients = (
-        Patient('HetSingleVar',
+        Patient(SampleLabels('HetSingleVar'),
                 phenotypes=(phenos['arachnodactyly_T'], phenos['spasticity_F'], phenos['focal_clonic_seizure_T']),
                 variants=(dup,),
                 proteins=[prot]
                 ),
-        Patient('HetDoubleVar1',
+        Patient(SampleLabels('HetDoubleVar1'),
                 phenotypes=(phenos['arachnodactyly_T'], phenos['seizure_T'], phenos['spasticity_T']),
                 variants=(indel, snv_stop_gain),
                 proteins=[prot]
                 ),
-        Patient('HetDoubleVar2',
+        Patient(SampleLabels('HetDoubleVar2'),
                 phenotypes=(phenos['arachnodactyly_F'], phenos['spasticity_T'], phenos['seizure_T']),
                 variants=(snv_missense, del_frameshift),
                 proteins=[prot]
                 ),
-        Patient('HomoVar',
+        Patient(SampleLabels('HomoVar'),
                 phenotypes=(phenos['arachnodactyly_T'], phenos['spasticity_T'], phenos['seizure_T']),
                 variants=(del_small,),
                 proteins=[prot]
                 ),
-        Patient('LargeCNV',
+        Patient(SampleLabels('LargeCNV'),
                 phenotypes=(phenos['arachnodactyly_T'], phenos['spasticity_T'], phenos['seizure_F']),
                 variants=(del_large,),
                 proteins=[prot]
diff --git a/tests/test_predicates.py b/tests/test_predicates.py
index 7e3fb12a6..4eb2744e2 100644
--- a/tests/test_predicates.py
+++ b/tests/test_predicates.py
@@ -11,7 +11,7 @@
 from .fixtures import toy_hpo, toy_cohort
 
 
-def find_patient(pat_id, cohort) -> typing.Optional[Patient]:
+def find_patient(pat_id: str, cohort: Cohort) -> typing.Optional[Patient]:
     for pat in cohort.all_patients:
         if pat.patient_id == pat_id:
             return pat