Repository: spetlr-org/spetlr (language: python)

Issue:
fix: fix inputtype to transformerNC
**UPDATE: I would rather merge #82. And then close this PR.**

When inherit from TransformerNC, there can occur some issues regarding the dataset_input_keys. When adding super().__init__ to a transformer that inherits from TransformerNC, the inputs will be a string-type. Therefore, there ETL thinks it should call process_many.


```python
class TestInheritTransformerNC(TransformerNC):
   

    def __init__(
        self,
        *,
        dataset_input_keys: Union[str, List[str]] = None,
        dataset_output_key: str = None,
    ):
        super().__init__(
            dataset_input_keys=dataset_input_keys,
            dataset_output_key=dataset_output_key,
        )
```

If the dataset_input_key here is a `str`, the transformerNC does not properly convert the the input as a list.

I think it is much more robust to control the input datatype instead. 


see this bug: #76 
spetlr 2.1.5 introduces errors when using TransformerNC
When applying 2.1.5, the new TransformerNC introduces issues.

If one inherits Transformer(consume=false) all works as it should.

If one inherits from TransformerNC, the dataset_input_keys are not correctly passed trhough the ETL pipeline. 


Discussion / hints:

I recommend that we remove TransformerNC as soon as possible

Fix patch:
diff --git a/docs/transformations/README.md b/docs/transformations/README.md
index 3dc46a9d..d3c8f312 100644
--- a/docs/transformations/README.md
+++ b/docs/transformations/README.md
@@ -14,7 +14,7 @@ Transformations in spetlr:
   - [SelectAndCastColumnsTransformer](#selectandcastcolumnstransformer)
   - [ValidFromToTransformer](#validfromtotransformer)
   - [DataFrameFilterTransformer](#dataframefiltertransformer)
-  - [CountryToAlphaCodeTransformerNC](#countrytoalphacodetransformernc)
+  - [CountryToAlphaCodeTransformer](#countrytoalphacodetransformer)
   - [GenerateMd5ColumnTransformer](#generatemd5columntransformer)
 ## Concatenate data frames
 
@@ -432,17 +432,18 @@ transformed_df.display()
 
 ```
 
-## CountryToAlphaCodeTransformerNC
+## CountryToAlphaCodeTransformer
 
 This is a simple transformer for translating country names to their alpha-2 code equivalent.
 
 Usage example
 
 ```python
-from spetlr.transformers import CountryToAlphaCodeTransformerNC
+from spetlr.transformers import CountryToAlphaCodeTransformer
 import pyspark.sql.types as T
 
 from spetlr.spark import Spark
+
 input_schema = T.StructType(
     [
         T.StructField("countryCol", T.StringType(), True),
@@ -456,15 +457,13 @@ input_data = [
 
 input_df = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-transformed_df = CountryToAlphaCodeTransformerNC(
+transformed_df = CountryToAlphaCodeTransformer(
     col_name="countryCol",
     output_col_name="alphaCodeCol
 ).process(df_input)
 
-
 transformed_df.display()
 
-+----------+------------+
 |countryCol|alphaCodeCol|
 +----------+------------+
 |   Denmark|          DK|
@@ -480,10 +479,11 @@ This transformer generates a unique column with md5 encoding based on other colu
 Usage example
 
 ```python
-from spetlr.transformers import GenerateMd5ColumnTransformerNC
+from spetlr.transformers import GenerateMd5ColumnTransformer
 import pyspark.sql.types as T
 
 from spetlr.spark import Spark
+
 input_schema = T.StructType(
     [
         T.StructField("id", T.IntegerType(), True),
@@ -498,12 +498,11 @@ input_data = [
 
 input_df = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-transformed_df = GenerateMd5ColumnTransformerNC(
+transformed_df = GenerateMd5ColumnTransformer(
     col_name="md5_col",
     col_list=["id", "text"],
 ).process(input_df)
 
-
 transformed_df.display()
 
 +-----+-------+----------------------------------+
@@ -512,4 +511,4 @@ transformed_df.display()
 |    1|  text1|  e86667d75db79395e172c5c343ec2df1|
 |    2|   Null|  c81e728d9d4c2f636f067f89cc14862c|
 +-----+-------+-----------------------------------+
-```
\ No newline at end of file
+```
diff --git a/src/VERSION.txt b/src/VERSION.txt
index 7ec1d6db..4a36342f 100644
--- a/src/VERSION.txt
+++ b/src/VERSION.txt
@@ -1,1 +1,1 @@
-2.1.0
+3.0.0
diff --git a/src/spetlr/etl/__init__.py b/src/spetlr/etl/__init__.py
index 811fdedf..2519fbc9 100644
--- a/src/spetlr/etl/__init__.py
+++ b/src/spetlr/etl/__init__.py
@@ -2,7 +2,6 @@
 from .loader import Loader
 from .orchestrator import Orchestrator
 from .transformer import Transformer
-from .transformer_nc import TransformerNC
 from .types import EtlBase, dataset_group
 
 __all__ = [
@@ -11,6 +10,5 @@
     "Transformer",
     "Orchestrator",
     "EtlBase",
-    "TransformerNC",
     "dataset_group",
 ]
diff --git a/src/spetlr/etl/transformer_nc.py b/src/spetlr/etl/transformer_nc.py
deleted file mode 100644
index ec18ee33..00000000
--- a/src/spetlr/etl/transformer_nc.py
+++ /dev/null
@@ -1,46 +0,0 @@
-from abc import abstractmethod
-from typing import List, Union
-
-from deprecated import deprecated
-from pyspark.sql import DataFrame
-
-from spetlr.etl.types import dataset_group
-
-from .transformer import Transformer
-
-
-@deprecated(reason="Use Transformer with consume_inputs=False instead")
-class TransformerNC(Transformer):
-    """If you only want to transform a single input dataframe,
-    implement `process`
-    If you want to transform a set of dataframes,
-    implement `process_many`
-
-    In regards to the etl step, the TransformerNC does NOT CONSUME the inputs
-    and ADDs the result of its transformation stage to the dataset dict.
-    """
-
-    def __init__(
-        self,
-        *,
-        dataset_input_keys: Union[str, List[str]] = None,
-        dataset_output_key: str = None,
-    ):
-        if isinstance(dataset_input_keys, str):
-            dataset_input_keys = [dataset_input_keys]
-        else:
-            dataset_input_keys = dataset_input_keys
-
-        super().__init__(
-            dataset_input_keys=dataset_input_keys,
-            dataset_output_key=dataset_output_key,
-            consume_inputs=False,
-        )
-
-    @abstractmethod
-    def process(self, df: DataFrame) -> DataFrame:
-        raise NotImplementedError()
-
-    @abstractmethod
-    def process_many(self, datasets: dataset_group) -> DataFrame:
-        raise NotImplementedError()
diff --git a/src/spetlr/transformers/__init__.py b/src/spetlr/transformers/__init__.py
index a2eb46be..1c14ea70 100644
--- a/src/spetlr/transformers/__init__.py
+++ b/src/spetlr/transformers/__init__.py
@@ -1,26 +1,20 @@
-from .country_to_alphacode_transformer_nc import (  # noqa: F401
-    CountryToAlphaCodeTransformerNC,
+from .country_to_alphacode_transformer import (  # noqa: F401
+    CountryToAlphaCodeTransformer,
 )
 from .drop_oldest_duplicate_transformer import (  # noqa: F401
     DropOldestDuplicatesTransformer,
 )
-from .dropColumnsTransformer_nc import DropColumnsTransformerNC  # noqa: F401
-from .generate_md5_column_transformer_nc import (  # noqa: F401
-    GenerateMd5ColumnTransformerNC,
+from .dropColumnsTransformer import DropColumnsTransformer  # noqa: F401
+from .generate_md5_column_transformer import GenerateMd5ColumnTransformer  # noqa: F401
+from .join_dataframes_transformer import JoinDataframesTransformer  # noqa: F401
+from .select_and_cast_columns_transformer import (  # noqa: F401
+    SelectAndCastColumnsTransformer,
 )
-from .join_dataframes_transformer import JoinDataframesTransformerNC  # noqa: F401
-from .select_and_cast_columns_transformer_nc import (  # noqa: F401
-    SelectAndCastColumnsTransformerNC,
-)
-from .selectColumnsTransformer_nc import SelectColumnsTransformerNC  # noqa: F401
+from .selectColumnsTransformer import SelectColumnsTransformer  # noqa: F401
 from .simple_dataframe_filter_transformer import (  # noqa: F401
     DataFrameFilterTransformer,
 )
-from .simple_dataframe_filter_transformer_nc import (  # noqa: F401
-    DataFrameFilterTransformerNC,
-)
 from .simple_sql_transformer import SimpleSqlServerTransformer  # noqa: F401
-from .timezone_transformer_nc import TimeZoneTransformerNC  # noqa: F401
+from .timezone_transformer import TimeZoneTransformer  # noqa: F401
 from .union_transformer import UnionTransformer  # noqa: F401
-from .union_transformer_nc import UnionTransformerNC  # noqa: F401
 from .validfromto_transformer import ValidFromToTransformer  # noqa: F401
diff --git a/src/spetlr/transformers/country_to_alphacode_transformer_nc.py b/src/spetlr/transformers/country_to_alphacode_transformer.py
similarity index 87%
rename from src/spetlr/transformers/country_to_alphacode_transformer_nc.py
rename to src/spetlr/transformers/country_to_alphacode_transformer.py
index b6779fa6..2ff284d1 100644
--- a/src/spetlr/transformers/country_to_alphacode_transformer_nc.py
+++ b/src/spetlr/transformers/country_to_alphacode_transformer.py
@@ -1,11 +1,11 @@
-from typing import List, Union
+from typing import List
 
 import pycountry
 import pyspark.sql.functions as F
 import pyspark.sql.types as T
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 
 
 def translate_country_to_alpha2(country_name: str) -> str:
@@ -26,13 +26,14 @@ def translate_country_to_alpha2(country_name: str) -> str:
 translateUDF = F.udf(lambda z: translate_country_to_alpha2(z), T.StringType())
 
 
-class CountryToAlphaCodeTransformerNC(TransformerNC):
+class CountryToAlphaCodeTransformer(Transformer):
     def __init__(
         self,
         col_name: str,
         output_col_name: str = None,
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True,
     ) -> None:
         """
         A simple transformer to translate country names to alpha-2 codes
@@ -45,6 +46,7 @@ def __init__(
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.col_name = col_name
         self.output_col_name = output_col_name or self.col_name
diff --git a/src/spetlr/transformers/dropColumnsTransformer_nc.py b/src/spetlr/transformers/dropColumnsTransformer.py
similarity index 65%
rename from src/spetlr/transformers/dropColumnsTransformer_nc.py
rename to src/spetlr/transformers/dropColumnsTransformer.py
index 6b60e3ef..e881bfa6 100644
--- a/src/spetlr/transformers/dropColumnsTransformer_nc.py
+++ b/src/spetlr/transformers/dropColumnsTransformer.py
@@ -1,21 +1,23 @@
-from typing import List, Union
+from typing import List
 
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 
 
-class DropColumnsTransformerNC(TransformerNC):
+class DropColumnsTransformer(Transformer):
     def __init__(
         self,
         *,
         columnList: List[str],
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True
     ):
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.columnList = columnList
 
diff --git a/src/spetlr/transformers/drop_oldest_duplicate_transformer.py b/src/spetlr/transformers/drop_oldest_duplicate_transformer.py
index bbccf984..8d06c70c 100644
--- a/src/spetlr/transformers/drop_oldest_duplicate_transformer.py
+++ b/src/spetlr/transformers/drop_oldest_duplicate_transformer.py
@@ -7,8 +7,20 @@
 
 
 class DropOldestDuplicatesTransformer(Transformer):
-    def __init__(self, *, cols: List[str], orderByColumn: str):
-        super().__init__()
+    def __init__(
+        self,
+        *,
+        cols: List[str],
+        orderByColumn: str,
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self.cols = cols
         self.orderByColumn = orderByColumn
 
diff --git a/src/spetlr/transformers/fuzzy_select.py b/src/spetlr/transformers/fuzzy_select.py
index bde3b4de..b7dd1300 100644
--- a/src/spetlr/transformers/fuzzy_select.py
+++ b/src/spetlr/transformers/fuzzy_select.py
@@ -32,8 +32,19 @@ class FuzzySelectTransformer(Transformer):
     the method find_best_mapping and inspect the returned mapping.
     """
 
-    def __init__(self, columns: Iterable[str], match_cutoff=0.6):
-        super().__init__()
+    def __init__(
+        self,
+        columns: Iterable[str],
+        match_cutoff=0.6,
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self.columns = list(columns)
         self.match_cutoff = match_cutoff
 
diff --git a/src/spetlr/transformers/generate_md5_column_transformer_nc.py b/src/spetlr/transformers/generate_md5_column_transformer.py
similarity index 87%
rename from src/spetlr/transformers/generate_md5_column_transformer_nc.py
rename to src/spetlr/transformers/generate_md5_column_transformer.py
index 61e5f281..5a00161a 100644
--- a/src/spetlr/transformers/generate_md5_column_transformer_nc.py
+++ b/src/spetlr/transformers/generate_md5_column_transformer.py
@@ -1,14 +1,14 @@
 import uuid
-from typing import List, Union
+from typing import List
 
 import pyspark.sql.functions as F
 import pyspark.sql.types as T
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 
 
-class GenerateMd5ColumnTransformerNC(TransformerNC):
+class GenerateMd5ColumnTransformer(Transformer):
     """
     This transformer generates a unique column with md5 encoding based on other columns.
     The transformer also handles if a value is NULL, by replacing it with empty string.
@@ -30,12 +30,14 @@ def __init__(
         *,
         col_name: str,
         col_list: List[str],
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True
     ):
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.col_name = col_name
         self.col_list = col_list
diff --git a/src/spetlr/transformers/join_dataframes_transformer.py b/src/spetlr/transformers/join_dataframes_transformer.py
index 0dc18d4d..1f159eaf 100644
--- a/src/spetlr/transformers/join_dataframes_transformer.py
+++ b/src/spetlr/transformers/join_dataframes_transformer.py
@@ -2,7 +2,7 @@
 
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 from spetlr.etl.types import dataset_group
 from spetlr.exceptions import (
     ColumnDoesNotExistException,
@@ -10,7 +10,7 @@
 )
 
 
-class JoinDataframesTransformerNC(TransformerNC):
+class JoinDataframesTransformer(Transformer):
     """
     This transformer joins two DataFrames together.
 
@@ -40,6 +40,7 @@ def __init__(
         join_type: str = "inner",
         dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True,
     ):
         if len(dataset_input_keys) > 2:
             raise MoreThanTwoDataFramesException(
@@ -48,7 +49,9 @@ def __init__(
             )
 
         super().__init__(
-            dataset_input_keys=dataset_input_keys, dataset_output_key=dataset_output_key
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.first_dataframe_join_key = first_dataframe_join_key
         self.second_dataframe_join_key = second_dataframe_join_key
diff --git a/src/spetlr/transformers/selectColumnsTransformer_nc.py b/src/spetlr/transformers/selectColumnsTransformer.py
similarity index 65%
rename from src/spetlr/transformers/selectColumnsTransformer_nc.py
rename to src/spetlr/transformers/selectColumnsTransformer.py
index 16b4a52c..51106ae5 100644
--- a/src/spetlr/transformers/selectColumnsTransformer_nc.py
+++ b/src/spetlr/transformers/selectColumnsTransformer.py
@@ -1,21 +1,23 @@
-from typing import List, Union
+from typing import List
 
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 
 
-class SelectColumnsTransformerNC(TransformerNC):
+class SelectColumnsTransformer(Transformer):
     def __init__(
         self,
         *,
         columnList: List[str],
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True
     ):
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.columnList = columnList
 
diff --git a/src/spetlr/transformers/select_and_cast_columns_transformer_nc.py b/src/spetlr/transformers/select_and_cast_columns_transformer.py
similarity index 83%
rename from src/spetlr/transformers/select_and_cast_columns_transformer_nc.py
rename to src/spetlr/transformers/select_and_cast_columns_transformer.py
index ae8949ab..84c2aa0a 100644
--- a/src/spetlr/transformers/select_and_cast_columns_transformer_nc.py
+++ b/src/spetlr/transformers/select_and_cast_columns_transformer.py
@@ -1,13 +1,13 @@
-from typing import List, Union
+from typing import List
 
 import pyspark.sql.types as T
 from pyspark.sql import DataFrame
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 from spetlr.utils import SelectAndCastColumns
 
 
-class SelectAndCastColumnsTransformerNC(TransformerNC):
+class SelectAndCastColumnsTransformer(Transformer):
     """
     This transformer select and cast columns based pyspark schema.
 
@@ -28,12 +28,14 @@ def __init__(
         *,
         schema: T.StructType,
         caseInsensitiveMatching: bool = False,
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True
     ):
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.schema = schema
         self.caseInsensitiveMatching = caseInsensitiveMatching
diff --git a/src/spetlr/transformers/simple_dataframe_filter_transformer.py b/src/spetlr/transformers/simple_dataframe_filter_transformer.py
index 62416ae9..d1ddda43 100644
--- a/src/spetlr/transformers/simple_dataframe_filter_transformer.py
+++ b/src/spetlr/transformers/simple_dataframe_filter_transformer.py
@@ -1,3 +1,5 @@
+from typing import List
+
 import pyspark.sql.functions as F
 from pyspark.sql import DataFrame
 
@@ -5,7 +7,14 @@
 
 
 class DataFrameFilterTransformer(Transformer):
-    def __init__(self, col_value: str, col_name: str = "messageType") -> None:
+    def __init__(
+        self,
+        col_value: str,
+        col_name: str = "messageType",
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ) -> None:
         """
         A simple helper class to filter a dataframe based on the passed col_name
         if its value equals to the specified col_value.
@@ -16,7 +25,11 @@ def __init__(self, col_value: str, col_name: str = "messageType") -> None:
                 is 'messageType' as this class is mostly used to filter dataframes
                 with this column name.
         """
-        super().__init__()
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self.col_value = col_value
         self.col_name = col_name
 
diff --git a/src/spetlr/transformers/simple_dataframe_filter_transformer_nc.py b/src/spetlr/transformers/simple_dataframe_filter_transformer_nc.py
deleted file mode 100644
index 08a774ce..00000000
--- a/src/spetlr/transformers/simple_dataframe_filter_transformer_nc.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from typing import List, Union
-
-import pyspark.sql.functions as F
-from pyspark.sql import DataFrame
-
-from spetlr.etl import TransformerNC
-
-
-class DataFrameFilterTransformerNC(TransformerNC):
-    def __init__(
-        self,
-        col_name: str,
-        col_value: str,
-        dataset_input_keys: Union[str, List[str]] = None,
-        dataset_output_key: str = None,
-    ) -> None:
-        """
-
-        The non-consuming version of DataFrameFilterTransformer()
-        without a default column name.
-
-        A simple helper class to filter a dataframe based on the passed col_name
-        if its value equals to the specified col_value.
-
-        Args:
-            col_value: The value of the column to filter the dataframe
-            col_name: The name of the column to filter the dataframe.
-        """
-
-        super().__init__(
-            dataset_input_keys=dataset_input_keys, dataset_output_key=dataset_output_key
-        )
-        self.col_value = col_value
-        self.col_name = col_name
-
-    def process(self, df: DataFrame) -> DataFrame:
-        """
-        Method to filter the passed dataframe df based on the col_name and col_value
-        of the class.
-
-        Args:
-            df: The dataframe to filter
-
-        Returns:
-            The filtered dataframe
-        """
-        return df.filter(F.col(self.col_name) == self.col_value)
diff --git a/src/spetlr/transformers/simple_sql_transformer.py b/src/spetlr/transformers/simple_sql_transformer.py
index aa1914a8..bd9bed9f 100644
--- a/src/spetlr/transformers/simple_sql_transformer.py
+++ b/src/spetlr/transformers/simple_sql_transformer.py
@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from typing import List
 
 import pyspark.sql.functions as f
 from pyspark.sql import DataFrame
@@ -10,8 +11,21 @@
 
 
 class SimpleSqlServerTransformer(Transformer):
-    def __init__(self, *, table_id: str, server: SqlServer, ignoreCase=False):
-        super().__init__()
+    def __init__(
+        self,
+        *,
+        table_id: str,
+        server: SqlServer,
+        ignoreCase=False,
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self.server = server
         self.table_id = table_id
         self.ignoreCase = ignoreCase
diff --git a/src/spetlr/transformers/timezone_transformer_nc.py b/src/spetlr/transformers/timezone_transformer.py
similarity index 91%
rename from src/spetlr/transformers/timezone_transformer_nc.py
rename to src/spetlr/transformers/timezone_transformer.py
index b500c762..4f93eb92 100644
--- a/src/spetlr/transformers/timezone_transformer_nc.py
+++ b/src/spetlr/transformers/timezone_transformer.py
@@ -1,15 +1,15 @@
-from typing import List, Union
+from typing import List
 
 import pyspark.sql.functions as F
 from pyspark.sql import DataFrame
 from timezonefinder import TimezoneFinder
 
-from spetlr.etl import TransformerNC
+from spetlr.etl import Transformer
 from spetlr.etl.types import dataset_group
 from spetlr.exceptions import ColumnDoesNotExistException
 
 
-class TimeZoneTransformerNC(TransformerNC):
+class TimeZoneTransformer(Transformer):
     """
     This transformer extracts a timezone using longitude and latitude.
 
@@ -38,12 +38,14 @@ def __init__(
         latitude_col: str,
         longitude_col: str,
         column_output_name: str = "TimeZone",
-        dataset_input_keys: Union[str, List[str]] = None,
+        dataset_input_keys: List[str] = None,
         dataset_output_key: str = None,
+        consume_inputs: bool = True
     ):
         super().__init__(
             dataset_input_keys=dataset_input_keys,
             dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
         )
         self.latitude_col = latitude_col
         self.longitude_col = longitude_col
diff --git a/src/spetlr/transformers/union_transformer.py b/src/spetlr/transformers/union_transformer.py
index aaf2f496..6816652f 100644
--- a/src/spetlr/transformers/union_transformer.py
+++ b/src/spetlr/transformers/union_transformer.py
@@ -1,4 +1,5 @@
 from functools import reduce
+from typing import List
 
 from pyspark.sql import DataFrame
 
@@ -26,8 +27,18 @@ class UnionTransformer(Transformer):
         returns the union of all input DataFrames
     """
 
-    def __init__(self, allowMissingColumns: bool = False):
-        super().__init__()
+    def __init__(
+        self,
+        allowMissingColumns: bool = False,
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self.allowMissingColumns = allowMissingColumns
 
     def process(self, df: DataFrame) -> DataFrame:
diff --git a/src/spetlr/transformers/union_transformer_nc.py b/src/spetlr/transformers/union_transformer_nc.py
deleted file mode 100644
index c3bc0cfe..00000000
--- a/src/spetlr/transformers/union_transformer_nc.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from functools import reduce
-from typing import List, Union
-
-from pyspark.sql import DataFrame
-
-from spetlr.etl import TransformerNC
-from spetlr.etl.types import dataset_group
-
-
-class UnionTransformerNC(TransformerNC):
-    """
-    This non-consuming transformer unions multiple DataFrames
-
-    Attributes:
-    ----------
-        allowMissingColumns : bool
-            When the parameter allowMissingColumns is True,
-            the set of column names in this and other DataFrame
-            can differ; missing columns will be filled with null
-
-    Methods
-    -------
-    process(df: DataFrame):
-        returns the input DataFrame
-
-    process_many(datasets: dataset_group):
-        returns the union of all input DataFrames
-    """
-
-    def __init__(
-        self,
-        *,
-        allowMissingColumns: bool = False,
-        dataset_input_keys: Union[str, List[str]] = None,
-        dataset_output_key: str = None,
-    ):
-        super().__init__(
-            dataset_input_keys=dataset_input_keys,
-            dataset_output_key=dataset_output_key,
-        )
-        self.allowMissingColumns = allowMissingColumns
-
-    def process(self, df: DataFrame) -> DataFrame:
-        return df
-
-    def process_many(self, datasets: dataset_group) -> DataFrame:
-        dfs = list(datasets.values())
-        return reduce(
-            lambda df1, df2: df1.unionByName(
-                df2, allowMissingColumns=self.allowMissingColumns
-            ),
-            dfs,
-        )
diff --git a/src/spetlr/transformers/validfromto_transformer.py b/src/spetlr/transformers/validfromto_transformer.py
index 508b549b..582c551e 100644
--- a/src/spetlr/transformers/validfromto_transformer.py
+++ b/src/spetlr/transformers/validfromto_transformer.py
@@ -17,8 +17,19 @@ class ValidFromToTransformer(Transformer):
     NB: Be aware, if incremental extraction is used, the logic does not work
     """
 
-    def __init__(self, time_col: str, wnd_cols: List[str]):
-        super().__init__()
+    def __init__(
+        self,
+        time_col: str,
+        wnd_cols: List[str],
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
         self._time_col = time_col
         self._wnd_cols = wnd_cols
 


Test patch:
diff --git a/tests/local/etl/etl_transformer_test_helper.py b/tests/local/etl/etl_transformer_test_helper.py
new file mode 100644
index 00000000..cb8b91a1
--- /dev/null
+++ b/tests/local/etl/etl_transformer_test_helper.py
@@ -0,0 +1,30 @@
+from spetlrtools.testing import TestHandle
+
+from spetlr.etl import Orchestrator
+from spetlr.etl.extractors import SimpleExtractor
+from spetlr.spark import Spark
+
+
+def ETLTransformerTester(trans) -> Orchestrator:
+    """
+    This method is a helper for the test_transformer.py
+
+    A transformer is applied in a OETL setup.
+
+    """
+    empty_df = Spark.get().createDataFrame(data=[], schema="col1 string")
+
+    dh_extract_1 = TestHandle(provides=empty_df)
+    dh_extract_2 = TestHandle(provides=empty_df)
+
+    oc = Orchestrator()
+
+    oc.extract_from(SimpleExtractor(handle=dh_extract_1, dataset_key="df_1"))
+
+    oc.extract_from(SimpleExtractor(handle=dh_extract_2, dataset_key="df_2"))
+
+    oc.transform_with(
+        trans,
+    )
+
+    return oc
diff --git a/tests/local/etl/test_transformer.py b/tests/local/etl/test_transformer.py
index 4ec23b85..688109f8 100644
--- a/tests/local/etl/test_transformer.py
+++ b/tests/local/etl/test_transformer.py
@@ -1,38 +1,65 @@
 import unittest
+from typing import List
 
 from pyspark.sql import DataFrame
 from pyspark.sql.types import IntegerType, StringType, StructField, StructType
+from spetlrtools.testing import TestHandle
 
 from spetlr.etl import Transformer
+from spetlr.etl.loaders import SimpleLoader
 from spetlr.etl.types import dataset_group
 from spetlr.spark import Spark
+from tests.local.etl.etl_transformer_test_helper import ETLTransformerTester
 
 
 class TransformerTests(unittest.TestCase):
+    """
+    Test suite for the Transformer class in the OETL framework.
+
+    This test suite contains test cases for both
+        consuming and non-consuming transformers.
+    """
+
     @classmethod
     def setUpClass(cls):
-        cls.transformer = TestTransformer()
+        cls.transformer_consuming = TestTransformer(consume_inputs=True)
+        cls.transformer_non_consuming = TestTransformer(consume_inputs=False)
         cls.df = create_dataframe()
 
-    def test_process(self):
+        # Test helpers for non consuming handling of keys
+        cls.transformer_output_key = TestTransformer(
+            dataset_output_key="my_output_key", consume_inputs=False
+        )
+        cls.transformer_input_key = TestTransformer(
+            dataset_input_keys=["my_input_key"], consume_inputs=False
+        )
+        cls.transformer_input_key_list = TestTransformer(
+            dataset_input_keys=["my_input_key_1", "my_input_key_2"],
+            consume_inputs=False,
+        )
+
+    # ######################################################################
+    # ################# CONSUMING TEST CASES ###############################
+    # ######################################################################
+    def test_consuming_process(self):
         # Process is called with single input
         # Result contain single df
-        result = self.transformer.etl({"df": self.df})
+        result = self.transformer_consuming.etl({"df": self.df})
         self.assertEqual(1, len(result))
         self.assertEqual({"TestTransformer"}, set(result.keys()))
         self.assertIs(self.df, result["TestTransformer"])
 
-    def test_process_many(self):
+    def test_consuming_process_many(self):
         # Process_many is called with multiple inputs
         # Result contain union of input dfs
-        result = self.transformer.etl({"df1": self.df, "df2": self.df})
+        result = self.transformer_consuming.etl({"df1": self.df, "df2": self.df})
         self.assertEqual(1, len(result))
         self.assertEqual({"TestTransformer"}, set(result.keys()))
         self.assertEqual(
             self.df.union(self.df).collect(), result["TestTransformer"].collect()
         )
 
-    def test_dataset_key(self):
+    def test_consuming_dataset_key(self):
         # Set dataset_key to control name of the output
         # Result contain the key 'my_key'
         result = TestTransformer(dataset_key="my_key").etl({"df": self.df})
@@ -40,7 +67,7 @@ def test_dataset_key(self):
         self.assertEqual({"my_key"}, set(result.keys()))
         self.assertIs(self.df, result["my_key"])
 
-    def test_dataset_output_key(self):
+    def test_consuming_dataset_output_key(self):
         # Set dataset_output_key to control name of the output
         # Result contain the key 'my_key'
         result = TestTransformer(dataset_output_key="my_key").etl({"df": self.df})
@@ -48,7 +75,7 @@ def test_dataset_output_key(self):
         self.assertEqual({"my_key"}, set(result.keys()))
         self.assertIs(self.df, result["my_key"])
 
-    def test_single_dataset_input_key(self):
+    def test_consuming_single_dataset_input_key(self):
         # Set dataset_input_keys to control what dfs in dataset to handle
         # Process is called with single input
         # Result contain two keys due to 'df2' not being consumed
@@ -61,7 +88,7 @@ def test_single_dataset_input_key(self):
         self.assertIs(self.df, result["TestTransformer"])
         self.assertIs(self.df, result["df2"])
 
-    def test_multiple_dataset_input_keys(self):
+    def test_consuming_multiple_dataset_input_keys(self):
         # Set dataset_input_keys to control what dfs in dataset to handle
         # Process_many is called with multiple inputs
         # Result contain two keys due to 'df3' not being consumed
@@ -76,7 +103,7 @@ def test_multiple_dataset_input_keys(self):
         )
         self.assertIs(self.df, result["df3"])
 
-    def test_not_consume_inputs(self):
+    def test_consuming_should_not_consume_inputs(self):
         # Set consume_inputs to False to control dataset keys will no be consumed
         # in the output
         # Result contain two keys due to 'df' not being consumed
@@ -86,8 +113,155 @@ def test_not_consume_inputs(self):
         self.assertIs(self.df, result["TestTransformer"])
         self.assertIs(self.df, result["df"])
 
+    def test_consuming_in_etl_context(self):
+        """
+        In order to test whether the transformer class
+        works in a full ETL flow,
+        this tests a simple setup.
+
+        It should be able to write df_trans to a testhandle.
+
+        But cannot write df_1 to a testhandle, since it has been consumed.
+        """
+        trans_consuming = TestTransformer(
+            dataset_input_keys=["df_1"],
+            dataset_output_key="df_trans",
+            consume_inputs=True,
+        )
+
+        oc_test_B = ETLTransformerTester(
+            trans_consuming,
+        )
+        dh_load = TestHandle()
+
+        oc_test_B.load_into(
+            SimpleLoader(
+                handle=dh_load, mode="overwrite", dataset_input_keys=["df_trans"]
+            )
+        )
+
+        oc_test_B.execute()
+
+        oc_test_B.load_into(
+            SimpleLoader(handle=dh_load, mode="overwrite", dataset_input_keys=["df_1"])
+        )
+
+        with self.assertRaises(KeyError) as cm:
+            oc_test_B.execute()
+
+        # Since it is consuming, it should not be able to find df_1
+        self.assertEqual(cm.exception.args[0], "df_1")
+
+    # ######################################################################
+    # ################# NON-CONSUMING TEST CASES ###########################
+    # ######################################################################
+
+    def test_non_consuming_process(self):
+        # process is called when:
+        # - inputs has one df
+        # - dataset_input_key is not given
+        result = self.transformer_non_consuming.etl({"df": self.df})
+        self.assertIs(self.df, list(result.values())[1])
+
+    def test_non_consuming_process_many(self):
+        # process_many is called when:
+        # - inputs has more than one df
+        # - dataset_input_key is not given
+        result = self.transformer_non_consuming.etl({"df1": self.df, "df2": self.df})
+        self.assertEqual(6, list(result.values())[2].count())
+
+    def test_non_consuming_process_no_key(self):
+        # process sets dataset_ouput_key equivalent to the transformer class when:
+        # - dataset_output_key is not given
+        result = self.transformer_non_consuming.etl({"df": self.df})
+        self.assertEqual("TestTransformer", list(result.keys())[1])
+
+    def test_non_consuming_process_many_no_key(self):
+        # process_many sets dataset_ouput_key equivalent to the transformer class when:
+        # - dataset_output_key is not given
+        result = self.transformer_non_consuming.etl({"df1": self.df, "df2": self.df})
+        self.assertEqual("TestTransformer", list(result.keys())[2])
+
+    def test_non_consuming_process_output_key(self):
+        # process sets dataset_output_key equiavalent to the input when:
+        # - dataset_output_key is given
+        result = self.transformer_output_key.etl({"df": self.df})
+        self.assertEqual("my_output_key", list(result.keys())[1])
+
+    def test_non_consuming_process_many_output_key(self):
+        # process_many sets dataset_output_key equiavalent to the input when:
+        # - dataset_output_key is given
+        result = self.transformer_output_key.etl({"df1": self.df, "df2": self.df})
+        self.assertEqual("my_output_key", list(result.keys())[2])
+
+    def test_non_consuming_process_input_key(self):
+        # process is called when:
+        # - dataset_input_key is given
+        result = self.transformer_input_key.etl({"my_input_key": self.df})
+        self.assertIs(self.df, list(result.values())[1])
+
+        with self.assertRaises(KeyError):
+            # error when:
+            # - the provided dataset_input_key does not exist in inputs
+            self.transformer_input_key.etl({"df": self.df})
+
+    def test_non_consuming_process_many_input_key_list(self):
+        # process_many is called when:
+        # - dataset_input_key_list is given
+        result = self.transformer_input_key_list.etl(
+            {"my_input_key_1": self.df, "my_input_key_2": self.df}
+        )
+        self.assertEqual(6, list(result.values())[2].count())
+
+        with self.assertRaises(AssertionError):
+            # error when:
+            # - the provided dataset_input_key_list contains an incorrect key
+            self.transformer_input_key_list.etl({"df1": self.df, "df2": self.df})
+
+    def test_non_consuming_in_etl_context(self):
+        """
+        In order to test whether the transformer class
+        works in a full ETL flow,
+        this tests a simple setup.
+
+        The non consuming can both write the df_1 and df_trans
+        to a testhandle.
+        """
+
+        trans_consuming = TestTransformer(
+            dataset_input_keys=["df_1"],
+            dataset_output_key="df_trans",
+            consume_inputs=False,
+        )
+        dh_load = TestHandle()
+        oc_test_A = ETLTransformerTester(trans_consuming)
+        oc_test_A.load_into(
+            SimpleLoader(
+                handle=dh_load, mode="overwrite", dataset_input_keys=["df_trans"]
+            )
+        )
+        oc_test_A.load_into(
+            SimpleLoader(handle=dh_load, mode="overwrite", dataset_input_keys=["df_1"])
+        )
+
+        oc_test_A.execute()
+
 
 class TestTransformer(Transformer):
+    def __init__(
+        self,
+        dataset_key: str = None,
+        dataset_input_keys: List[str] = None,
+        dataset_output_key: str = None,
+        consume_inputs: bool = True,
+    ):
+        super().__init__(
+            dataset_key=dataset_key,
+            dataset_input_keys=dataset_input_keys,
+            dataset_output_key=dataset_output_key,
+            consume_inputs=consume_inputs,
+        )
+
     def process(self, df: DataFrame) -> DataFrame:
         return df
 
diff --git a/tests/local/etl/test_transformer_nc.py b/tests/local/etl/test_transformer_nc.py
deleted file mode 100644
index 46d541be..00000000
--- a/tests/local/etl/test_transformer_nc.py
+++ /dev/null
@@ -1,110 +0,0 @@
-import unittest
-
-from pyspark.sql import DataFrame
-from pyspark.sql.types import IntegerType, StringType, StructField, StructType
-
-from spetlr.etl import TransformerNC
-from spetlr.etl.types import dataset_group
-from spetlr.spark import Spark
-
-
-class TransformerNCTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.transformer = TestTransformer()
-        cls.df = create_dataframe()
-
-        cls.transformer_output_key = TestTransformer(dataset_output_key="my_output_key")
-        cls.transformer_input_key = TestTransformer(dataset_input_keys="my_input_key")
-        cls.transformer_input_key_list = TestTransformer(
-            dataset_input_keys=["my_input_key_1", "my_input_key_2"]
-        )
-
-    def test_process(self):
-        # process is called when:
-        # - inputs has one df
-        # - dataset_input_key is not given
-        result = self.transformer.etl({"df": self.df})
-        self.assertIs(self.df, list(result.values())[1])
-
-    def test_process_many(self):
-        # process_many is called when:
-        # - inputs has more than one df
-        # - dataset_input_key is not given
-        result = self.transformer.etl({"df1": self.df, "df2": self.df})
-        self.assertEqual(6, list(result.values())[2].count())
-
-    def test_process_no_key(self):
-        # process sets dataset_ouput_key equivalent to the transformer class when:
-        # - dataset_output_key is not given
-        result = self.transformer.etl({"df": self.df})
-        self.assertEqual("TestTransformer", list(result.keys())[1])
-
-    def test_process_many_no_key(self):
-        # process_many sets dataset_ouput_key equivalent to the transformer class when:
-        # - dataset_output_key is not given
-        result = self.transformer.etl({"df1": self.df, "df2": self.df})
-        self.assertEqual("TestTransformer", list(result.keys())[2])
-
-    def test_process_output_key(self):
-        # process sets dataset_output_key equiavalent to the input when:
-        # - dataset_output_key is given
-        result = self.transformer_output_key.etl({"df": self.df})
-        self.assertEqual("my_output_key", list(result.keys())[1])
-
-    def test_process_many_output_key(self):
-        # process_many sets dataset_output_key equiavalent to the input when:
-        # - dataset_output_key is given
-        result = self.transformer_output_key.etl({"df1": self.df, "df2": self.df})
-        self.assertEqual("my_output_key", list(result.keys())[2])
-
-    def test_process_input_key(self):
-        # process is called when:
-        # - dataset_input_key is given
-        result = self.transformer_input_key.etl({"my_input_key": self.df})
-        self.assertIs(self.df, list(result.values())[1])
-
-        with self.assertRaises(KeyError):
-            # error when:
-            # - the provided dataset_input_key does not exist in inputs
-            self.transformer_input_key.etl({"df": self.df})
-
-    def test_process_many_input_key_list(self):
-        # process_many is called when:
-        # - dataset_input_key_list is given
-        result = self.transformer_input_key_list.etl(
-            {"my_input_key_1": self.df, "my_input_key_2": self.df}
-        )
-        self.assertEqual(6, list(result.values())[2].count())
-
-        with self.assertRaises(AssertionError):
-            # error when:
-            # - the provided dataset_input_key_list contains an incorrect key
-            self.transformer_input_key_list.etl({"df1": self.df, "df2": self.df})
-
-
-class TestTransformer(TransformerNC):
-    def process(self, df: DataFrame) -> DataFrame:
-        return df
-
-    def process_many(self, datasets: dataset_group) -> DataFrame:
-        assert len(datasets) == 2
-        df1, df2 = list(datasets.values())
-        return df1.union(df2)
-
-
-def create_dataframe():
-    data = [(1, "1"), (2, "2"), (3, "3")]
-
-    schema = StructType(
-        [
-            StructField("id", IntegerType(), False),
-            StructField("text", StringType(), False),
-        ]
-    )
-
-    return Spark.get().createDataFrame(data=data, schema=schema)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/tests/local/transformers/test_country_to_alphacode_transformer.py b/tests/local/transformers/test_country_to_alphacode_transformer.py
index 238b9ab3..e8624df2 100644
--- a/tests/local/transformers/test_country_to_alphacode_transformer.py
+++ b/tests/local/transformers/test_country_to_alphacode_transformer.py
@@ -2,10 +2,10 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import CountryToAlphaCodeTransformerNC
+from spetlr.transformers import CountryToAlphaCodeTransformer
 
 
-class CountryToAlphaCodeTransformer(DataframeTestCase):
+class CountryToAlphaCodeTransformerTest(DataframeTestCase):
     def test_country_to_alpha_code_transformer(self):
         inputSchema = T.StructType(
             [
@@ -22,7 +22,7 @@ def test_country_to_alpha_code_transformer(self):
 
         expectedData = [("DK",), ("DE",)]
 
-        df_transformed = CountryToAlphaCodeTransformerNC(col_name="countryCol").process(
+        df_transformed = CountryToAlphaCodeTransformer(col_name="countryCol").process(
             df_input
         )
 
@@ -53,7 +53,7 @@ def test_country_to_alpha_code_transformer_new_col(self):
             ),
         ]
 
-        df_transformed = CountryToAlphaCodeTransformerNC(
+        df_transformed = CountryToAlphaCodeTransformer(
             col_name="countryCol", output_col_name="alphaCodeCol"
         ).process(df_input)
 
@@ -76,7 +76,7 @@ def test_country_to_alpha_code_transformer_failure(self):
             ("",),
         ]
 
-        df_transformed = CountryToAlphaCodeTransformerNC(col_name="countryCol").process(
+        df_transformed = CountryToAlphaCodeTransformer(col_name="countryCol").process(
             df_input
         )
 
diff --git a/tests/local/transformers/test_drop_columns.py b/tests/local/transformers/test_drop_columns.py
index cc75db92..94963384 100644
--- a/tests/local/transformers/test_drop_columns.py
+++ b/tests/local/transformers/test_drop_columns.py
@@ -2,7 +2,7 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import DropColumnsTransformerNC
+from spetlr.transformers import DropColumnsTransformer
 
 
 class TestDropColumnsTransformer(DataframeTestCase):
@@ -29,7 +29,7 @@ def test_drop_columns_transformer(self):
             (1,),
         ]
 
-        df_transformed = DropColumnsTransformerNC(
-            columnList=["text1", "text2"]
-        ).process(df_input)
+        df_transformed = DropColumnsTransformer(columnList=["text1", "text2"]).process(
+            df_input
+        )
         self.assertDataframeMatches(df_transformed, None, expectedData)
diff --git a/tests/local/transformers/test_generate_md5_column_transformer_nc.py b/tests/local/transformers/test_generate_md5_column_transformer.py
similarity index 87%
rename from tests/local/transformers/test_generate_md5_column_transformer_nc.py
rename to tests/local/transformers/test_generate_md5_column_transformer.py
index 915dfa84..f5131666 100644
--- a/tests/local/transformers/test_generate_md5_column_transformer_nc.py
+++ b/tests/local/transformers/test_generate_md5_column_transformer.py
@@ -4,10 +4,10 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import GenerateMd5ColumnTransformerNC
+from spetlr.transformers import GenerateMd5ColumnTransformer
 
 
-class TestGenerateMd5ColumnTransformerNC(DataframeTestCase):
+class TestGenerateMd5ColumnTransformer(DataframeTestCase):
     def test_generate_md5_column(self):
         input_schema = T.StructType(
             [
@@ -23,7 +23,7 @@ def test_generate_md5_column(self):
 
         df_input = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-        df_transformed = GenerateMd5ColumnTransformerNC(
+        df_transformed = GenerateMd5ColumnTransformer(
             col_name="md5_col",
             col_list=["id", "text"],
         ).process(df_input)
@@ -53,7 +53,7 @@ def test_generate_md5_column_with_nulls(self):
 
         df_input = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-        df_transformed = GenerateMd5ColumnTransformerNC(
+        df_transformed = GenerateMd5ColumnTransformer(
             col_name="md5_col",
             col_list=["id", "text"],
         ).process(df_input)
diff --git a/tests/local/transformers/test_join_dataframes_transformer.py b/tests/local/transformers/test_join_dataframes_transformer.py
index 3d7bc703..be7f9ad0 100644
--- a/tests/local/transformers/test_join_dataframes_transformer.py
+++ b/tests/local/transformers/test_join_dataframes_transformer.py
@@ -6,10 +6,10 @@
     MoreThanTwoDataFramesException,
 )
 from spetlr.spark import Spark
-from spetlr.transformers import JoinDataframesTransformerNC
+from spetlr.transformers import JoinDataframesTransformer
 
 
-class TestJoinDataframesTransformerNC(DataframeTestCase):
+class TestJoinDataframesTransformer(DataframeTestCase):
     def test_data_join_inner(self):
         dataset = {}
 
@@ -46,7 +46,7 @@ def test_data_join_inner(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="inner",
@@ -109,7 +109,7 @@ def test_data_join_outer(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="outer",
@@ -176,7 +176,7 @@ def test_data_join_left_outer(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="left_outer",
@@ -240,7 +240,7 @@ def test_data_join_right_outer(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="right_outer",
@@ -306,7 +306,7 @@ def test_data_join_semi(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="semi",
@@ -366,7 +366,7 @@ def test_data_join_anti(self):
             schema=input2_schema, data=input2_data
         )
 
-        df_transformed = JoinDataframesTransformerNC(
+        df_transformed = JoinDataframesTransformer(
             first_dataframe_join_key="Id",
             second_dataframe_join_key="_Id",
             join_type="anti",
@@ -435,7 +435,7 @@ def test_data_join_MoreThanTwoDataFramesException(self):
         )
 
         with self.assertRaises(MoreThanTwoDataFramesException):
-            JoinDataframesTransformerNC(
+            JoinDataframesTransformer(
                 first_dataframe_join_key="Id",
                 second_dataframe_join_key="_Id",
                 join_type="anti",
@@ -480,7 +480,7 @@ def test_data_join_ColumnDoesNotExistException(self):
         )
 
         with self.assertRaises(ColumnDoesNotExistException):
-            JoinDataframesTransformerNC(
+            JoinDataframesTransformer(
                 first_dataframe_join_key="Id_col",
                 second_dataframe_join_key="_Id",
                 join_type="anti",
@@ -488,7 +488,7 @@ def test_data_join_ColumnDoesNotExistException(self):
             ).process_many(dataset)
 
         with self.assertRaises(ColumnDoesNotExistException):
-            JoinDataframesTransformerNC(
+            JoinDataframesTransformer(
                 first_dataframe_join_key="Id",
                 second_dataframe_join_key="_Id_col",
                 join_type="anti",
diff --git a/tests/local/transformers/test_select_and_cast_columns_transformer_nc.py b/tests/local/transformers/test_select_and_cast_columns_transformer.py
similarity index 92%
rename from tests/local/transformers/test_select_and_cast_columns_transformer_nc.py
rename to tests/local/transformers/test_select_and_cast_columns_transformer.py
index 88bc8a59..c249b023 100644
--- a/tests/local/transformers/test_select_and_cast_columns_transformer_nc.py
+++ b/tests/local/transformers/test_select_and_cast_columns_transformer.py
@@ -4,7 +4,7 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import SelectAndCastColumnsTransformerNC
+from spetlr.transformers import SelectAndCastColumnsTransformer
 
 
 class TestSelectAndCastColumnsTransformerNC(DataframeTestCase):
@@ -32,7 +32,7 @@ def test_select_transformer(self):
             ]
         )
 
-        transformed_df = SelectAndCastColumnsTransformerNC(
+        transformed_df = SelectAndCastColumnsTransformer(
             schema=transformer_schema
         ).process(input_df)
 
@@ -70,7 +70,7 @@ def test_cast_transformer(self):
             ]
         )
 
-        transformed_df = SelectAndCastColumnsTransformerNC(
+        transformed_df = SelectAndCastColumnsTransformer(
             schema=transformer_schema
         ).process(input_df)
 
diff --git a/tests/local/transformers/test_select_columns.py b/tests/local/transformers/test_select_columns.py
index 31ddf0cb..6b13a530 100644
--- a/tests/local/transformers/test_select_columns.py
+++ b/tests/local/transformers/test_select_columns.py
@@ -2,7 +2,7 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import SelectColumnsTransformerNC
+from spetlr.transformers import SelectColumnsTransformer
 
 
 class TestSelectColumnsTransformer(DataframeTestCase):
@@ -22,7 +22,7 @@ def test_select_columns_transformer(self):
 
         expectedData = [(42, 13.37, "Col4Data")]
 
-        transformed_df = SelectColumnsTransformerNC(
+        transformed_df = SelectColumnsTransformer(
             columnList=["Col2", "Col3", "Col4"]
         ).process(input_df)
 
diff --git a/tests/local/transformers/test_simple_dataframe_filter_transformer_nc.py b/tests/local/transformers/test_simple_dataframe_filter_transformer_nc.py
deleted file mode 100644
index d39eec68..00000000
--- a/tests/local/transformers/test_simple_dataframe_filter_transformer_nc.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import pyspark.sql.types as T
-from spetlrtools.testing import DataframeTestCase
-
-from spetlr.spark import Spark
-from spetlr.transformers import DataFrameFilterTransformerNC
-
-
-class TestDataFrameFilterTransformerNC(DataframeTestCase):
-    def test_filter_with_column_name_and_value(self):
-        """
-        This test accepts col_name and col_value in DataFrameFilterTransformer and
-        checks if the output dataframe is correctly filtered.
-        """
-        input_schema = T.StructType(
-            [
-                T.StructField("Col1", T.StringType(), True),
-                T.StructField("Col2", T.IntegerType(), True),
-                T.StructField("Col3", T.DoubleType(), True),
-                T.StructField("Col4", T.StringType(), True),
-                T.StructField("Col5", T.StringType(), True),
-            ]
-        )
-
-        input_data1 = ("Col1Data", 42, 13.37, "Col4Data", "Col5Data")
-        input_data2 = ("Col1Data_2nd", 43, 23.37, "Col4Data_2nd", "Col5Data_2nd")
-        input_data3 = ("Col1Data", 45, 20.15, "Col4Data_3rd", "Col5Data_3rd")
-
-        input_data = [input_data1, input_data2, input_data3]
-
-        input_df = Spark.get().createDataFrame(data=input_data, schema=input_schema)
-
-        transformed_df = DataFrameFilterTransformerNC(
-            col_value="Col1Data", col_name="Col1"
-        ).process(input_df)
-
-        transformed_df.show()
-
-        expected_data = [
-            input_data1,
-            input_data3,
-        ]
-
-        self.assertDataframeMatches(
-            df=transformed_df,
-            expected_data=expected_data,
-        )
diff --git a/tests/local/transformers/test_timezone_transformer_nc.py b/tests/local/transformers/test_timezone_transformer.py
similarity index 89%
rename from tests/local/transformers/test_timezone_transformer_nc.py
rename to tests/local/transformers/test_timezone_transformer.py
index e19461aa..baa2afc2 100644
--- a/tests/local/transformers/test_timezone_transformer_nc.py
+++ b/tests/local/transformers/test_timezone_transformer.py
@@ -2,10 +2,10 @@
 from spetlrtools.testing import DataframeTestCase
 
 from spetlr.spark import Spark
-from spetlr.transformers import TimeZoneTransformerNC
+from spetlr.transformers import TimeZoneTransformer
 
 
-class TimeZoneTransformerNCTest(DataframeTestCase):
+class TimeZoneTransformerTest(DataframeTestCase):
     def test_timezone_transformer(self):
         input_schema = T.StructType(
             [
@@ -18,7 +18,7 @@ def test_timezone_transformer(self):
 
         input_df = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-        transformed_df = TimeZoneTransformerNC(
+        transformed_df = TimeZoneTransformer(
             latitude_col="Latitude",
             longitude_col="Longitude",
         ).process(input_df)
@@ -46,7 +46,7 @@ def test_timezone_transformer_none(self):
 
         input_df = Spark.get().createDataFrame(data=input_data, schema=input_schema)
 
-        transformed_df = TimeZoneTransformerNC(
+        transformed_df = TimeZoneTransformer(
             latitude_col="Latitude",
             longitude_col="Longitude",
         ).process(input_df)
diff --git a/tests/local/transformers/test_union_transformer_nc.py b/tests/local/transformers/test_union_transformer_nc.py
deleted file mode 100644
index efe9620d..00000000
--- a/tests/local/transformers/test_union_transformer_nc.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import pyspark.sql.types as T
-from spetlrtools.testing import DataframeTestCase
-
-from spetlr.spark import Spark
-from spetlr.transformers import UnionTransformerNC
-
-
-class TestUnionTransformer(DataframeTestCase):
-    def test_union_two_dataframes(self):
-        input_schema = T.StructType(
-            [
-                T.StructField("Col1", T.StringType(), True),
-                T.StructField("Col2", T.IntegerType(), True),
-                T.StructField("Col3", T.DoubleType(), True),
-                T.StructField("Col4", T.StringType(), True),
-                T.StructField("Col5", T.StringType(), True),
-            ]
-        )
-
-        input_data1 = [("Col1Data", 42, 13.37, "Col4Data", "Col5Data")]
-        input_data2 = [("Col1Data_2nd", 42, 13.37, "Col4Data_2nd", "Col5Data_2nd")]
-
-        input_df_1 = Spark.get().createDataFrame(data=input_data1, schema=input_schema)
-        input_df_2 = Spark.get().createDataFrame(data=input_data2, schema=input_schema)
-        input_datasets = {"DF1": input_df_1, "DF2": input_df_2}
-
-        transformed_df = UnionTransformerNC().process_many(input_datasets)
-
-        expected_data = [
-            ("Col1Data", 42, 13.37, "Col4Data", "Col5Data"),
-            ("Col1Data_2nd", 42, 13.37, "Col4Data_2nd", "Col5Data_2nd"),
-        ]
-
-        self.assertDataframeMatches(
-            df=transformed_df,
-            expected_data=expected_data,
-        )
-
-    def test_union_three_dataframes(self):
-        input_schema = T.StructType(
-            [
-                T.StructField("Col1", T.StringType(), True),
-                T.StructField("Col2", T.IntegerType(), True),
-                T.StructField("Col3", T.DoubleType(), True),
-                T.StructField("Col4", T.StringType(), True),
-                T.StructField("Col5", T.StringType(), True),
-            ]
-        )
-
-        input_data1 = [("Col1Data", 42, 13.37, "Col4Data", "Col5Data")]
-        input_data2 = [("Col1Data_2nd", 42, 13.37, "Col4Data_2nd", "Col5Data_2nd")]
-        input_data3 = [
-            (
-                "Totally new data",
-                1234,
-                98.76,
-                "More totally new data",
-                "Again, totally new data",
-            )
-        ]
-
-        input_df_1 = Spark.get().createDataFrame(data=input_data1, schema=input_schema)
-        input_df_2 = Spark.get().createDataFrame(data=input_data2, schema=input_schema)
-        input_df_3 = Spark.get().createDataFrame(data=input_data3, schema=input_schema)
-        input_datasets = {"DF1": input_df_1, "DF2": input_df_2, "DF3": input_df_3}
-
-        transformed_df = UnionTransformerNC().process_many(input_datasets)
-
-        expected_data = [
-            ("Col1Data", 42, 13.37, "Col4Data", "Col5Data"),
-            ("Col1Data_2nd", 42, 13.37, "Col4Data_2nd", "Col5Data_2nd"),
-            (
-                "Totally new data",
-                1234,
-                98.76,
-                "More totally new data",
-                "Again, totally new data",
-            ),
-        ]
-
-        self.assertDataframeMatches(df=transformed_df, expected_data=expected_data)
-
-    def test_union_dataframes_missing_columns(self):
-        input_schema1 = T.StructType(
-            [
-                T.StructField("Col1", T.StringType(), True),
-                T.StructField("Col2", T.IntegerType(), True),
-                T.StructField("Col3", T.DoubleType(), True),
-                T.StructField("Col4", T.StringType(), True),
-                T.StructField("Col5", T.StringType(), True),
-            ]
-        )
-        input_data1 = [
-            (
-                "Col1Data",
-                42,
-                13.37,
-                "Col4Data",
-                "Col5Data",
-            )
-        ]
-
-        input_schema2 = T.StructType(
-            [
-                T.StructField("Col1", T.StringType(), True),
-                T.StructField("Col2", T.IntegerType(), True),
-                T.StructField("Col3", T.DoubleType(), True),
-                T.StructField("Col4", T.StringType(), True),
-            ]
-        )
-        input_data2 = [("Col1Data_2nd", 42, 13.37, "Col4Data_2nd")]
-
-        input_df_1 = Spark.get().createDataFrame(data=input_data1, schema=input_schema1)
-        input_df_2 = Spark.get().createDataFrame(data=input_data2, schema=input_schema2)
-        input_datasets = {"DF1": input_df_1, "DF2": input_df_2}
-
-        transformed_df = UnionTransformerNC(allowMissingColumns=True).process_many(
-            input_datasets
-        )
-
-        expected_data = [
-            ("Col1Data", 42, 13.37, "Col4Data", "Col5Data"),
-            ("Col1Data_2nd", 42, 13.37, "Col4Data_2nd", None),
-        ]
-
-        self.assertDataframeMatches(df=transformed_df, expected_data=expected_data)