Repository: sdv-dev/RDT (language: python)

Issue:
Create method to auto detect `HyperTransformer` config from data
### Problem Description
When given data, `HyperTransformer` should be able to auto detect the config (data types and first transformers) & show them to the user. That way, the user can update them **before** the expensive `fit` computation. 

Changes:
- Add method `detect_initial_config` that has 1 required param `data` (a `pandas.DataFrame`)
- Rename `data_types` to `sdtype` (semantic data type)

### Expected behavior

```python
>>> ht = HyperTransformer()
>>> ht.detect_initial_config(data=my_pandas_dataframe)
Detecting a new config from the data ... SUCCESS
Setting the new config ... SUCCESS

Config:
{
  'sdtypes': {
    'colA': 'numerical',
    'colB': 'categorical'
  },
  'transformers': {
    'colA': <FloatFormatter(missing_value_replacement="mean")>,
    'colB': <FrequencyEncoder()>
  }
}

```

(See #395 for how to print out transformers.)

### Additional context

- We expect the user to use this method _only once_ before they fit their data
- Calling this method again with erase any pre-existing config and auto-detect it from the new data being passed in



Discussion / hints:

Fix patch:
diff --git a/.github/PULL_REQUEST_TEMPLATE/new_transformer.md b/.github/PULL_REQUEST_TEMPLATE/new_transformer.md
index 73e3a0721..092bcbfc5 100644
--- a/.github/PULL_REQUEST_TEMPLATE/new_transformer.md
+++ b/.github/PULL_REQUEST_TEMPLATE/new_transformer.md
@@ -1,6 +1,6 @@
 ### New Transformer Description
 
-__Data Type__: (replace this with the data type that your new transformer handles)
+__sdtype__: (replace this with the sdtype that your new transformer handles)
 
 (replace this text with your description)
 
@@ -8,7 +8,7 @@ __Data Type__: (replace this with the data type that your new transformer handle
 - [ ] Does this PR resolve an existing issue? If not, please open a new issue. Add the issue number here: Resolves #xxx
 - [ ] Is this PR introducing one (and only one) new Transformer?
 - [ ] Have you implemented Unit tests for all the methods in your Transformer, and successfully run them?
-- [ ] If the data type that this Transformer addresses is new, have you added Dataset Generators and Real World Datasets for this new data type?
+- [ ] If the sdtype that this Transformer addresses is new, have you added Dataset Generators and Real World Datasets for this new sdtype?
 - [ ] Have you successfully run the Integration tests on your Transformer?
 - [ ] Have you run the Performance tests, and optimized your transformer according to the [Common Performance Pitfalls](https://github.com/sdv-dev/RDT/blob/master/CONTRIBUTING.rst#common-performance-pitfalls)?
 - [ ] Have you run and tried to optimize the results of the Quality tests of your Transformer, if applicable?
diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 45018608a..4f09bb075 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -162,9 +162,11 @@ There are only three required methods for a transformer:
    the Transformer instance.
 
 Each transformer class should be placed inside the ``rdt/transformers`` folder, in a module
-file named after the data type that the transformer operates on. For example, if you are
-writing a transformer that works with ``categorical`` data, your transformer should be placed
-inside the ``rdt/transformers/categorical.py`` module.
+file named after the data type that the transformer operates on. The data
+types used by RDT are called ``sdtypes``, and you can think of them as representing the **semantic**
+or **statistical** meaning of a datatype. For example, if you are writing a transformer that works
+with ``categorical`` data, your transformer should be placed inside the
+``rdt/transformers/categorical.py`` module.
 
 For more detailed guide on writing transformers, refer to the `Development Guide`_.
 
@@ -172,10 +174,10 @@ On top of adding the new class, unit tests must be written to cover all of the m
 class uses. In some cases, integration tests may also be required. More details on this can be
 found below.
 
-If the transformer add a previously unsupported `Data Type` to RDT, then more steps will need
+If the transformer adds a previously unsupported `sdtype` to RDT, then more steps will need
 to be taken for the quality and performance tests. A new `DatasetGenerator` class may need to
-be created for the `Data Type`. You may also need to find a real world dataset containing this
-`Data Type` and request for it to be added. More details for these steps can be found below in
+be created for the `sdtype`. You may also need to find a real world dataset containing this
+`sdtype` and request for it to be added. More details for these steps can be found below in
 the `Transformer Performance`_ and `Transformer Quality`_ sections respectively.
 
 Transformer Validations
@@ -289,15 +291,15 @@ Integration tests should test the entire workflow of going from input data, to f
 transforming and finally reverse transforming the data. By default, we run integration tests
 for each transformer that validate the following checks:
 
-1. The Transformer correctly defines the data type that it supports.
-2. At least one Dataset Generator exists for the Transformer data type.
-3. The Transformer can transform data and produces outputs of the indicated data types.
-4. The Transformer can reverse transform the data it produces, recovering the original data type.
+1. The Transformer correctly defines the sdtype that it supports.
+2. At least one Dataset Generator exists for the Transformer sdtype.
+3. The Transformer can transform data and produces outputs of the indicated sdtypes.
+4. The Transformer can reverse transform the data it produces, recovering the original sdtype.
    If ``is_composite_identity``, we expect that the reverse transformed data is equal to the
    original data.
 5. The HyperTransformer is able to use the Transformer and produce float values.
 6. The HyperTransformer is able to reverse the data that has previously transformed,
-   and restore the original data type.
+   and restore the original sdtype.
 
 If you wish to test any specific end-to-end scenarios that were not covered in the above checks, 
 add a new integration test. Integration tests can be added under
@@ -325,11 +327,11 @@ checks. It also prints a table describing each check and whether or not it passe
 
    Check                                   Correct    Details
    --------------------------------------  ---------  -----------------------------------------------------------------------------------------------------------------------
-   Dataset Generators                      Yes        At least one Dataset Generator exists for the Transformer data type.
-   Output Types                            Yes        The Transformer can transform data and produce output(s) of the indicated data type(s).
-   Reverse Transform                       Yes        The Transformer can reverse transform the data it produces, going back to the original data type.
+   Dataset Generators                      Yes        At least one Dataset Generator exists for the Transformer sdtype.
+   Output Sdtypes                            Yes        The Transformer can transform data and produce output(s) of the indicated sdtype(s).
+   Reverse Transform                       Yes        The Transformer can reverse transform the data it produces, going back to the original sdtype.
    Hypertransformer can transform          Yes        The HyperTransformer is able to use the Transformer and produce float values.
-   Hypertransformer can reverse transform  Yes        The HyperTransformer is able to reverse the data that it has previously transformed and restore the original data type.
+   Hypertransformer can reverse transform  Yes        The HyperTransformer is able to reverse the data that it has previously transformed and restore the original sdtype.
 
    In [3]: valid
    Out [3]: True
@@ -340,11 +342,11 @@ Transformer Performance
 """""""""""""""""""""""
 
 We want to ensure our transformers are as efficient as possible, in terms of time and memory.
-In order to do so, we run performance tests on each transformer, based on the input data type
+In order to do so, we run performance tests on each transformer, based on the input sdtype
 specified by the transformer.
 
 We generate test data using Dataset Generators. Each transformer should have at least one
-Dataset Generator that produces data of the transformer's input type.
+Dataset Generator that produces data of the transformer's input sdtype.
 If there are any specific dataset characteristics that you think may affect your transformer
 performance (e.g. constant data, mostly null data), consider adding a Dataset Generator
 for that scenario as well.
@@ -355,7 +357,7 @@ Creating Dataset Generators
 ***************************
 
 In order to test performance, we have a class that is responsible for generating data to test
-the transformer methods against. Each subclass implements two static method, ``generate`` 
+the transformer methods against. Each subclass implements two static methods, ``generate`` 
 and ``get_performance_thresholds``.
 
 1. ``generate`` takes in the number of rows to generate, and outputs the expected number
@@ -366,7 +368,7 @@ and ``get_performance_thresholds``.
 You should make a generator for every type of column that you believe would be useful to test
 against. For some examples, you can look in the `dataset generator folder`_.
 
-The generators each have a ``DATA_TYPE`` class variable. This should match the data type that your
+The generators each have a ``SDTYPE`` class variable. This should match the sdtype that your
 ``transformer`` accepts as input.
 
 More details can be found in the `Development Guide`_.
@@ -425,28 +427,28 @@ Transformer Quality
 """""""""""""""""""
 
 To assess the quality of a transformer, we run quality tests that apply the Transformer
-on all the real world datasets that contain the Transformer input data type. The quality tests
+on all the real world datasets that contain the Transformer input sdtype. The quality tests
 look at how well the original correlations are preserved by using transformed data to train
 regression models that predict other columns in the data. We compare the transformer's quality
-results to that of other transformers of the same data type.
+results to that of other transformers of the same sdtype.
 
 .. _Adding a Dataset:
 
 Adding a Dataset
 ****************
 
-If the transformer you are creating adds a new data type, then a dataset with that type may need to
+If the transformer you are creating adds a new sdtype, then a dataset with that sdtype may need to
 be added for the quality tests. This only needs to be done if the transformer being added is 
 expected to preserve or expose relationships in the data. This can be done using the following
 steps:
 
-1. Find a dataset containing the data type your transformer uses as an input.
+1. Find a dataset containing the sdtype your transformer uses as an input.
 
 2. Test your transformer against this dataset by loading it into a ``DataFrame`` and using the
    ``get_transformer_regression_scores`` in the ``test_quality`` package::
 
     from tests.quality.test_quality import get_transformer_regression_scores
-    get_transformer_regression_scores(data, data_type, dataset_name, [transformer])
+    get_transformer_regression_scores(data, sdtype, dataset_name, [transformer])
 
 3. If the scores are higher than the ``TEST_THRESHOLD`` in the ``test_quality`` package, contact
    one of the `RDT core contributors`_ on GitHub and ask them to add the dataset. Once this is
@@ -514,7 +516,7 @@ Summary of Steps to Add a New Transformer
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 1. If it does not exist, open an Issue in Github and describe the Transformer that will be added,
-   including the data type that it handles and how it will handle it.
+   including the sdtype that it handles and how it will handle it.
 2. Create and clone a fork of the RDT repository.
 3. Create a branch in this repository using the naming convention
    issue-[issue-number]-[transformer-name] (eg. issue-123-address-transformer).
@@ -524,7 +526,7 @@ Summary of Steps to Add a New Transformer
 6. Implement Unit Tests for the Transformer.
 7. Run the ``validate_transformer_unit_tests`` function and fix the reported errors.
 8. Run the ``validate_transformer_integration`` function and fix the reported errors.
-9. If required, implement the `Dataset Generators` for the new data type. This is described in the
+9. If required, implement the `Dataset Generators` for the new sdtype. This is described in the
    `Creating Dataset Generators`_ section.
 10. Run the ``validate_transformer_performance`` function and fix any errors reported.
     If there are no errors but performance can be improved, this function should be used for
@@ -532,9 +534,9 @@ Summary of Steps to Add a New Transformer
 11. If this transformer is expected to help preserve relationships in the data, run the
     ``validate_transformer_quality`` function. If the quality is too low, make the
     necessary enhancements to the transformer.
-12. If the quality tests fail because there is no dataset for the transformer's data type,
+12. If the quality tests fail because there is no dataset for the transformer's sdtype,
     follow the steps in the `Adding a Dataset`_ section to add a real world dataset
-    containing the new data type to the quality tests.
+    containing the new sdtype to the quality tests.
 13. Run the ``validate_pull_request`` function as a final check and fix any errors reported.
 14. After all the previous steps pass, all the new and modified files can be committed and pushed
     to github, and a Pull Request can be submitted. Follow the steps in the
diff --git a/DEVELOPMENT.rst b/DEVELOPMENT.rst
index b8f61e267..7280d313f 100644
--- a/DEVELOPMENT.rst
+++ b/DEVELOPMENT.rst
@@ -16,9 +16,11 @@ RDT Technical Overview
 
 The goal of RDT is to be able to transform data that is not machine learning ready into data that
 is. By machine learning ready, we mean that the data should consist of data types that most machine
-learning models can process. Usually this means outputting numeric data with no nulls. On top of this,
-RDT also enforces that those transformations can be reversed, so that data of the original form can
-be obtained again. RDT accomplishes this with the use of two main classes:
+learning models can process. Usually this means outputting numeric data with no nulls. The data
+types used by RDT are called ``sdtypes``. You can think of them as representing the **semantic**
+or **statistical** meaning of a datatype. On top of this, RDT also enforces that those transformations
+can be reversed, so that data of the original form can be obtained again. RDT accomplishes this
+with the use of two main classes:
 
 * ``BaseTransformer``
 * ``HyperTransformer``
@@ -27,11 +29,11 @@ BaseTransformer
 """""""""""""""
 
 Every Transformer in RDT inherits from the ``BaseTransformer``. The goal of this class or any of
-its subclasses is to take data of a certain data type, and convert it into machine learning ready
+its subclasses is to take data of a certain sdtype, and convert it into machine learning ready
 data. To enable transformers to do this, the ``BaseTransformer`` has the following attributes:
 
-* ``INPUT_TYPE`` (str) - The input type for the transformer.
-* ``OUTPUT_TYPES`` (dict) - Dictionary mapping transformed column names to their data types.
+* ``INPUT_SDTYPE`` (str) - The input sdtype for the transformer.
+* ``OUTPUT_SDTYPES`` (dict) - Dictionary mapping transformed column names to their sdtypes.
 * ``DETERMINISTIC_TRANSFORM`` (bool) - Whether or not calling ``transform`` yields a deterministic
   output.
 * ``DETERMINISTIC_REVERSE`` (bool) - Whether or not calling ``reverse_transform`` yields a
@@ -52,8 +54,8 @@ data. To enable transformers to do this, the ``BaseTransformer`` has the followi
 It also has the following default methods, which the ``Transformer`` subclasses may overwrite when
 necessary:
 
-* ``get_output_types()`` - Returns the name of the columns that the transform method creates. By
-  default this will be the ``OUTPUT_TYPES`` dictionary with the column names prepended with the
+* ``get_output_sdtypes()`` - Returns the name of the columns that the transform method creates. By
+  default this will be the ``OUTPUT_SDTYPES`` dictionary with the column names prepended with the
   ``column_prefix`` with a dot (`.`) as the separator.
 * ``is_transform_deterministic()`` - Returns a boolean indicating whether the output of the
   ``transform`` method is deterministic. By default this is the value of the
@@ -88,7 +90,7 @@ get a machine learning ready output. It does so using the following methods:
 * ``fit(data)`` - Takes in a ``pandas.DataFrame``. For every column or group of columns in the
   data, it find a transformer to use on it and calls that transformer's `fit` method with those
   columns. If the output of the transformer is not machine learning ready, it will recursively
-  find transformers to use on that data type until it is. A sequence of transformers to use is
+  find transformers to use on that sdtype until it is. A sequence of transformers to use is
   created.
 * ``transform(data)`` - Takes in a ``pandas.DataFrame``. Goes through the sequence of transformers
   created during ``fit`` and calls their underlying ``transform`` method.
@@ -135,7 +137,7 @@ Let's start by setting the necessary attributes and writing the ``__init__`` met
 
     class USPhoneNumberTransformer(BaseTransformer):
 
-        INPUT_TYPE = 'phone_number'
+        INPUT_SDTYPE = 'phone_number'
         DETERMINISTIC_TRANSFORM = True
         DETERMINISTIC_REVERSE = True
         COMPOSITION_IS_IDENTITY = True
@@ -152,20 +154,20 @@ Now we can write the ``_fit`` method.
         self.has_country_code = len(number) == 11
 
 Since the ``country_code`` may or may not be present, we can overwrite the
-``get_next_transformers`` and ``get_output_types`` methods accordingly.
+``get_next_transformers`` and ``get_output_sdtypes`` methods accordingly.
 
 .. code-block:: Python
 
-    def get_output_types(self):
-        output_types = {
+    def get_output_sdtypes(self):
+        output_sdtypes = {
             'area_code': 'categorical',
             'exchange': 'integer',
             'line': 'integer'
         }
         if self.has_country_code:
-            output_types['country_code'] = 'categorical'
+            output_sdtypes['country_code'] = 'categorical'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def get_next_transformers(self):
         next_transformers = {
@@ -205,7 +207,7 @@ handles that for us. Let's view the complete class below.
 .. code-block:: Python
     class USPhoneNumberTransformer(BaseTransformer):
 
-        INPUT_TYPE = 'phone_number'
+        INPUT_SDTYPE = 'phone_number'
         DETERMINISTIC_TRANSFORM = True
         DETERMINISTIC_REVERSE = True
         COMPOSITION_IS_IDENTITY = True
@@ -217,16 +219,16 @@ handles that for us. Let's view the complete class below.
             number = ''.join(columns_data.loc[0].split('-'))
             self.has_country_code = len(number) == 11
 
-        def get_output_types(self):
-            output_types = {
+        def get_output_sdtypes(self):
+            output_sdtypes = {
                 'area_code': 'categorical',
                 'exchange': 'integer',
                 'line': 'integer'
             }
             if self.has_country_code:
-                output_types['country_code'] = 'categorical'
+                output_sdtypes['country_code'] = 'categorical'
 
-            return self._add_prefix(output_types)
+            return self._add_prefix(output_sdtypes)
 
         def get_next_transformers(self):
             next_transformers = {
@@ -286,8 +288,8 @@ We can also run it using the `HyperTransformer`.
 .. code-block:: Python
 
     In [1]: ht = HyperTransformer(
-                default_data_type_transformers={'phone_number': USPhoneNumberTransformer},
-                field_data_types={'phone_numbers': 'phone_number'}
+                default_sdtype_transformers={'phone_number': USPhoneNumberTransformer},
+                field_sdtypes={'phone_numbers': 'phone_number'}
             )
             ht.fit(data)
             transformed = ht.transform(data)
@@ -312,8 +314,8 @@ Dataset Generators
 ------------------
 
 In RDT, performance tests are run to assure that each transformer is efficient. In order to run
-these tests, we have classes that generate datasets of a certain data type. If a new transformer
-introduces a new data type, the a ``DatasetGenerator`` class will need to be added for it.
+these tests, we have classes that generate datasets of a certain sdtype. If a new transformer
+introduces a new sdtype, the a ``DatasetGenerator`` class will need to be added for it.
 
 BaseDatasetGenerator
 """"""""""""""""""""
@@ -321,12 +323,12 @@ BaseDatasetGenerator
 All dataset generators inherit from the ``BaseDatasetGenerator`` class. It has the following
 class attribute:
 
-* ``DATA_TYPE`` (str) - The data type for the class to generate.
+* ``SDTYPE`` (str) - The sdtype for the class to generate.
 
 They must implement the following methods.
 
 * ``generate(num_rows)`` - Takes in an int representing the number of rows to generate. Returns a
-  ``numpy.ndarray`` of size ``num_rows`` where each value is of the class' ``DATA_TYPE``.
+  ``numpy.ndarray`` of size ``num_rows`` where each value is of the class' ``SDTYPE``.
 
 * ``get_performance_thresholds()`` - Returns a dict mapping each of the main methods for a
   transformer (``fit``, ``transform``, ``reverse_transform``) to the expected time and memory it
@@ -336,14 +338,14 @@ Implementing a DatasetGenerator
 """""""""""""""""""""""""""""""
 
 To create a new ``DatasetGenerator``, the methods described above need to be implemented. The
-class should be placed in a new file in the following location ``tests/datasets/{DATA_TYPE}.py``.
+class should be placed in a new file in the following location ``tests/datasets/{SDTYPE}.py``.
 Each generator must inherit from the base class as well as ``abc.ABC``.
 
 Example DatasetGenerator
 ************************
 
-Let's create a ``DatasetGenerator`` for the ``phone_number`` data type that we introduced earlier.
-We can start by implementing the ``generate`` method and setting the ``DATA_TYPE``.
+Let's create a ``DatasetGenerator`` for the ``phone_number`` sdtype that we introduced earlier.
+We can start by implementing the ``generate`` method and setting the ``SDTYPE``.
 
 .. code-block:: Python
 
@@ -354,7 +356,7 @@ We can start by implementing the ``generate`` method and setting the ``DATA_TYPE
     from tests.datasets.base import BaseDatasetGenerator
 
     class USPhoneNumberGenerator(BaseDatasetGenerator, ABC):
-        DATA_TYPE = 'phone_number'
+        SDTYPE = 'phone_number'
         
         @staticmethod
         def generate(num_rows):
diff --git a/README.md b/README.md
index 7cfcefc76..a4db900e4 100644
--- a/README.md
+++ b/README.md
@@ -92,7 +92,7 @@ from rdt import get_demo
 data = get_demo()
 ```
 
-This will return a `pandas.DataFrame` with 5 rows and 5 columns, one of each data type supported:
+This will return a `pandas.DataFrame` with 5 rows and 5 columns, one of each sdtype supported:
 
 ```
   last_login email_optin credit_card  age  dollars_spent
diff --git a/rdt/__init__.py b/rdt/__init__.py
index 7f7a0af0c..9bd166884 100644
--- a/rdt/__init__.py
+++ b/rdt/__init__.py
@@ -20,7 +20,7 @@
 
 
 def get_demo(num_rows=5):
-    """Generate demo data with multiple data types.
+    """Generate demo data with multiple sdtypes.
 
     The first five rows are hard coded. The rest are randomly generated
     using ``np.random.seed(42)``.
diff --git a/rdt/hyper_transformer.py b/rdt/hyper_transformer.py
index 4d3ba8ae9..56b79985f 100644
--- a/rdt/hyper_transformer.py
+++ b/rdt/hyper_transformer.py
@@ -25,17 +25,17 @@ class HyperTransformer:
             names. Keys can also specify transformers for fields derived by other transformers.
             This can be done by concatenating the name of the original field to the output name
             using ``.`` as a separator (eg. {field_name}.{transformer_output_name}).
-        field_data_types (dict or None):
-            Dict mapping field names to their data types. If not provided, the data type is
+        field_sdtypes (dict or None):
+            Dict mapping field names to their sdtypes. If not provided, the sdtype is
             inferred using the column's Pandas ``dtype``.
-        default_data_type_transformers (dict or None):
-            Dict used to overwrite the default transformer for a data type. The keys are
-            data types and the values are Transformers or Transformer instances.
+        default_sdtype_transformers (dict or None):
+            Dict used to overwrite the default transformer for a sdtype. The keys are
+            sdtypes and the values are Transformers or Transformer instances.
         copy (bool):
             Whether to make a copy of the input data or not. Defaults to ``True``.
-        transform_output_types (list or None):
-            List of acceptable data types for the output of the ``transform`` method.
-            If ``None``, only ``numerical`` types will be considered acceptable.
+        transform_output_sdtypes (list or None):
+            List of acceptable sdtypes for the output of the ``transform`` method.
+            If ``None``, only ``numerical`` sdtypes will be considered acceptable.
 
 
     Example:
@@ -44,13 +44,13 @@ class HyperTransformer:
 
         >>> ht = HyperTransformer()
 
-        Create a ``HyperTransformer`` passing a dict mapping fields to data types.
+        Create a ``HyperTransformer`` passing a dict mapping fields to sdtypes.
 
-        >>> field_data_types = {
+        >>> field_sdtypes = {
         ...     'a': 'categorical',
         ...     'b': 'numerical'
         ... }
-        >>> ht = HyperTransformer(field_data_types=field_data_types)
+        >>> ht = HyperTransformer(field_sdtypes=field_sdtypes)
 
         Create a ``HyperTransformer`` passing a ``field_transformers`` dict.
         (Note: The transformers used in this example may not exist and are just used
@@ -62,24 +62,24 @@ class HyperTransformer:
         ... }
         >>> ht = HyperTransformer(field_transformers=field_transformers)
 
-        Create a ``HyperTransformer`` passing a dict mapping data types to transformers.
-        >>> default_data_type_transformers = {
+        Create a ``HyperTransformer`` passing a dict mapping sdtypes to transformers.
+        >>> default_sdtype_transformers = {
         ...     'categorical': LabelEncoder(),
         ...     'numerical': FloatFormatter()
         ... }
-        >>> ht = HyperTransformer(default_data_type_transformers=default_data_type_transformers)
+        >>> ht = HyperTransformer(default_sdtype_transformers=default_sdtype_transformers)
     """
 
     # pylint: disable=too-many-instance-attributes
 
-    _DTYPES_TO_DATA_TYPES = {
+    _DTYPES_TO_SDTYPES = {
         'i': 'integer',
         'f': 'float',
         'O': 'categorical',
         'b': 'boolean',
         'M': 'datetime',
     }
-    _DEFAULT_OUTPUT_TYPES = [
+    _DEFAULT_OUTPUT_SDTYPES = [
         'numerical',
         'float',
         'integer'
@@ -109,7 +109,7 @@ def _subset(input_list, other_list, not_in=False):
 
     def _create_multi_column_fields(self):
         multi_column_fields = {}
-        for field in list(self.field_data_types) + list(self.field_transformers):
+        for field in list(self.field_sdtypes) + list(self.field_transformers):
             if isinstance(field, tuple):
                 for column in field:
                     multi_column_fields[column] = field
@@ -124,15 +124,15 @@ def _validate_field_transformers(self):
 
             self._add_field_to_set(field, self._specified_fields)
 
-    def __init__(self, copy=True, field_data_types=None, default_data_type_transformers=None,
-                 field_transformers=None, transform_output_types=None):
+    def __init__(self, copy=True, field_sdtypes=None, default_sdtype_transformers=None,
+                 field_transformers=None, transform_output_sdtypes=None):
         self.copy = copy
-        self.field_data_types = field_data_types or {}
-        self.default_data_type_transformers = default_data_type_transformers or {}
+        self.field_sdtypes = field_sdtypes or {}
+        self.default_sdtype_transformers = default_sdtype_transformers or {}
         self.field_transformers = field_transformers or {}
         self._specified_fields = set()
         self._validate_field_transformers()
-        self.transform_output_types = transform_output_types or self._DEFAULT_OUTPUT_TYPES
+        self.transform_output_sdtypes = transform_output_sdtypes or self._DEFAULT_OUTPUT_SDTYPES
         self._multi_column_fields = self._create_multi_column_fields()
         self._transformers_sequence = []
         self._output_columns = []
@@ -146,20 +146,20 @@ def _field_in_data(field, data):
         all_columns_in_data = isinstance(field, tuple) and all(col in data for col in field)
         return field in data or all_columns_in_data
 
-    def _set_field_data_type(self, data, field):
+    def _set_field_sdtype(self, data, field):
         clean_data = data[field].dropna()
         kind = clean_data.infer_objects().dtype.kind
-        self.field_data_types[field] = self._DTYPES_TO_DATA_TYPES[kind]
+        self.field_sdtypes[field] = self._DTYPES_TO_SDTYPES[kind]
 
-    def _populate_field_data_types(self, data):
+    def _populate_field_sdtypes(self, data):
         # get set of provided fields including multi-column fields
         provided_fields = set()
-        for field in self.field_data_types.keys():
+        for field in self.field_sdtypes.keys():
             self._add_field_to_set(field, provided_fields)
 
         for field in data:
             if field not in provided_fields:
-                self._set_field_data_type(data, field)
+                self._set_field_sdtype(data, field)
 
     def _unfit(self):
         self._transformers_sequence = []
@@ -171,12 +171,12 @@ def _validate_config(config):
         sdtypes = config.get('sdtypes', {})
         transformers = config.get('transformers', {})
         for column, transformer in transformers.items():
-            input_type = transformer.get_input_type()
+            input_sdtype = transformer.get_input_sdtype()
             sdtype = sdtypes.get(column)
-            if input_type != sdtype:
-                warnings.warn(f'You are assigning a {input_type} transformer to a {sdtype} column'
-                              f" ('{column}'). If the transformer doesn't match the sdtype,"
-                              ' it may lead to errors.')
+            if input_sdtype != sdtype:
+                warnings.warn(f'You are assigning a {input_sdtype} transformer to a {sdtype} '
+                              f"column ('{column}'). If the transformer doesn't match the "
+                              'sdtype, it may lead to errors.')
 
     def get_config(self):
         """Get the current ``HyperTransformer`` configuration.
@@ -188,7 +188,7 @@ def get_config(self):
                 - transformers: A dictionary mapping column names to their transformer instances.
         """
         return {
-            'sdtypes': self.field_data_types,
+            'sdtypes': self.field_sdtypes,
             'transformers': self.field_transformers
         }
 
@@ -202,43 +202,43 @@ def set_config(self, config):
                 - transformers: A dictionary mapping column names to their transformer instances.
         """
         self._validate_config(config)
-        self.field_data_types = config['sdtypes']
+        self.field_sdtypes = config['sdtypes']
         self.field_transformers = config['transformers']
 
-    def update_field_data_types(self, field_data_types):
-        """Update the ``field_data_types`` dict.
+    def update_field_sdtypes(self, field_sdtypes):
+        """Update the ``field_sdtypes`` dict.
 
         Args:
-            field_data_types (dict):
-                Mapping of fields to their data types. Fields can be defined as a string
+            field_sdtypes (dict):
+                Mapping of fields to their sdtypes. Fields can be defined as a string
                 representing a column name or a tuple of multiple column names. It will
-                update the existing ``field_data_types`` values. Calling this method will
+                update the existing ``field_sdtypes`` values. Calling this method will
                 require ``fit`` to be run again.
         """
-        self.field_data_types.update(field_data_types)
+        self.field_sdtypes.update(field_sdtypes)
         self._unfit()
 
-    def get_default_data_type_transformers(self):
-        """Get the ``default_data_type_transformer`` dict.
+    def get_default_sdtype_transformers(self):
+        """Get the ``default_sdtype_transformer`` dict.
 
         Returns:
             dict:
-                The ``default_data_type_transformers`` dictionary. The keys are
-                data types and the values are Transformers or Transformer instances.
+                The ``default_sdtype_transformers`` dictionary. The keys are
+                sdtypes and the values are Transformers or Transformer instances.
         """
-        return self.default_data_type_transformers
+        return self.default_sdtype_transformers
 
-    def update_default_data_type_transformers(self, new_data_type_transformers):
-        """Update the ``default_data_type_transformer`` dict.
+    def update_default_sdtype_transformers(self, new_sdtype_transformers):
+        """Update the ``default_sdtype_transformer`` dict.
 
         Args:
-            new_data_type_transformers (dict):
-                Dict mapping data types to the default transformer class or instance to use for
-                them. This dict does not need to contain an entry for every data type. It will be
+            new_sdtype_transformers (dict):
+                Dict mapping sdtypes to the default transformer class or instance to use for
+                them. This dict does not need to contain an entry for every sdtype. It will be
                 used to overwrite the existing defaults. Calling this method will require ``fit``
                 to be run again.
         """
-        self.default_data_type_transformers.update(new_data_type_transformers)
+        self.default_sdtype_transformers.update(new_sdtype_transformers)
         self._unfit()
 
     def set_first_transformers_for_fields(self, field_transformers):
@@ -296,9 +296,9 @@ def get_final_output_columns(self, field):
         """Return list of all final output columns related to a field.
 
         The ``HyperTransformer`` will figure out which transformers to use on a field during
-        ``transform``. If the outputs are not of an acceptable data type, they will also go
+        ``transform``. If the outputs are not of an acceptable sdtype, they will also go
         through transformations. This method finds all the output columns that are of an
-        acceptable final data type that originated from the specified field.
+        acceptable final sdtype that originated from the specified field.
 
         Args:
             field (str or tuple):
@@ -367,36 +367,36 @@ def detect_initial_config(self, data):
                 Data which will have its configuration detected.
         """
         # Reset the state of the HyperTransformer
-        self.field_data_types = {}
+        self.field_sdtypes = {}
         self.field_transformers = {}
 
         # Set the sdtypes and transformers of all fields to their defaults
         for field in data:
-            self._set_field_data_type(data, field)
-            field_sdtype = self.field_data_types[field]
+            self._set_field_sdtype(data, field)
+            field_sdtype = self.field_sdtypes[field]
             self.field_transformers[field] = get_default_transformer(field_sdtype)
 
         print('Detecting a new config from the data ... SUCCESS')  # noqa: T001
         print('Setting the new config ... SUCCESS')  # noqa: T001
 
         config = {
-            'sdtypes': self.field_data_types,
+            'sdtypes': self.field_sdtypes,
             'transformers': {k: repr(v) for k, v in self.field_transformers.items()}
         }
 
         print('Config:')  # noqa: T001
         print(json.dumps(config, indent=4))  # noqa: T001
 
-    def _get_next_transformer(self, output_field, output_type, next_transformers):
+    def _get_next_transformer(self, output_field, output_sdtype, next_transformers):
         next_transformer = None
         if output_field in self.field_transformers:
             next_transformer = self.field_transformers[output_field]
 
-        elif output_type not in self.transform_output_types:
+        elif output_sdtype not in self.transform_output_sdtypes:
             if next_transformers is not None and output_field in next_transformers:
                 next_transformer = next_transformers[output_field]
             else:
-                next_transformer = get_default_transformer(output_type)
+                next_transformer = get_default_transformer(output_sdtype)
 
         return next_transformer
 
@@ -424,14 +424,14 @@ def _fit_field_transformer(self, data, field, transformer):
         self._transformers_sequence.append(transformer)
         data = transformer.transform(data)
 
-        output_types = transformer.get_output_types()
+        output_sdtypes = transformer.get_output_sdtypes()
         next_transformers = transformer.get_next_transformers()
         self._transformers_tree[field]['transformer'] = transformer
-        self._transformers_tree[field]['outputs'] = list(output_types)
-        for (output_name, output_type) in output_types.items():
+        self._transformers_tree[field]['outputs'] = list(output_sdtypes)
+        for (output_name, output_sdtype) in output_sdtypes.items():
             output_field = self._multi_column_fields.get(output_name, output_name)
             next_transformer = self._get_next_transformer(
-                output_field, output_type, next_transformers)
+                output_field, output_sdtype, next_transformers)
 
             if next_transformer:
                 if self._field_in_data(output_field, data):
@@ -459,19 +459,19 @@ def fit(self, data):
                 Data to fit the transformers to.
         """
         self._input_columns = list(data.columns)
-        self._populate_field_data_types(data)
+        self._populate_field_sdtypes(data)
 
         # Loop through field_transformers that are first level
         for field in self.field_transformers:
             if self._field_in_data(field, data):
                 data = self._fit_field_transformer(data, field, self.field_transformers[field])
 
-        for (field, data_type) in self.field_data_types.items():
+        for (field, sdtype) in self.field_sdtypes.items():
             if not self._field_in_set(field, self._fitted_fields):
-                if data_type in self.default_data_type_transformers:
-                    transformer = self.default_data_type_transformers[data_type]
+                if sdtype in self.default_sdtype_transformers:
+                    transformer = self.default_sdtype_transformers[sdtype]
                 else:
-                    transformer = get_default_transformer(data_type)
+                    transformer = get_default_transformer(sdtype)
 
                 data = self._fit_field_transformer(data, field, transformer)
 
diff --git a/rdt/performance/datasets/__init__.py b/rdt/performance/datasets/__init__.py
index 35cb94361..e381ef899 100644
--- a/rdt/performance/datasets/__init__.py
+++ b/rdt/performance/datasets/__init__.py
@@ -16,15 +16,15 @@
 
 
 def get_dataset_generators_by_type():
-    """Build a ``dict`` mapping data types to dataset generators.
+    """Build a ``dict`` mapping sdtypes to dataset generators.
 
     Returns:
         dict:
-            Mapping of data type to a list of dataset generators that produce
-            data of that data type.
+            Mapping of sdtype to a list of dataset generators that produce
+            data of that sdtype.
     """
     dataset_generators = defaultdict(list)
     for dataset_generator in BaseDatasetGenerator.get_subclasses():
-        dataset_generators[dataset_generator.DATA_TYPE].append(dataset_generator)
+        dataset_generators[dataset_generator.SDTYPE].append(dataset_generator)
 
     return dataset_generators
diff --git a/rdt/performance/datasets/base.py b/rdt/performance/datasets/base.py
index 6937c8442..acc001cfd 100644
--- a/rdt/performance/datasets/base.py
+++ b/rdt/performance/datasets/base.py
@@ -6,7 +6,7 @@
 class BaseDatasetGenerator(ABC):
     """Parent class for all the Dataset Generators."""
 
-    DATA_TYPE = None
+    SDTYPE = None
 
     @staticmethod
     @abstractmethod
diff --git a/rdt/performance/datasets/boolean.py b/rdt/performance/datasets/boolean.py
index 98d7668a3..99ed04878 100644
--- a/rdt/performance/datasets/boolean.py
+++ b/rdt/performance/datasets/boolean.py
@@ -13,7 +13,7 @@
 class BooleanGenerator(BaseDatasetGenerator, ABC):
     """Base class for generators that generate boolean data."""
 
-    DATA_TYPE = 'boolean'
+    SDTYPE = 'boolean'
 
 
 class RandomBooleanGenerator(BooleanGenerator):
diff --git a/rdt/performance/datasets/categorical.py b/rdt/performance/datasets/categorical.py
index 4834f835e..c21f65fa2 100644
--- a/rdt/performance/datasets/categorical.py
+++ b/rdt/performance/datasets/categorical.py
@@ -12,7 +12,7 @@
 class CategoricalGenerator(BaseDatasetGenerator, ABC):
     """Base class for generators that generate catgorical data."""
 
-    DATA_TYPE = 'categorical'
+    SDTYPE = 'categorical'
 
 
 class RandomIntegerGenerator(CategoricalGenerator):
diff --git a/rdt/performance/datasets/datetime.py b/rdt/performance/datasets/datetime.py
index 7391d7f92..c0b56e490 100644
--- a/rdt/performance/datasets/datetime.py
+++ b/rdt/performance/datasets/datetime.py
@@ -13,7 +13,7 @@
 class DatetimeGenerator(BaseDatasetGenerator, ABC):
     """Base class for generators that generate datatime data."""
 
-    DATA_TYPE = 'datetime'
+    SDTYPE = 'datetime'
 
 
 class RandomGapDatetimeGenerator(DatetimeGenerator):
diff --git a/rdt/performance/datasets/numerical.py b/rdt/performance/datasets/numerical.py
index d4caa9ea3..dab7354f8 100644
--- a/rdt/performance/datasets/numerical.py
+++ b/rdt/performance/datasets/numerical.py
@@ -11,7 +11,7 @@
 class NumericalGenerator(BaseDatasetGenerator, ABC):
     """Base class for generators that create numerical data."""
 
-    DATA_TYPE = 'numerical'
+    SDTYPE = 'numerical'
 
 
 class RandomIntegerGenerator(NumericalGenerator):
diff --git a/rdt/performance/datasets/pii.py b/rdt/performance/datasets/pii.py
index 7d4c0ff5b..887565fb9 100644
--- a/rdt/performance/datasets/pii.py
+++ b/rdt/performance/datasets/pii.py
@@ -11,7 +11,7 @@
 class PIIGenerator(BaseDatasetGenerator, ABC):
     """Base class for generators that generate PII data."""
 
-    DATA_TYPE = 'pii'
+    SDTYPE = 'pii'
 
 
 class RandomStringGenerator(PIIGenerator):
diff --git a/rdt/performance/performance.py b/rdt/performance/performance.py
index 0c981249e..782d3629b 100644
--- a/rdt/performance/performance.py
+++ b/rdt/performance/performance.py
@@ -47,15 +47,15 @@
 }
 
 
-def _get_dataset_sizes(data_type):
+def _get_dataset_sizes(sdtype):
     """Get a list of (fit_size, transform_size) for each dataset generator.
 
-    Based on the data type of the dataset generator, return the list of
+    Based on the sdtype of the dataset generator, return the list of
     sizes to run performance tests on. Each element in this list is a tuple
     of (fit_size, transform_size).
 
     Args:
-        input_type (str):
+        sdtype (str):
             The type of data that the generator returns.
 
     Returns:
@@ -64,7 +64,7 @@ def _get_dataset_sizes(data_type):
     """
     sizes = [(s, s) for s in DATASET_SIZES]
 
-    if data_type == 'categorical':
+    if sdtype == 'categorical':
         sizes = [(s, max(s, 1000)) for s in DATASET_SIZES if s <= 10000]
 
     return sizes
@@ -90,7 +90,7 @@ def evaluate_transformer_performance(transformer, dataset_generator, verbose=Fal
     transformer_args = TRANSFORMER_ARGS.get(transformer.__name__, {})
     transformer_instance = transformer(**transformer_args)
 
-    sizes = _get_dataset_sizes(dataset_generator.DATA_TYPE)
+    sizes = _get_dataset_sizes(dataset_generator.SDTYPE)
 
     out = []
     for fit_size, transform_size in sizes:
diff --git a/rdt/transformers/__init__.py b/rdt/transformers/__init__.py
index 9e02aab69..7d22113bc 100644
--- a/rdt/transformers/__init__.py
+++ b/rdt/transformers/__init__.py
@@ -134,46 +134,46 @@ def get_transformer_instance(transformer):
 
 @lru_cache()
 def get_transformers_by_type():
-    """Build a ``dict`` mapping data types to valid existing transformers for that type.
+    """Build a ``dict`` mapping sdtypes to valid existing transformers for that sdtype.
 
     Returns:
         dict:
-            Mapping of data types to a list of existing transformers that take that
-            type as an input.
+            Mapping of sdtypes to a list of existing transformers that take that
+            sdtype as an input.
     """
-    data_type_transformers = defaultdict(list)
+    sdtype_transformers = defaultdict(list)
     transformer_classes = BaseTransformer.get_subclasses()
     for transformer in transformer_classes:
-        input_type = transformer.get_input_type()
-        data_type_transformers[input_type].append(transformer)
+        input_sdtype = transformer.get_input_sdtype()
+        sdtype_transformers[input_sdtype].append(transformer)
 
-    return data_type_transformers
+    return sdtype_transformers
 
 
 @lru_cache()
 def get_default_transformers():
-    """Build a ``dict`` mapping data types to a default transformer for that type.
+    """Build a ``dict`` mapping sdtypes to a default transformer for that sdtype.
 
     Returns:
         dict:
-            Mapping of data types to a transformer.
+            Mapping of sdtypes to a transformer.
     """
     transformers_by_type = get_transformers_by_type()
     defaults = deepcopy(DEFAULT_TRANSFORMERS)
-    for (data_type, transformers) in transformers_by_type.items():
-        if data_type not in defaults:
-            defaults[data_type] = transformers[0]
+    for (sdtype, transformers) in transformers_by_type.items():
+        if sdtype not in defaults:
+            defaults[sdtype] = transformers[0]
 
     return defaults
 
 
 @lru_cache()
-def get_default_transformer(data_type):
-    """Get default transformer for a data type.
+def get_default_transformer(sdtype):
+    """Get default transformer for a sdtype.
 
     Returns:
         Transformer:
-            Default transformer for data type.
+            Default transformer for sdtype.
     """
     default_transformers = get_default_transformers()
-    return default_transformers[data_type]
+    return default_transformers[sdtype]
diff --git a/rdt/transformers/addons/identity/identity.py b/rdt/transformers/addons/identity/identity.py
index aaf2a87af..8703e5c99 100644
--- a/rdt/transformers/addons/identity/identity.py
+++ b/rdt/transformers/addons/identity/identity.py
@@ -17,7 +17,7 @@ def _fit(self, data):
             data (pandas.Series or numpy.ndarray):
                 Data to fit the transformer to.
         """
-        self.OUTPUT_TYPES = {
+        self.OUTPUT_SDTYPES = {
             column: None
             for column in self.columns
         }
diff --git a/rdt/transformers/base.py b/rdt/transformers/base.py
index 39ca6775d..2711c275d 100644
--- a/rdt/transformers/base.py
+++ b/rdt/transformers/base.py
@@ -13,8 +13,8 @@ class BaseTransformer:
     and ``fit_transform`` method is already implemented.
     """
 
-    INPUT_TYPE = None
-    OUTPUT_TYPES = None
+    INPUT_SDTYPE = None
+    OUTPUT_SDTYPES = None
     DETERMINISTIC_TRANSFORM = None
     DETERMINISTIC_REVERSE = None
     COMPOSITION_IS_IDENTITY = None
@@ -42,33 +42,33 @@ def get_subclasses(cls):
         return subclasses
 
     @classmethod
-    def get_input_type(cls):
-        """Return the input type supported by the transformer.
+    def get_input_sdtype(cls):
+        """Return the input sdtype supported by the transformer.
 
         Returns:
             string:
-                Accepted input type of the transformer.
+                Accepted input sdtype of the transformer.
         """
-        return cls.INPUT_TYPE
+        return cls.INPUT_SDTYPE
 
     def _add_prefix(self, dictionary):
         if not dictionary:
             return {}
 
         output = {}
-        for output_columns, output_type in dictionary.items():
-            output[f'{self.column_prefix}.{output_columns}'] = output_type
+        for output_columns, output_sdtype in dictionary.items():
+            output[f'{self.column_prefix}.{output_columns}'] = output_sdtype
 
         return output
 
-    def get_output_types(self):
-        """Return the output types produced by this transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes produced by this transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to the produced data types.
+                Mapping from the transformed column names to the produced sdtypes.
         """
-        return self._add_prefix(self.OUTPUT_TYPES)
+        return self._add_prefix(self.OUTPUT_SDTYPES)
 
     def is_transform_deterministic(self):
         """Return whether the transform is deterministic.
@@ -122,7 +122,7 @@ def get_output_columns(self):
             list:
                 Names of columns created during ``transform``.
         """
-        return list(self.get_output_types())
+        return list(self.get_output_sdtypes())
 
     def _store_columns(self, columns, data):
         if isinstance(columns, tuple) and columns not in data:
@@ -158,13 +158,13 @@ def _set_columns_data(data, columns_data, columns):
 
     def _build_output_columns(self, data):
         self.column_prefix = '#'.join(self.columns)
-        self.output_columns = list(self.get_output_types().keys())
+        self.output_columns = list(self.get_output_sdtypes().keys())
 
         # make sure none of the generated `output_columns` exists in the data
         data_columns = set(data.columns)
         while data_columns & set(self.output_columns):
             self.column_prefix += '#'
-            self.output_columns = list(self.get_output_types().keys())
+            self.output_columns = list(self.get_output_sdtypes().keys())
 
     def __repr__(self):
         """Represent initialization of transformer as text.
diff --git a/rdt/transformers/boolean.py b/rdt/transformers/boolean.py
index 9396efd6c..46de1eacd 100644
--- a/rdt/transformers/boolean.py
+++ b/rdt/transformers/boolean.py
@@ -28,7 +28,7 @@ class BinaryEncoder(BaseTransformer):
             are null values. Defaults to ``False``.
     """
 
-    INPUT_TYPE = 'boolean'
+    INPUT_SDTYPE = 'boolean'
     DETERMINISTIC_TRANSFORM = True
     DETERMINISTIC_REVERSE = True
 
@@ -38,20 +38,20 @@ def __init__(self, missing_value_replacement=None, model_missing_values=False):
         self.missing_value_replacement = missing_value_replacement
         self.model_missing_values = model_missing_values
 
-    def get_output_types(self):
-        """Return the output types returned by this transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes returned by this transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to the produced data types.
+                Mapping from the transformed column names to the produced sdtypes.
         """
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
         }
         if self.null_transformer and self.null_transformer.models_missing_values():
-            output_types['is_null'] = 'float'
+            output_sdtypes['is_null'] = 'float'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def _fit(self, data):
         """Fit the transformer to the data.
diff --git a/rdt/transformers/categorical.py b/rdt/transformers/categorical.py
index c994806a0..a8b6cb578 100644
--- a/rdt/transformers/categorical.py
+++ b/rdt/transformers/categorical.py
@@ -32,8 +32,8 @@ class FrequencyEncoder(BaseTransformer):
             or just use the mean for all the replaced values. Defaults to ``False``.
     """
 
-    INPUT_TYPE = 'categorical'
-    OUTPUT_TYPES = {'value': 'float'}
+    INPUT_SDTYPE = 'categorical'
+    OUTPUT_SDTYPES = {'value': 'float'}
     DETERMINISTIC_REVERSE = True
     COMPOSITION_IS_IDENTITY = True
 
@@ -261,7 +261,7 @@ class OneHotEncoder(BaseTransformer):
     Null values are considered just another category.
     """
 
-    INPUT_TYPE = 'categorical'
+    INPUT_SDTYPE = 'categorical'
     DETERMINISTIC_TRANSFORM = True
     DETERMINISTIC_REVERSE = True
 
@@ -299,16 +299,16 @@ def _prepare_data(data):
 
         return data
 
-    def get_output_types(self):
-        """Return the output types produced by this transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes produced by this transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to the produced data types.
+                Mapping from the transformed column names to the produced sdtypes.
         """
-        output_types = {f'value{i}': 'float' for i in range(len(self.dummies))}
+        output_sdtypes = {f'value{i}': 'float' for i in range(len(self.dummies))}
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def _fit(self, data):
         """Fit the transformer to the data.
@@ -416,8 +416,8 @@ class LabelEncoder(BaseTransformer):
             integer value.
     """
 
-    INPUT_TYPE = 'categorical'
-    OUTPUT_TYPES = {'value': 'integer'}
+    INPUT_SDTYPE = 'categorical'
+    OUTPUT_SDTYPES = {'value': 'integer'}
     DETERMINISTIC_TRANSFORM = True
     DETERMINISTIC_REVERSE = True
     COMPOSITION_IS_IDENTITY = True
diff --git a/rdt/transformers/datetime.py b/rdt/transformers/datetime.py
index 721937ffa..41c013427 100644
--- a/rdt/transformers/datetime.py
+++ b/rdt/transformers/datetime.py
@@ -30,7 +30,7 @@ class UnixTimestampEncoder(BaseTransformer):
             https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior.
     """
 
-    INPUT_TYPE = 'datetime'
+    INPUT_SDTYPE = 'datetime'
     DETERMINISTIC_TRANSFORM = True
     DETERMINISTIC_REVERSE = True
     COMPOSITION_IS_IDENTITY = True
@@ -55,20 +55,20 @@ def is_composition_identity(self):
 
         return self.COMPOSITION_IS_IDENTITY
 
-    def get_output_types(self):
-        """Return the output types supported by the transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes supported by the transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to supported data types.
+                Mapping from the transformed column names to supported sdtypes.
         """
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
         }
         if self.null_transformer and self.null_transformer.models_missing_values():
-            output_types['is_null'] = 'float'
+            output_sdtypes['is_null'] = 'float'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def _convert_to_datetime(self, data):
         if data.dtype == 'object':
diff --git a/rdt/transformers/numerical.py b/rdt/transformers/numerical.py
index abb0c1b63..815e0f957 100644
--- a/rdt/transformers/numerical.py
+++ b/rdt/transformers/numerical.py
@@ -42,7 +42,7 @@ class FloatFormatter(BaseTransformer):
             max values seen during ``fit``. Defaults to ``False``.
     """
 
-    INPUT_TYPE = 'numerical'
+    INPUT_SDTYPE = 'numerical'
     DETERMINISTIC_TRANSFORM = True
     DETERMINISTIC_REVERSE = True
     COMPOSITION_IS_IDENTITY = True
@@ -61,20 +61,20 @@ def __init__(self, missing_value_replacement=None, model_missing_values=False,
         self.learn_rounding_scheme = learn_rounding_scheme
         self.enforce_min_max_values = enforce_min_max_values
 
-    def get_output_types(self):
-        """Return the output types supported by the transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes supported by the transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to supported data types.
+                Mapping from the transformed column names to supported sdtypes.
         """
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
         }
         if self.null_transformer and self.null_transformer.models_missing_values():
-            output_types['is_null'] = 'float'
+            output_sdtypes['is_null'] = 'float'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def is_composition_identity(self):
         """Return whether composition of transform and reverse transform produces the input data.
@@ -443,21 +443,21 @@ def __init__(self, missing_value_replacement=None, model_missing_values=False,
         self._max_clusters = max_clusters
         self._weight_threshold = weight_threshold
 
-    def get_output_types(self):
-        """Return the output types supported by the transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes supported by the transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to supported data types.
+                Mapping from the transformed column names to supported sdtypes.
         """
-        output_types = {
+        output_sdtypes = {
             'normalized': 'float',
             'component': 'categorical'
         }
         if self.null_transformer and self.null_transformer.models_missing_values():
-            output_types['is_null'] = 'float'
+            output_sdtypes['is_null'] = 'float'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def _fit(self, data):
         """Fit the transformer to the data.
diff --git a/rdt/transformers/pii/anonymizer.py b/rdt/transformers/pii/anonymizer.py
index 0ff68138d..2a05a51f7 100644
--- a/rdt/transformers/pii/anonymizer.py
+++ b/rdt/transformers/pii/anonymizer.py
@@ -42,7 +42,7 @@ class PIIAnonymizer(BaseTransformer):
 
     DETERMINISTIC_TRANSFORM = False
     DETERMINISTIC_REVERSE = False
-    INPUT_TYPE = 'pii'
+    INPUT_SDTYPE = 'pii'
     null_transformer = None
 
     @staticmethod
@@ -78,18 +78,18 @@ def __init__(self, provider_name=None, function_name='lexify', function_kwargs=N
         self.faker = faker.Faker(locales)
         self._function = getattr(self.faker, function_name)
 
-    def get_output_types(self):
-        """Return the output types supported by the transformer.
+    def get_output_sdtypes(self):
+        """Return the output sdtypes supported by the transformer.
 
         Returns:
             dict:
-                Mapping from the transformed column names to supported data types.
+                Mapping from the transformed column names to supported sdtypes.
         """
-        output_types = {}
+        output_sdtypes = {}
         if self.null_transformer and self.null_transformer.models_missing_values():
-            output_types['is_null'] = 'float'
+            output_sdtypes['is_null'] = 'float'
 
-        return self._add_prefix(output_types)
+        return self._add_prefix(output_sdtypes)
 
     def _fit(self, data):
         """Fit the transformer to the data.


Test patch:
diff --git a/tests/contributing.py b/tests/contributing.py
index c1f917950..1596e99a3 100644
--- a/tests/contributing.py
+++ b/tests/contributing.py
@@ -27,17 +27,17 @@
 CHECK_DETAILS = {
     '_validate_dataset_generators': (
         'Dataset Generators',
-        'At least one Dataset Generator exists for the Transformer data type.',
+        'At least one Dataset Generator exists for the Transformer sdtype.',
     ),
     '_validate_transformed_data': (
-        'Output Types',
-        'The Transformer can transform data and produce output(s) of the indicated data type(s).',
+        'Output Sdtypes',
+        'The Transformer can transform data and produce output(s) of the indicated sdtype(s).',
     ),
     '_validate_reverse_transformed_data': (
         'Reverse Transform',
         (
             'The Transformer can reverse transform the data it produces, going back to the '
-            'original data type.'
+            'original sdtype.'
         ),
     ),
     '_validate_composition': (
@@ -55,7 +55,7 @@
         'Hypertransformer can reverse transform',
         (
             'The HyperTransformer is able to reverse the data that it has previously transformed '
-            'and restore the original data type.'
+            'and restore the original sdtype.'
         ),
     ),
 }
@@ -359,14 +359,14 @@ def validate_transformer_quality(transformer):
 
     This function creates a DataFrame containing the results
     from running the quality tests for this transformer against
-    all the datasets with columns of its input type. It does the
+    all the datasets with columns of its input sdtype. It does the
     following steps:
     1. A DataFrame containing the regression scores obtained from running the
-    transformers of the input type against the datasets in the test cases is
+    transformers of the input sdtype against the datasets in the test cases is
     created. Each row in the DataFrame has the transformer name, dataset name,
     column name and score. The scores are computed as follows:
-        - For every transformer of the data type, transform all the
-        columns of that data type.
+        - For every transformer of the sdtype, transform all the
+        columns of that sdtype.
         - For every numerical column in the dataset, the transformed
         columns are used as features to train a regression model.
         - The score is the coefficient of determination obtained from
@@ -375,7 +375,7 @@ def validate_transformer_quality(transformer):
     a transformer name, dataset name, average score for the dataset,
     a score comparing the transformer's average score for the dataset to
     the average of the average score for the dataset across all transformers of
-    the same data type, and whether or not the score passed the test threshold.
+    the same sdtype, and whether or not the score passed the test threshold.
 
     Returns:
         DataFrame containing the following columns for each dataset the transformer
@@ -386,8 +386,8 @@ def validate_transformer_quality(transformer):
 
     print(f'Validating Quality Tests for transformer {transformer.__name__}\n')
 
-    input_type = transformer.get_input_type()
-    test_cases = get_test_cases({input_type})
+    input_sdtype = transformer.get_input_sdtype()
+    test_cases = get_test_cases({input_sdtype})
     regression_scores = get_regression_scores(test_cases, get_transformers_by_type())
     results = get_results_table(regression_scores)
 
@@ -415,9 +415,9 @@ def validate_transformer_quality(transformer):
 def validate_transformer_performance(transformer):
     """Validate the performance of a transformer.
 
-    Run the specified Transformer on all the Dataset Generators of the indicated data type
+    Run the specified Transformer on all the Dataset Generators of the indicated sdtype
     and produce a report about its performance and how it compares to the other
-    Transformers of the same data type.
+    Transformers of the same sdtype.
 
     Args:
         transformer (string or rdt.transformers.BaseTransformer):
@@ -432,9 +432,9 @@ def validate_transformer_performance(transformer):
 
     print(f'Validating Performance for transformer {transformer.__name__}\n')
 
-    data_type = transformer.get_input_type()
-    transformers = get_transformers_by_type().get(data_type, [])
-    dataset_generators = get_dataset_generators_by_type().get(data_type, [])
+    sdtype = transformer.get_input_sdtype()
+    transformers = get_transformers_by_type().get(sdtype, [])
+    dataset_generators = get_dataset_generators_by_type().get(sdtype, [])
 
     total_results = pd.DataFrame()
     for current_transformer in transformers:
diff --git a/tests/integration/test_hyper_transformer.py b/tests/integration/test_hyper_transformer.py
index 47920abcc..4eb17cc40 100644
--- a/tests/integration/test_hyper_transformer.py
+++ b/tests/integration/test_hyper_transformer.py
@@ -14,8 +14,8 @@
 
 class DummyTransformerNumerical(BaseTransformer):
 
-    INPUT_TYPE = 'categorical'
-    OUTPUT_TYPES = {
+    INPUT_SDTYPE = 'categorical'
+    OUTPUT_SDTYPES = {
         'value': 'float'
     }
 
@@ -31,8 +31,8 @@ def _reverse_transform(self, data):
 
 class DummyTransformerNotMLReady(BaseTransformer):
 
-    INPUT_TYPE = 'datetime'
-    OUTPUT_TYPES = {
+    INPUT_SDTYPE = 'datetime'
+    OUTPUT_SDTYPES = {
         'value': 'categorical',
     }
 
@@ -131,10 +131,10 @@ def test_hypertransformer_default_inputs():
 
     Setup:
         - Patch the ``DEFAULT_TRANSFORMERS`` to use the ``FrequencyEncoder``
-        for categorical data types, so that the output is predictable.
+        for categorical sdtypes, so that the output is predictable.
 
     Input:
-        - A dataframe with every data type.
+        - A dataframe with every sdtype.
 
     Expected behavior:
         - The transformed data should contain all the ML ready data.
@@ -178,7 +178,7 @@ def test_hypertransformer_field_transformers():
 
     This tests that the transformers specified in the ``field_transformers``
     argument are used. Any output of a transformer that is not ML ready (not
-    in the ``_transform_output_types`` list) should be recursively transformed
+    in the ``_transform_output_sdtypes`` list) should be recursively transformed
     till it is.
 
     Setup:
@@ -187,7 +187,7 @@ def test_hypertransformer_field_transformers():
 
     Input:
         - A dict mapping each field to a transformer.
-        - A dataframe with every data type.
+        - A dataframe with every sdtype.
 
     Expected behavior:
         - The transformed data should contain all the ML ready data.
@@ -280,7 +280,7 @@ def test_with_unfitted_columns():
     """HyperTransform should be able to transform even if there are unseen columns in data."""
     # Setup
     data = get_input_data()
-    ht = HyperTransformer(default_data_type_transformers={'categorical': FrequencyEncoder})
+    ht = HyperTransformer(default_sdtype_transformers={'categorical': FrequencyEncoder})
     ht.fit(data)
 
     # Run
diff --git a/tests/integration/test_transformers.py b/tests/integration/test_transformers.py
index 605ea0dc3..fe598841c 100644
--- a/tests/integration/test_transformers.py
+++ b/tests/integration/test_transformers.py
@@ -11,7 +11,7 @@
 DATA_SIZE = 1000
 TEST_COL = 'test_col'
 
-PRIMARY_DATA_TYPES = ['boolean', 'categorical', 'datetime', 'numerical']
+PRIMARY_SDTYPES = ['boolean', 'categorical', 'datetime', 'numerical']
 
 # Additional arguments for transformers
 TRANSFORMER_ARGS = {
@@ -49,8 +49,8 @@
     },
 }
 
-# Mapping of rdt data type to dtype
-DATA_TYPE_TO_DTYPES = {
+# Mapping of rdt sdtype to dtype
+SDTYPE_TO_DTYPES = {
     'boolean': ['b', 'O'],
     'categorical': ['O', 'i', 'f'],
     'datetime': ['M'],
@@ -90,31 +90,31 @@ def _get_all_transformers():
 
 
 def _build_generator_map():
-    """Build a map of data type to data generator.
+    """Build a map of sdtype to data generator.
 
     Output:
         dict:
-            A mapping of data type (str) to a list of data
+            A mapping of sdtype (str) to a list of data
             generators (rdt.tests.datasets.BaseDatasetGenerator).
     """
     generators = defaultdict(list)
 
     for generator in BaseDatasetGenerator.get_subclasses():
-        generators[generator.DATA_TYPE].append(generator)
+        generators[generator.SDTYPE].append(generator)
 
     return generators
 
 
-def _find_dataset_generators(data_type, generators):
-    """Find the dataset generators for the given data_type."""
-    if data_type is None:
+def _find_dataset_generators(sdtype, generators):
+    """Find the dataset generators for the given sdtype."""
+    if sdtype is None:
         primary_generators = []
-        for primary_data_type in PRIMARY_DATA_TYPES:
-            primary_generators.extend(_find_dataset_generators(primary_data_type, generators))
+        for primary_sdtype in PRIMARY_SDTYPES:
+            primary_generators.extend(_find_dataset_generators(primary_sdtype, generators))
 
         return primary_generators
 
-    return generators.get(data_type, [])
+    return generators.get(sdtype, [])
 
 
 def _validate_dataset_generators(dataset_generators):
@@ -124,14 +124,14 @@ def _validate_dataset_generators(dataset_generators):
 
 def _validate_transformed_data(transformer, transformed_data):
     """Check that the transformed data is the expected dtype."""
-    expected_data_types = transformer.get_output_types()
+    expected_sdtypes = transformer.get_output_sdtypes()
     transformed_dtypes = transformed_data.dtypes
 
-    for column, expected_data_type in expected_data_types.items():
+    for column, expected_sdtype in expected_sdtypes.items():
         message = f'Column {column} is expected but not found in transformed data.'
         assert column in transformed_data, message
-        message = f'Column {column} is not the expected data type {expected_data_type}'
-        assert transformed_dtypes[column].kind in DATA_TYPE_TO_DTYPES[expected_data_type], message
+        message = f'Column {column} is not the expected sdtype {expected_sdtype}'
+        assert transformed_dtypes[column].kind in SDTYPE_TO_DTYPES[expected_sdtype], message
 
 
 def _validate_reverse_transformed_data(transformer, reversed_data, input_dtype):
@@ -139,9 +139,9 @@ def _validate_reverse_transformed_data(transformer, reversed_data, input_dtype):
 
     Expect that the dtype is equal to the dtype of the input data.
     """
-    expected_data_type = transformer.get_input_type()
-    message = f'Reverse transformed data is not the expected data type {expected_data_type}'
-    assert reversed_data.dtypes[TEST_COL].kind in DATA_TYPE_TO_DTYPES[expected_data_type], message
+    expected_sdtype = transformer.get_input_sdtype()
+    message = f'Reverse transformed data is not the expected sdtype {expected_sdtype}'
+    assert reversed_data.dtypes[TEST_COL].kind in SDTYPE_TO_DTYPES[expected_sdtype], message
 
 
 def _validate_composition(transformer, reversed_data, input_data):
@@ -217,14 +217,14 @@ def _validate_hypertransformer_transformed_data(transformed_data):
     assert transformed_data.notna().all(axis=None), 'Transformed data has nulls.'
 
     for dtype in transformed_data.dtypes:
-        assert dtype.kind in DATA_TYPE_TO_DTYPES['numerical'], 'Transformed data is not numerical.'
+        assert dtype.kind in SDTYPE_TO_DTYPES['numerical'], 'Transformed data is not numerical.'
 
 
 def _validate_hypertransformer_reverse_transformed_data(transformer, reversed_data):
     """Check that the reverse transformed data has the same dtype as the input."""
-    expected_data_type = transformer().get_input_type()
-    message = f'Reversed transformed data is not the expected data type {expected_data_type}'
-    assert reversed_data.dtype.kind in DATA_TYPE_TO_DTYPES[expected_data_type], message
+    expected_sdtype = transformer().get_input_sdtype()
+    message = f'Reversed transformed data is not the expected sdtype {expected_sdtype}'
+    assert reversed_data.dtype.kind in SDTYPE_TO_DTYPES[expected_sdtype], message
 
 
 def _test_transformer_with_hypertransformer(transformer_class, input_data, steps):
@@ -280,9 +280,9 @@ def validate_transformer(transformer, steps=None, subtests=None):
         subtests:
             Whether or not to test with subtests.
     """
-    input_data_type = transformer.get_input_type()
+    input_sdtype = transformer.get_input_sdtype()
 
-    dataset_generators = _find_dataset_generators(input_data_type, generators)
+    dataset_generators = _find_dataset_generators(input_sdtype, generators)
     _validate_helper(_validate_dataset_generators, [dataset_generators], steps)
 
     for dg in dataset_generators:
diff --git a/tests/integration/transformers/test_base.py b/tests/integration/transformers/test_base.py
index 13ea81032..cd7cef805 100644
--- a/tests/integration/transformers/test_base.py
+++ b/tests/integration/transformers/test_base.py
@@ -30,8 +30,8 @@ def test_dummy_transformer_series_output():
     # Setup
     class DummyTransformer(BaseTransformer):
 
-        INPUT_TYPE = 'boolean'
-        OUTPUT_TYPES = {
+        INPUT_SDTYPE = 'boolean'
+        OUTPUT_SDTYPES = {
             'value': 'float'
         }
 
@@ -88,8 +88,8 @@ def test_dummy_transformer_dataframe_output():
     # Setup
     class DummyTransformer(BaseTransformer):
 
-        INPUT_TYPE = 'boolean'
-        OUTPUT_TYPES = {
+        INPUT_SDTYPE = 'boolean'
+        OUTPUT_SDTYPES = {
             'value': 'float',
             'null': 'float'
         }
diff --git a/tests/performance/test_performance.py b/tests/performance/test_performance.py
index 3b939f144..6bf1498c1 100644
--- a/tests/performance/test_performance.py
+++ b/tests/performance/test_performance.py
@@ -20,8 +20,8 @@ def _get_performance_test_cases():
     dataset_generators = get_dataset_generators_by_type()
     transformers = get_transformers_by_type()
 
-    for data_type, transformers_for_type in transformers.items():
-        dataset_generators_for_type = dataset_generators.get(data_type, [])
+    for sdtype, transformers_for_type in transformers.items():
+        dataset_generators_for_type = dataset_generators.get(sdtype, [])
 
         for transformer in transformers_for_type:
             if transformer in SANDBOX_TRANSFORMERS:
diff --git a/tests/quality/test_quality.py b/tests/quality/test_quality.py
index c7ec19cd5..9c2315405 100644
--- a/tests/quality/test_quality.py
+++ b/tests/quality/test_quality.py
@@ -13,7 +13,7 @@
 R2_THRESHOLD = 0.2
 TEST_THRESHOLD = 0.3
 MAX_SIZE = 5000000
-TYPES_TO_SKIP = {'numerical', 'float', 'integer', 'id', None}
+SDTYPES_TO_SKIP = {'numerical', 'float', 'integer', 'id', None}
 
 TYPE_TO_DTYPE = {
     'numerical': ['number'],
@@ -41,16 +41,16 @@ def get_regression_score(features, target):
     return np.mean(scores)
 
 
-def find_columns(data, data_type, metadata=None):
+def find_columns(data, sdtype, metadata=None):
     if metadata:
         return {
             column
             for column in metadata['fields']
-            if metadata['fields'][column]['type'] == data_type
+            if metadata['fields'][column]['type'] == sdtype
         }
 
     columns = set()
-    dtypes = TYPE_TO_DTYPE.get(data_type, data_type)
+    dtypes = TYPE_TO_DTYPE.get(sdtype, sdtype)
     for dtype in dtypes:
         selected = data.select_dtypes(dtype)
         columns.update(set(selected.columns))
@@ -58,14 +58,14 @@ def find_columns(data, data_type, metadata=None):
     return columns
 
 
-def get_transformer_regression_scores(data, data_type, dataset_name, transformers, metadata=None):
+def get_transformer_regression_scores(data, sdtype, dataset_name, transformers, metadata=None):
     """Returns regression scores for a list of transformers.
 
     Args:
         data (pandas.DataFrame):
             The dataset containing columns to predict and train with.
-        data_type (string):
-            The data type of the transformer.
+        sdtype (string):
+            The sdtype of the transformer.
         dataset_name (string):
             The name of the dataset.
         transformers (list):
@@ -77,10 +77,10 @@ def get_transformer_regression_scores(data, data_type, dataset_name, transformer
         pandas.DataFrame containing the score for each column predicted
         in the dataset. To get the scores, a regression model is trained.
         The features used are the output of transforming all the columns
-        of the data type using a transformer in the transformers list.
+        of the sdtype using a transformer in the transformers list.
     """
     columns_to_predict = find_columns(data, 'numerical')
-    columns_to_transform = find_columns(data, data_type, metadata)
+    columns_to_transform = find_columns(data, sdtype, metadata)
     scores = pd.DataFrame()
     features = data[columns_to_transform]
 
@@ -90,7 +90,7 @@ def get_transformer_regression_scores(data, data_type, dataset_name, transformer
         target = numerical_transformer.fit_transform(target, column)
         target = format_array(target)
         for transformer in transformers:
-            ht = HyperTransformer(default_data_type_transformers={data_type: transformer})
+            ht = HyperTransformer(default_sdtype_transformers={sdtype: transformer})
             ht.fit(features)
             transformed_features = ht.transform(features).to_numpy()
             score = get_regression_score(transformed_features, target)
@@ -105,14 +105,14 @@ def get_transformer_regression_scores(data, data_type, dataset_name, transformer
     return scores
 
 
-def get_test_cases(data_types):
+def get_test_cases(sdtypes):
     test_cases = []
     path = os.path.join(os.path.dirname(__file__), 'dataset_info.csv')
     datasets = pd.read_csv(path)
     for _, row in datasets.iterrows():
         if row['table_size'] < MAX_SIZE and row['modality'] == 'single-table':
             table_types = eval(row['table_types'])
-            table_types_to_test = data_types.intersection(table_types)
+            table_types_to_test = sdtypes.intersection(table_types)
             if len(table_types_to_test) > 0:
                 test_cases.append((row['name'], row['table_name'], table_types_to_test))
 
@@ -126,10 +126,10 @@ def get_regression_scores(test_cases, transformers_by_type):
         test_cases (list):
             List of test cases. Each test case is a tuple containing
             the dataset name, the name of the table to use from the
-            dataset, and the data types to test against for that table.
+            dataset, and the sdtypes to test against for that table.
         transformers_by_type (dict):
-            Dict mapping data type to list of transformers that have that
-            type as their input type.
+            Dict mapping sdtype to list of transformers that have that
+            type as their input sdtype.
 
     Returns:
         DataFrame where each row has a dataset name, transformer name,
@@ -137,13 +137,13 @@ def get_regression_scores(test_cases, transformers_by_type):
         coefficient of determination for the transformer predicting the column.
     """
     all_scores = defaultdict(pd.DataFrame)
-    for dataset_name, table_name, data_types in test_cases:
+    for dataset_name, table_name, sdtypes in test_cases:
         (data, metadata) = download_single_table(dataset_name, table_name)
-        for data_type in data_types:
-            transformers = transformers_by_type[data_type]
+        for sdtype in sdtypes:
+            transformers = transformers_by_type[sdtype]
             regression_scores = get_transformer_regression_scores(
-                data, data_type, dataset_name, transformers, metadata)
-            all_scores[data_type] = all_scores[data_type].append(
+                data, sdtype, dataset_name, transformers, metadata)
+            all_scores[sdtype] = all_scores[sdtype].append(
                 regression_scores, ignore_index=True)
 
     return all_scores
@@ -154,7 +154,7 @@ def get_results_table(regression_scores):
 
     Args:
         regression_scores (dict):
-            Dict mapping data types to a DataFrame where each row has
+            Dict mapping sdtypes to a DataFrame where each row has
             a table name, column name, transformer name and coefficient
             of determination for that transformer predicting that column.
 
@@ -162,7 +162,7 @@ def get_results_table(regression_scores):
         A DataFrame where each row has a transformer name, dataset name,
         average score for the dataset and a score comparing the transformer's
         average score for the dataset to the average of the average score for
-        the dataset across all transformers of the same data type.
+        the dataset across all transformers of the same sdtype.
     """
     results = pd.DataFrame()
     for _, scores in regression_scores.items():
@@ -199,14 +199,14 @@ def test_quality(subtests):
 
     This test has multiple steps.
         1. It creates a list of test cases. Each test case has a dataset
-        and a set of data types to test for the dataset.
-        2. A dictionary is created mapping data types to a DataFrame
+        and a set of sdtypes to test for the dataset.
+        2. A dictionary is created mapping sdtypes to a DataFrame
         containing the regression scores obtained from running the
-        transformers of that type against the datasets in the test cases.
+        transformers of that sdtype against the datasets in the test cases.
         Each row in the DataFrame has the transformer name, dataset name,
         column name and score. The scores are computed as follows:
-            - For every transformer of the data type, transform all the
-            columns of that data type.
+            - For every transformer of the sdtype, transform all the
+            columns of that sdtype.
             - For every numerical column in the dataset, the transformed
             columns are used as features to train a regression model.
             - The score is the coefficient of determination obtained from
@@ -215,18 +215,18 @@ def test_quality(subtests):
         a transformer name, dataset name, average score for the dataset and a score
         comparing the transformer's average score for the dataset to the average
         of the average score for the dataset across all transformers of the same
-        data type.
+        sdtype.
         4. For every unique transformer in the results, a test is run to check
         that the transformer's score for each table is either higher than the
         threshold, or the comparitive score is higher than the threshold.
     """
     transformers_by_type = get_transformers_by_type()
-    data_types_to_test = {
-        data_type
-        for data_type in transformers_by_type.keys()
-        if data_type not in TYPES_TO_SKIP
+    sdtypes_to_test = {
+        sdtype
+        for sdtype in transformers_by_type.keys()
+        if sdtype not in SDTYPES_TO_SKIP
     }
-    test_cases = get_test_cases(data_types_to_test)
+    test_cases = get_test_cases(sdtypes_to_test)
     all_regression_scores = get_regression_scores(test_cases, transformers_by_type)
     results = get_results_table(all_regression_scores)
 
diff --git a/tests/unit/test_hyper_transformer.py b/tests/unit/test_hyper_transformer.py
index 92df3fdc9..f07fc671f 100644
--- a/tests/unit/test_hyper_transformer.py
+++ b/tests/unit/test_hyper_transformer.py
@@ -107,8 +107,8 @@ def test___init__(self, validation_mock, multi_column_mock):
         # Asserts
         assert ht.copy is True
         assert ht.field_transformers == {}
-        assert ht.default_data_type_transformers == {}
-        assert ht.field_data_types == {}
+        assert ht.default_sdtype_transformers == {}
+        assert ht.field_sdtypes == {}
         multi_column_mock.assert_called_once()
         validation_mock.assert_called_once()
 
@@ -143,12 +143,12 @@ def test__create_multi_column_fields(self):
         """Test the ``_create_multi_column_fields`` method.
 
         This tests that the method goes through both the ``field_transformers``
-        dict and ``field_data_types`` dict to find multi_column fields and map
+        dict and ``field_sdtypes`` dict to find multi_column fields and map
         each column to its corresponding tuple.
 
         Setup:
             - instance.field_transformers will be populated with multi-column fields
-            - instance.field_data_types will be populated with multi-column fields
+            - instance.field_sdtypes will be populated with multi-column fields
 
         Output:
             - A dict mapping each column name that is part of a multi-column
@@ -162,7 +162,7 @@ def test__create_multi_column_fields(self):
             ('c', 'd'): UnixTimestampEncoder,
             'e': FloatFormatter
         }
-        ht.field_data_types = {
+        ht.field_sdtypes = {
             'f': 'categorical',
             ('g', 'h'): 'datetime'
         }
@@ -184,17 +184,17 @@ def test__get_next_transformer_field_transformer(self):
 
         This tests that if the transformer is defined in the
         ``instance.field_transformers`` dict, then it is returned
-        even if the output type is final.
+        even if the output sdtype is final.
 
         Setup:
             - field_transformers is given a transformer for the
             output field.
-            - default_data_type_transformers will be given a different transformer
-            for the output type of the output field.
+            - default_sdtype_transformers will be given a different transformer
+            for the output sdtype of the output field.
 
         Input:
             - An output field name in field_transformers.
-            - Output type is numerical.
+            - Output sdtype  is numerical.
             - next_transformers is None.
 
         Output:
@@ -204,7 +204,7 @@ def test__get_next_transformer_field_transformer(self):
         transformer = FloatFormatter()
         ht = HyperTransformer(
             field_transformers={'a.out': transformer},
-            default_data_type_transformers={'numerical': GaussianNormalizer()}
+            default_sdtype_transformers={'numerical': GaussianNormalizer()}
         )
 
         # Run
@@ -213,21 +213,21 @@ def test__get_next_transformer_field_transformer(self):
         # Assert
         assert next_transformer == transformer
 
-    def test__get_next_transformer_final_output_type(self):
+    def test__get_next_transformer_final_output_sdtype(self):
         """Test the ``_get_next_transformer method.
 
         This tests that if the transformer is not defined in the
-        ``instance.field_transformers`` dict and its output type
-        is in ``instance._transform_output_types``, then ``None``
+        ``instance.field_transformers`` dict and its output sdtype
+        is in ``instance._transform_output_sdtypes``, then ``None``
         is returned.
 
         Setup:
-            - default_data_type_transformers will be given a transformer
-            for the output type of the output field.
+            - default_sdtype_transformers will be given a transformer
+            for the output sdtype of the output field.
 
         Input:
             - An output field name in field_transformers.
-            - Output type is numerical.
+            - Output sdtype  is numerical.
             - next_transformers is None.
 
         Output:
@@ -235,7 +235,7 @@ def test__get_next_transformer_final_output_type(self):
         """
         # Setup
         ht = HyperTransformer(
-            default_data_type_transformers={'numerical': GaussianNormalizer()}
+            default_sdtype_transformers={'numerical': GaussianNormalizer()}
         )
 
         # Run
@@ -248,18 +248,18 @@ def test__get_next_transformer_next_transformers(self):
         """Test the ``_get_next_transformer method.
 
         This tests that if the transformer is not defined in the
-        ``instance.field_transformers`` dict and its output type
-        is not in ``instance._transform_output_types`` and the
+        ``instance.field_transformers`` dict and its output sdtype
+        is not in ``instance._transform_output_sdtypes`` and the
         ``next_transformers`` dict has a transformer for the output
         field, then it is used.
 
         Setup:
-            - default_data_type_transformers will be given a transformer
-            for the output type of the output field.
+            - default_sdtype_transformers will be given a transformer
+            for the output sdtype of the output field.
 
         Input:
             - An output field name in field_transformers.
-            - Output type is categorical.
+            - Output sdtype  is categorical.
             - next_transformers is has a transformer defined
             for the output field.
 
@@ -269,7 +269,7 @@ def test__get_next_transformer_next_transformers(self):
         # Setup
         transformer = FrequencyEncoder()
         ht = HyperTransformer(
-            default_data_type_transformers={'categorical': OneHotEncoder()}
+            default_sdtype_transformers={'categorical': OneHotEncoder()}
         )
         next_transformers = {'a.out': transformer}
 
@@ -285,7 +285,7 @@ def test__get_next_transformer_default_transformer(self, mock):
 
         This tests that if the transformer is not defined in the
         ``instance.field_transformers`` dict or ``next_transformers``
-        and its output type is not in ``instance._transform_output_types``
+        and its output sdtype is not in ``instance._transform_output_sdtypes``
         then the default_transformer is used.
 
         Setup:
@@ -293,7 +293,7 @@ def test__get_next_transformer_default_transformer(self, mock):
 
         Input:
             - An output field name in field_transformers.
-            - Output type is categorical.
+            - Output sdtype  is categorical.
             - next_transformers is None.
 
         Output:
@@ -303,7 +303,7 @@ def test__get_next_transformer_default_transformer(self, mock):
         transformer = FrequencyEncoder(add_noise=True)
         mock.return_value = transformer
         ht = HyperTransformer(
-            default_data_type_transformers={'categorical': OneHotEncoder()}
+            default_sdtype_transformers={'categorical': OneHotEncoder()}
         )
 
         # Run
@@ -313,25 +313,25 @@ def test__get_next_transformer_default_transformer(self, mock):
         assert isinstance(next_transformer, FrequencyEncoder)
         assert next_transformer.add_noise is False
 
-    def test__populate_field_data_types(self):
-        """Test the ``_populate_field_data_types`` method.
+    def test__populate_field_sdtypes(self):
+        """Test the ``_populate_field_sdtypes`` method.
 
-        This tests that if any field types are missing in the
-        provided field_data_types dict, that the rest of the values
-        are filled in using the data types for the dtype.
+        This tests that if any field sdtypes are missing in the
+        provided field_sdtypes dict, that the rest of the values
+        are filled in using the sdtypes for the dtype.
 
         Setup:
-            - field_data_types will only define a few of the fields.
+            - field_sdtypes will only define a few of the fields.
 
         Input:
-            - A DataFrame of various types.
+            - A DataFrame of various sdtypes.
 
         Expected behavior:
-            - field types will have values for all fields in
+            - field sdtypes will have values for all fields in
             the data.
         """
         # Setup
-        ht = HyperTransformer(field_data_types={'a': 'numerical', 'b': 'categorical'})
+        ht = HyperTransformer(field_sdtypes={'a': 'numerical', 'b': 'categorical'})
         data = pd.DataFrame({
             'a': [np.nan, 1, 2, 3],
             'b': [np.nan, 'category1', 'category2', 'category3'],
@@ -340,16 +340,16 @@ def test__populate_field_data_types(self):
         })
 
         # Run
-        ht._populate_field_data_types(data)
+        ht._populate_field_sdtypes(data)
 
         # Assert
         expected = {'a': 'numerical', 'b': 'categorical', 'c': 'boolean', 'd': 'float'}
-        assert ht.field_data_types == expected
+        assert ht.field_sdtypes == expected
 
     def test_detect_initial_config(self):
         """Test the ``detect_initial_config`` method.
 
-        This tests that ``field_data_types`` and ``field_transformers`` are correctly set,
+        This tests that ``field_sdtypes`` and ``field_transformers`` are correctly set,
         and that the appropriate configuration is printed.
 
         Input:
@@ -373,7 +373,7 @@ def test_detect_initial_config(self):
         output = f_out.getvalue()
 
         # Assert
-        assert ht.field_data_types == {
+        assert ht.field_sdtypes == {
             'col1': 'float',
             'col2': 'categorical',
             'col3': 'boolean',
@@ -424,7 +424,7 @@ def test__fit_field_transformer(self, get_transformer_instance_mock):
         Setup:
             - A mock for ``get_transformer_instance``.
             - A mock for the transformer returned by ``get_transformer_instance``.
-            The ``get_output_types`` method will return two outputs, one that
+            The ``get_output_sdtypes`` method will return two outputs, one that
             is ML ready and one that isn't.
 
         Input:
@@ -444,7 +444,7 @@ def test__fit_field_transformer(self, get_transformer_instance_mock):
         })
         transformer1 = Mock()
         transformer2 = Mock()
-        transformer1.get_output_types.return_value = {
+        transformer1.get_output_sdtypes.return_value = {
             'a.out1': 'categorical',
             'a.out2': 'numerical'
         }
@@ -452,7 +452,7 @@ def test__fit_field_transformer(self, get_transformer_instance_mock):
             'a.out1': transformer2
         }
         transformer1.transform.return_value = transformed_data1
-        transformer2.get_output_types.return_value = {
+        transformer2.get_output_sdtypes.return_value = {
             'a.out1.value': 'numerical'
         }
         transformer2.get_next_transformers.return_value = None
@@ -503,7 +503,7 @@ def test__fit_field_transformer_multi_column_field_not_ready(
         Setup:
             - A mock for ``get_transformer_instance``.
             - A mock for the transformer returned by ``get_transformer_instance``.
-            The ``get_output_types`` method will return one output that is part of
+            The ``get_output_sdtypes`` method will return one output that is part of
             a multi-column field.
             - A mock for ``_multi_column_fields`` to return the multi-column field.
 
@@ -527,7 +527,7 @@ def test__fit_field_transformer_multi_column_field_not_ready(
         })
         transformer1 = Mock()
         transformer2 = Mock()
-        transformer1.get_output_types.return_value = {
+        transformer1.get_output_sdtypes.return_value = {
             'a.out1': 'categorical'
         }
         transformer1.get_next_transformers.return_value = None
@@ -700,11 +700,11 @@ def test_get_config(self):
             - transformers: Maps to a dictionary that maps column names to transformers.
 
         Setup:
-            - Add entries to the ``field_data_types`` attribute.
+            - Add entries to the ``field_sdtypes`` attribute.
             - Add entries to the ``field_transformers`` attribute.
 
         Output:
-            - A dictionary with the key sdtypes mapping to the ``field_data_types`` attribute and
+            - A dictionary with the key sdtypes mapping to the ``field_sdtypes`` attribute and
             the key transformers mapping to the ``field_transformers`` attribute.
         """
         # Setup
@@ -713,7 +713,7 @@ def test_get_config(self):
             'column1': FloatFormatter(),
             'column2': FrequencyEncoder()
         }
-        ht.field_data_types = {
+        ht.field_sdtypes = {
             'column1': 'numerical',
             'column2': 'categorical'
         }
@@ -723,7 +723,7 @@ def test_get_config(self):
 
         # Assert
         expected_config = {
-            'sdtypes': ht.field_data_types,
+            'sdtypes': ht.field_sdtypes,
             'transformers': ht.field_transformers
         }
         assert config == expected_config
@@ -755,7 +755,7 @@ def test_get_config_empty(self):
     def test_set_config(self):
         """Test the ``set_config`` method.
 
-        The method should set the ``instance.field_transformers`` and ``instance.field_data_types``
+        The method should set the ``instance.field_transformers`` and ``instance.field_sdtypes``
         attributes based on the config.
 
         Setup:
@@ -767,7 +767,7 @@ def test_set_config(self):
                 - sdtypes: Maps to a dict that maps column names to ``sdtypes``.
 
         Expected behavior:
-            - The ``instance.field_transformers`` and ``instance.field_data_types`` should be set.
+            - The ``instance.field_transformers`` and ``instance.field_sdtypes`` should be set.
         """
         # Setup
         transformers = {
@@ -791,7 +791,7 @@ def test_set_config(self):
         # Assert
         ht._validate_config.assert_called_once_with(config)
         assert ht.field_transformers == config['transformers']
-        assert ht.field_data_types == config['sdtypes']
+        assert ht.field_sdtypes == config['sdtypes']
 
     def get_data(self):
         return pd.DataFrame({
@@ -839,9 +839,9 @@ def test_fit(self, get_default_transformer_mock):
         """Test the ``fit`` method.
 
         Tests that the ``fit`` method loops through the fields in ``field_transformers``
-        and ``field_data_types`` that are in the data. It should try to find a transformer
-        in ``default_data_type_transformers`` and then use the default if it doesn't find one
-        when looping through ``field_data_types``. It should then call ``_fit_field_transformer``
+        and ``field_sdtypes`` that are in the data. It should try to find a transformer
+        in ``default_sdtype_transformers`` and then use the default if it doesn't find one
+        when looping through ``field_sdtypes``. It should then call ``_fit_field_transformer``
         with the correct arguments.
 
         Setup:
@@ -850,7 +850,7 @@ def test_fit(self, get_default_transformer_mock):
             - A mock for ``get_default_tranformer``.
 
         Input:
-            - A DataFrame with multiple columns of different types.
+            - A DataFrame with multiple columns of different sdtypes.
 
         Expected behavior:
             - The ``_fit_field_transformer`` mock should be called with the correct
@@ -870,14 +870,14 @@ def test_fit(self, get_default_transformer_mock):
             'float': float_transformer,
             'integer.out': int_out_transformer
         }
-        default_data_type_transformers = {
+        default_sdtype_transformers = {
             'boolean': bool_transformer,
             'categorical': categorical_transformer
         }
         get_default_transformer_mock.return_value = datetime_transformer
         ht = HyperTransformer(
             field_transformers=field_transformers,
-            default_data_type_transformers=default_data_type_transformers
+            default_sdtype_transformers=default_sdtype_transformers
         )
         ht._fit_field_transformer = Mock()
         ht._fit_field_transformer.return_value = data
@@ -913,7 +913,7 @@ def test_transform(self):
             - The ``_output_columns`` will be hardcoded.
 
         Input:
-            - A DataFrame of multiple types.
+            - A DataFrame of multiple sdtypes.
 
         Output:
             - The transformed DataFrame with the correct columns dropped.
@@ -964,7 +964,7 @@ def test_transform_raises_error_if_not_fitted(self):
             - The ``_fitted`` attribute will be False.
 
         Input:
-            - A DataFrame of multiple types.
+            - A DataFrame of multiple sdtypes.
 
         Expected behavior:
             - A ``NotFittedError`` is raised.
@@ -1015,7 +1015,7 @@ def test_reverse_transform(self):
             - The ``_input_columns`` will be hardcoded.
 
         Input:
-            - A DataFrame of multiple types.
+            - A DataFrame of multiple sdtypes.
 
         Output:
             - The reverse transformed DataFrame with the correct columns dropped.
@@ -1066,7 +1066,7 @@ def test_reverse_transform_raises_error_if_not_fitted(self):
             - The ``_fitted`` attribute will be False.
 
         Input:
-            - A DataFrame of multiple types.
+            - A DataFrame of multiple sdtypes.
 
         Expected behavior:
             - A ``NotFittedError`` is raised.
@@ -1079,81 +1079,81 @@ def test_reverse_transform_raises_error_if_not_fitted(self):
         with pytest.raises(NotFittedError):
             ht.reverse_transform(data)
 
-    def test_update_field_data_types(self):
-        """Test the ``update_field_data_types`` method.
+    def test_update_field_sdtypes(self):
+        """Test the ``update_field_sdtypes`` method.
 
-        This method should update the ``field_data_types`` attribute.
+        This method should update the ``field_sdtypes`` attribute.
 
         Setup:
-            - Initialize ``HyperTransformer`` with ``field_data_types`` having
+            - Initialize ``HyperTransformer`` with ``field_sdtypes`` having
             one entry.
 
         Input:
-            - Dict mapping fields to data types.
+            - Dict mapping fields to sdtypes.
         """
         # Setup
-        field_data_types = {
+        field_sdtypes = {
             'a': 'categorical',
             'b': 'integer'
         }
-        ht = HyperTransformer(field_data_types={'a': 'float'})
+        ht = HyperTransformer(field_sdtypes={'a': 'float'})
         ht._transformers_sequence = [FrequencyEncoder()]
         ht._unfit = Mock()
 
         # Run
-        ht.update_field_data_types(field_data_types)
+        ht.update_field_sdtypes(field_sdtypes)
 
         # Assert
-        assert ht.field_data_types == {'a': 'categorical', 'b': 'integer'}
+        assert ht.field_sdtypes == {'a': 'categorical', 'b': 'integer'}
         ht._unfit.assert_called_once()
 
-    def test_get_default_data_type_transformers(self):
-        """Test the ``get_default_data_type_transformers`` method.
+    def test_get_default_sdtype_transformers(self):
+        """Test the ``get_default_sdtype_transformers`` method.
 
-        This method should return the ``default_data_type_transformers`` attribute.
+        This method should return the ``default_sdtype_transformers`` attribute.
 
         Output:
-            - Dict mapping data types to transformers.
+            - Dict mapping sdtypes to transformers.
         """
         # Setup
-        data_type_transformers = {
+        sdtype_transformers = {
             'categorical': FrequencyEncoder,
             'integer': FloatFormatter
         }
-        ht = HyperTransformer(default_data_type_transformers=data_type_transformers)
+        ht = HyperTransformer(default_sdtype_transformers=sdtype_transformers)
 
         # Run
-        out = ht.get_default_data_type_transformers()
+        out = ht.get_default_sdtype_transformers()
 
         # Assert
         assert out == {'categorical': FrequencyEncoder, 'integer': FloatFormatter}
 
-    def test_update_default_data_type_transformers(self):
-        """Test the ``update_default_data_type_transformers`` method.
+    def test_update_default_sdtype_transformers(self):
+        """Test the ``update_default_sdtype_transformers`` method.
 
-        This method should update the ``default_data_type_transformers`` attribute.
+        This method should update the ``default_sdtype_transformers`` attribute.
 
         Setup:
-            - Initialize ``HyperTransformer`` with ``default_data_type_transformers``
-            dict that only has some types set.
+            - Initialize ``HyperTransformer`` with ``default_sdtype_transformers``
+            dict that only has some sdtypes set.
 
         Input:
-            - Dict mapping new data types to transformers.
+            - Dict mapping new sdtypes to transformers.
         """
         # Setup
-        data_type_transformers = {
+        sdtype_transformers = {
             'categorical': FrequencyEncoder,
             'integer': FloatFormatter
         }
-        ht = HyperTransformer(default_data_type_transformers=data_type_transformers)
+        ht = HyperTransformer(default_sdtype_transformers=sdtype_transformers)
         ht._transformers_sequence = [FrequencyEncoder()]
         ht._unfit = Mock()
 
         # Run
-        ht.update_default_data_type_transformers({'boolean': BinaryEncoder})
+        ht.update_default_sdtype_transformers({'boolean': BinaryEncoder})
 
         # Assert
-        assert ht.default_data_type_transformers == {
+        assert ht.default_sdtype_transformers == {
             'categorical': FrequencyEncoder,
             'integer': FloatFormatter,
             'boolean': BinaryEncoder
diff --git a/tests/unit/transformers/addons/identity/test_identity.py b/tests/unit/transformers/addons/identity/test_identity.py
index 27bb32050..3c802cf70 100644
--- a/tests/unit/transformers/addons/identity/test_identity.py
+++ b/tests/unit/transformers/addons/identity/test_identity.py
@@ -11,7 +11,7 @@ class TestIdentityTransformer(TestCase):
     def test__fit(self):
         """Test ``IdentityTransformer._fit`` function.
 
-        The ``_fit`` function is expected to learn the columns ``INPUT_TYPE`` and
+        The ``_fit`` function is expected to learn the columns ``INPUT_SDTYPE`` and
         ``OUTPUT_COLUMNS`` from the ``self.columns``.
 
         Setup:
@@ -30,13 +30,13 @@ def test__fit(self):
         IdentityTransformer._fit(instance, data)
 
         # assert
-        expected_output_types = {
+        expected_output_sdtypes = {
             'a': None,
             'b': None,
             'c': None,
         }
 
-        assert instance.OUTPUT_TYPES == expected_output_types
+        assert instance.OUTPUT_SDTYPES == expected_output_sdtypes
 
     def test__transform(self):
         """Test ``IdentityTransformer._transform`` function.
diff --git a/tests/unit/transformers/pii/test_anonymizer.py b/tests/unit/transformers/pii/test_anonymizer.py
index f1fc28387..eed7fe795 100644
--- a/tests/unit/transformers/pii/test_anonymizer.py
+++ b/tests/unit/transformers/pii/test_anonymizer.py
@@ -155,28 +155,28 @@ def test___init__custom(self, mock_check_provider_function, mock_faker):
         assert mock_faker.Faker.called_once_with(['en_US', 'fr_FR'])
         assert instance._function == mock_faker.Faker.return_value.credit_card_full
 
-    def test_get_output_types(self):
-        """Test the ``get_output_types``.
+    def test_get_output_sdtypes(self):
+        """Test the ``get_output_sdtypes``.
 
         Setup:
             - initialize a ``PIIAnonymizer`` transformer which:
 
         Output:
-            - the ``output_types`` returns an empty dictionary.
+            - the ``output_sdtypes`` returns an empty dictionary.
         """
         # Setup
         transformer = PIIAnonymizer()
         transformer.column_prefix = 'a#b'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {}
         assert output == expected
 
-    def test_get_output_types_model_missing_values(self):
-        """Test the ``get_output_types`` method when a null column is created.
+    def test_get_output_sdtypes_model_missing_values(self):
+        """Test the ``get_output_sdtypes`` method when a null column is created.
 
         Setup:
             - initialize a ``PIIAnonymizer`` transformer which:
@@ -185,7 +185,7 @@ def test_get_output_types_model_missing_values(self):
                 - sets ``self.column_prefix`` to a string.
 
         Output:
-            - An ``output_types`` dictionary is being returned with the ``self.column_prefix``
+            - An ``output_sdtypes`` dictionary is being returned with the ``self.column_prefix``
               added to the beginning of the keys.
         """
         # Setup
@@ -195,7 +195,7 @@ def test_get_output_types_model_missing_values(self):
         transformer.column_prefix = 'a#b'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {
diff --git a/tests/unit/transformers/test_base.py b/tests/unit/transformers/test_base.py
index fa389df52..f948b68b4 100644
--- a/tests/unit/transformers/test_base.py
+++ b/tests/unit/transformers/test_base.py
@@ -37,27 +37,27 @@ class Child(Parent):
         assert Child in subclasses
         assert Parent not in subclasses
 
-    def test_get_input_type(self):
-        """Test the ``get_input_type`` method.
+    def test_get_input_sdtype(self):
+        """Test the ``get_input_sdtype`` method.
 
-        This method should return the value defined in the ``INPUT_TYPE`` of the child classes.
+        This method should return the value defined in the ``INPUT_SDTYPE`` of the child classes.
 
         Setup:
             - create a ``Dummy`` class which inherits from the ``BaseTransformer``,
-            containing only a ``INPUT_TYPE`` attribute.
+            containing only a ``INPUT_SDTYPE`` attribute.
 
         Output:
-            - the string stored in the ``INPUT_TYPE`` attribute.
+            - the string stored in the ``INPUT_SDTYPE`` attribute.
         """
         # Setup
         class Dummy(BaseTransformer):
-            INPUT_TYPE = 'categorical'
+            INPUT_SDTYPE = 'categorical'
 
         # Run
-        input_type = Dummy.get_input_type()
+        input_sdtype = Dummy.get_input_sdtype()
 
         # Assert
-        assert input_type == 'categorical'
+        assert input_sdtype == 'categorical'
 
     def test__add_prefix_none(self):
         """Test the ``_add_prefix`` method when passed a ``None``.
@@ -181,32 +181,32 @@ def __init__(self, param1=None, param2=None, param3=None):
         # Assert
         assert text == "Dummy(param2='value', param3=True)"
 
-    def test_get_output_types(self):
-        """Test the ``get_output_types`` method.
+    def test_get_output_sdtypes(self):
+        """Test the ``get_output_sdtypes`` method.
 
         Validate that the ``_add_prefix`` method is properly applied to the value stored in the
-        ``OUTPUT_TYPES`` attribute.
+        ``OUTPUT_SDTYPES`` attribute.
 
         Setup:
             - create a ``Dummy`` class which inherits from the ``BaseTransformer`` where:
                 - ``column_prefix`` is set to ``'column_name'``.
-                - ``OUTPUT_TYPES`` is set to dictionary.
+                - ``OUTPUT_SDTYPES`` is set to dictionary.
 
         Output:
-            - the dictionary set in ``OUTPUT_TYPES`` with the ``column_prefix`` string
+            - the dictionary set in ``OUTPUT_SDTYPES`` with the ``column_prefix`` string
             added to the beginning of the keys.
         """
         # Setup
         class Dummy(BaseTransformer):
             column_prefix = 'column_name'
-            OUTPUT_TYPES = {
+            OUTPUT_SDTYPES = {
                 'value': 'numerical'
             }
 
         dummy_transformer = Dummy()
 
         # Run
-        output = dummy_transformer.get_output_types()
+        output = dummy_transformer.get_output_sdtypes()
 
         # Assert
         expected = {
@@ -214,16 +214,16 @@ class Dummy(BaseTransformer):
         }
         assert output == expected
 
-    def test_get_output_types_none(self):
-        """Test the ``get_output_types`` method.
+    def test_get_output_sdtypes_none(self):
+        """Test the ``get_output_sdtypes`` method.
 
-        Validate that a dict is returned even if ``OUTPUT_TYPES`` attribute is None.
+        Validate that a dict is returned even if ``OUTPUT_SDTYPES`` attribute is None.
 
         Output:
             - An empty ``dict``.
         """
         # Run
-        output = BaseTransformer().get_output_types()
+        output = BaseTransformer().get_output_sdtypes()
 
         # Assert
         expected = {}
@@ -261,7 +261,7 @@ def test_get_output_columns(self):
 
         Setup:
             - create a ``Dummy`` class which inherits from the ``BaseTransformer``
-            and sets the ``column_prefix`` and ``OUTPUT_TYPES`` attributes.
+            and sets the ``column_prefix`` and ``OUTPUT_SDTYPES`` attributes.
 
         Output:
             - A list of each output name with the prefix prepended.
@@ -269,7 +269,7 @@ def test_get_output_columns(self):
         # Setup
         class Dummy(BaseTransformer):
             column_prefix = 'column_name'
-            OUTPUT_TYPES = {
+            OUTPUT_SDTYPES = {
                 'out1': 'numerical',
                 'out2': 'categorical'
             }
@@ -770,7 +770,7 @@ def test__build_output_columns(self):
         Setup:
             - create a ``Dummy`` class which inherits from the ``BaseTransformer`` where:
                 - ``columns`` is set to a list of columns from the data.
-                - ``OUTPUT_TYPES`` is set to a dictionary.
+                - ``OUTPUT_SDTYPES`` is set to a dictionary.
 
         Input:
             - a dataframe.
@@ -779,7 +779,7 @@ def test__build_output_columns(self):
             - ``self.column_prefix`` should be set to the elements stored in ``self.columns``
             joined by hashtags (e.g. ['a', 'b'] -> 'a#b').
             - ``self.output_columns`` should be set to a list of the keys of what's returned
-            from the ``get_output_types`` method.
+            from the ``get_output_sdtypes`` method.
         """
         # Setup
         data = pd.DataFrame({
@@ -790,7 +790,7 @@ def test__build_output_columns(self):
 
         class Dummy(BaseTransformer):
             columns = ['a', 'b']
-            OUTPUT_TYPES = {
+            OUTPUT_SDTYPES = {
                 'value': 'numerical',
                 'is_null': 'float'
             }
@@ -815,7 +815,7 @@ def test__build_output_columns_generated_already_exist(self):
         Setup:
             - create a ``Dummy`` class which inherits from the ``BaseTransformer`` where:
                 - ``columns`` is set to a list of columns from the data.
-                - ``OUTPUT_TYPES`` is set to a dictionary.
+                - ``OUTPUT_SDTYPES`` is set to a dictionary.
 
         Input:
             - a dataframe where the generated column name already exists
@@ -825,7 +825,7 @@ def test__build_output_columns_generated_already_exist(self):
             - ``self.column_prefix`` should be set to the elements stored in ``self.columns``
             joined by hashtags, with a hashtag added at the end (e.g. ['a', 'b'] -> 'a#b#').
             - ``self.output_columns`` should be set to a list of the keys of what's returned
-            from the ``get_output_types`` method.
+            from the ``get_output_sdtypes`` method.
         """
         # Setup
         data = pd.DataFrame({
@@ -835,7 +835,7 @@ def test__build_output_columns_generated_already_exist(self):
         })
 
         class Dummy(BaseTransformer):
-            OUTPUT_TYPES = {
+            OUTPUT_SDTYPES = {
                 'value': 'numerical',
                 'is_null': 'float'
             }
@@ -870,11 +870,11 @@ def test_fit(self):
         Validate that the ``fit`` method (1) sets ``self.columns`` to the passed columns of the
         data, (2) sets ``self.column_prefix`` to the appropriate string (the joined column names
         separated by a hashtag) and (3) sets ``self.output_columns`` to the correct dictionary
-        mapping column names to accepted output data types.
+        mapping column names to accepted output sdtypes.
 
         Setup:
             - create a dummy class which inherits from the ``BaseTransformer``, which defines:
-                - a ``OUTPUT_TYPES`` dictionary.
+                - a ``OUTPUT_SDTYPES`` dictionary.
                 - a ``_fit`` method which simply stores the passed data to ``self._passed_data``.
 
         Input:
@@ -886,7 +886,7 @@ def test_fit(self):
             - ``self.column_prefix`` should be set to the joined column names
             separated by a hashtag.
             - ``self.output_columns`` should be set to the correct dictionary mapping
-            column names to accepted output data types.
+            column names to accepted output sdtypes.
         """
         # Setup
         data = pd.DataFrame({
@@ -897,7 +897,7 @@ def test_fit(self):
         column = 'a'
 
         class Dummy(BaseTransformer):
-            OUTPUT_TYPES = {
+            OUTPUT_SDTYPES = {
                 'value': 'categorical',
                 'is_null': 'float'
             }
diff --git a/tests/unit/transformers/test_boolean.py b/tests/unit/transformers/test_boolean.py
index 4803f6806..945f55ad9 100644
--- a/tests/unit/transformers/test_boolean.py
+++ b/tests/unit/transformers/test_boolean.py
@@ -20,13 +20,13 @@ def test___init__(self):
         assert transformer.missing_value_replacement is None, error_message
         assert not transformer.model_missing_values, 'model_missing_values is False by default'
 
-    def test_get_output_types_model_missing_values_column_created(self):
-        """Test the ``get_output_types`` method when a null column is created.
+    def test_get_output_sdtypes_model_missing_values_column_created(self):
+        """Test the ``get_output_sdtypes`` method when a null column is created.
 
         When a null column is created, this method should apply the ``_add_prefix``
-        method to the following dictionary of output types:
+        method to the following dictionary of output sdtypes:
 
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
             'is_null': 'float'
         }
@@ -38,7 +38,7 @@ def test_get_output_types_model_missing_values_column_created(self):
                 - sets ``self.column_prefix`` to a string.
 
         Output:
-            - the ``output_types`` dictionary, but with ``self.column_prefix``
+            - the ``output_sdtypes`` dictionary, but with ``self.column_prefix``
             added to the beginning of the keys.
         """
         # Setup
@@ -48,7 +48,7 @@ def test_get_output_types_model_missing_values_column_created(self):
         transformer.column_prefix = 'abc'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {
diff --git a/tests/unit/transformers/test_categorical.py b/tests/unit/transformers/test_categorical.py
index 4f034509e..2d59aaa3d 100644
--- a/tests/unit/transformers/test_categorical.py
+++ b/tests/unit/transformers/test_categorical.py
@@ -840,11 +840,11 @@ def test__prepare_data_pandas_series(self):
         expected = pd.Series(['a', 'b', 'c'])
         np.testing.assert_array_equal(out, expected)
 
-    def test_get_output_types(self):
-        """Test the ``get_output_types`` method.
+    def test_get_output_sdtypes(self):
+        """Test the ``get_output_sdtypes`` method.
 
-        Validate that the ``_add_prefix`` method is properly applied to the ``output_types``
-        dictionary. For this class, the ``output_types`` dictionary is described as:
+        Validate that the ``_add_prefix`` method is properly applied to the ``output_sdtypes``
+        dictionary. For this class, the ``output_sdtypes`` dictionary is described as:
 
         {
             'value1': 'float',
@@ -860,8 +860,8 @@ def test_get_output_types(self):
                 - the ``column_prefix`` attribute to a string.
 
         Output:
-            - the ``output_types`` dictionary, but with ``self.column_prefix``
-            added to the beginning of the keys of the ``output_types`` dictionary.
+            - the ``output_sdtypes`` dictionary, but with ``self.column_prefix``
+            added to the beginning of the keys of the ``output_sdtypes`` dictionary.
         """
         # Setup
         transformer = OneHotEncoder()
@@ -869,7 +869,7 @@ def test_get_output_types(self):
         transformer.dummies = [1, 2]
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {
diff --git a/tests/unit/transformers/test_datetime.py b/tests/unit/transformers/test_datetime.py
index 94b5bba10..5648052a0 100644
--- a/tests/unit/transformers/test_datetime.py
+++ b/tests/unit/transformers/test_datetime.py
@@ -81,13 +81,13 @@ def test_is_composition_identity_null_transformer_false(self):
         # Assert
         assert output is True
 
-    def test_get_output_types(self):
-        """Test the ``get_output_types`` method when a null column is created.
+    def test_get_output_sdtypes(self):
+        """Test the ``get_output_sdtypes`` method when a null column is created.
 
         When a null column is created, this method should apply the ``_add_prefix``
-        method to the following dictionary of output types:
+        method to the following dictionary of output sdtypes:
 
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
             'is_null': 'float'
         }
@@ -99,7 +99,7 @@ def test_get_output_types(self):
                 - sets ``self.column_prefix`` to a column name.
 
         Output:
-            - the ``output_types`` dictionary, but with the ``self.column_prefix``
+            - the ``output_sdtypes`` dictionary, but with the ``self.column_prefix``
             added to the beginning of the keys.
         """
         # Setup
@@ -109,7 +109,7 @@ def test_get_output_types(self):
         transformer.column_prefix = 'a#b'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {
diff --git a/tests/unit/transformers/test_numerical.py b/tests/unit/transformers/test_numerical.py
index 03a415960..97558387f 100644
--- a/tests/unit/transformers/test_numerical.py
+++ b/tests/unit/transformers/test_numerical.py
@@ -23,13 +23,13 @@ def test___init__super_attrs(self):
         assert nt.missing_value_replacement == 'mode'
         assert nt.model_missing_values is False
 
-    def test_get_output_types(self):
-        """Test the ``get_output_types`` method when a null column is created.
+    def test_get_output_sdtypes(self):
+        """Test the ``get_output_sdtypes`` method when a null column is created.
 
         When a null column is created, this method should apply the ``_add_prefix``
-        method to the following dictionary of output types:
+        method to the following dictionary of output sdtypes:
 
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
             'is_null': 'float'
         }
@@ -41,7 +41,7 @@ def test_get_output_types(self):
                 - sets ``self.column_prefix`` to a string.
 
         Output:
-            - the ``output_types`` dictionary, but with the ``self.column_prefix``
+            - the ``output_sdtypes`` dictionary, but with the ``self.column_prefix``
             added to the beginning of the keys.
         """
         # Setup
@@ -51,7 +51,7 @@ def test_get_output_types(self):
         transformer.column_prefix = 'a#b'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {
@@ -1213,13 +1213,13 @@ def test__reverse_transform_model_missing_values_none(self):
 
 class TestClusterBasedNormalizer(TestCase):
 
-    def test_get_output_types_model_missing_values_column_created(self):
-        """Test the ``get_output_types`` method when a null column is created.
+    def test_get_output_sdtypes_model_missing_values_column_created(self):
+        """Test the ``get_output_sdtypes`` method when a null column is created.
 
         When a null column is created, this method should apply the ``_add_prefix``
-        method to the following dictionary of output types:
+        method to the following dictionary of output sdtypes:
 
-        output_types = {
+        output_sdtypes = {
             'value': 'float',
             'is_null': 'float'
         }
@@ -1231,7 +1231,7 @@ def test_get_output_types_model_missing_values_column_created(self):
                 - sets ``self.column_prefix`` to a string.
 
         Output:
-            - the ``output_types`` dictionary, but with ``self.column_prefix``
+            - the ``output_sdtypes`` dictionary, but with ``self.column_prefix``
             added to the beginning of the keys.
         """
         # Setup
@@ -1241,7 +1241,7 @@ def test_get_output_types_model_missing_values_column_created(self):
         transformer.column_prefix = 'abc'
 
         # Run
-        output = transformer.get_output_types()
+        output = transformer.get_output_sdtypes()
 
         # Assert
         expected = {