diff --git a/cdisc_rules_engine/check_operators/helpers.py b/cdisc_rules_engine/check_operators/helpers.py
index 4a9348b8e..a676f435e 100644
--- a/cdisc_rules_engine/check_operators/helpers.py
+++ b/cdisc_rules_engine/check_operators/helpers.py
@@ -430,4 +430,3 @@ def flatten_list(data, items):
 vectorized_get_dict_key = np.vectorize(get_dict_key_val)
 vectorized_is_in = np.vectorize(is_in)
 vectorized_case_insensitive_is_in = np.vectorize(case_insensitive_is_in)
-vectorized_len = np.vectorize(len)
diff --git a/cdisc_rules_engine/constants/__init__.py b/cdisc_rules_engine/constants/__init__.py
index afe9572f7..4279e87b5 100644
--- a/cdisc_rules_engine/constants/__init__.py
+++ b/cdisc_rules_engine/constants/__init__.py
@@ -2,17 +2,6 @@
 
 # a message like: [INFO 2021-12-29 17:10:26,575 - module.py:44] - Log Message
 LOG_FORMAT: str = "[%(levelname)s %(asctime)s - %(filename)s:%(lineno)s] - %(message)s"
-XPT_LABEL_PATTERN: str = (
-    "HEADER RECORD\\*{7}MEMBER {2}HEADER RECORD!{7}0{17}160{8}140 "
-    "{2}HEADER RECORD\\*{7}DSCRPTR HEADER RECORD!{7}0{30}"
-    "  SAS\\s{5}.{8}SASDATA .{16}\\s{24}.{16}.{16}\\s{16}(?P<label>.{40})"
-)
-
-XPT_MODIFIED_DATE_PATTERN: str = (
-    "HEADER RECORD\\*{7}MEMBER {2}HEADER RECORD!{7}0{17}160{8}140 "
-    "{2}HEADER RECORD\\*{7}DSCRPTR HEADER RECORD!{7}0{30}"
-    "  SAS\\s{5}.{8}SASDATA .{16}\\s{24}.{16}(?P<modified_date>.{16})\\s{16}.{40}"
-)
 
 NULL_FLAVORS = ["", None, {}, {None}, [], [None], np.nan]
 
diff --git a/cdisc_rules_engine/constants/domains.py b/cdisc_rules_engine/constants/domains.py
index c28d844a5..166b3598f 100644
--- a/cdisc_rules_engine/constants/domains.py
+++ b/cdisc_rules_engine/constants/domains.py
@@ -1,5 +1,4 @@
 SUPPLEMENTARY_DOMAINS = ("SUPP", "SQ")
-AP_DOMAIN_LENGTH: int = 4
 AP_DOMAIN: str = "AP"
 APFA_DOMAIN: str = "APFA"
 APRELSUB_DOMAIN: str = "APRELSUB"
diff --git a/cdisc_rules_engine/constants/patterns.py b/cdisc_rules_engine/constants/patterns.py
deleted file mode 100644
index 6d88abdd3..000000000
--- a/cdisc_rules_engine/constants/patterns.py
+++ /dev/null
@@ -1,11 +0,0 @@
-XPT_LABEL_PATTERN: str = (
-    "HEADER RECORD\\*{7}MEMBER {2}HEADER RECORD!{7}0{17}160{8}140 "
-    "{2}HEADER RECORD\\*{7}DSCRPTR HEADER RECORD!{7}0{30}"
-    "  SAS\\s{5}.{8}SASDATA .{16}\\s{24}.{16}.{16}\\s{16}(?P<label>.{40})"
-)
-
-XPT_MODIFIED_DATE_PATTERN: str = (
-    "HEADER RECORD\\*{7}MEMBER {2}HEADER RECORD!{7}0{17}160{8}140 "
-    "{2}HEADER RECORD\\*{7}DSCRPTR HEADER RECORD!{7}0{30}"
-    "  SAS\\s{5}.{8}SASDATA .{16}\\s{24}.{16}(?P<modified_date>.{16})\\s{16}.{40}"
-)
diff --git a/cdisc_rules_engine/enums/default_file_paths.py b/cdisc_rules_engine/enums/default_file_paths.py
index 317589c68..20c166133 100644
--- a/cdisc_rules_engine/enums/default_file_paths.py
+++ b/cdisc_rules_engine/enums/default_file_paths.py
@@ -15,7 +15,6 @@ class DefaultFilePaths(BaseEnum):
     STANDARD_MODELS_CACHE_FILE = "standards_models.pkl"
     VARIABLE_METADATA_CACHE_FILE = "variables_metadata.pkl"
     VARIABLE_CODELIST_CACHE_FILE = "variable_codelist_maps.pkl"
-    CODELIST_TERM_MAP_CACHE_FILE = "codelist_term_maps.pkl"
     CUSTOM_RULES_CACHE_FILE = "custom_rules.pkl"
     CUSTOM_RULES_DICTIONARY = "custom_rules_dictionary.pkl"
     LOCAL_XSD_FILE_DIR = join("resources", "schema", "xml")
diff --git a/cdisc_rules_engine/exceptions/__init__.py b/cdisc_rules_engine/exceptions/__init__.py
index 509279a2f..c6be5eab0 100644
--- a/cdisc_rules_engine/exceptions/__init__.py
+++ b/cdisc_rules_engine/exceptions/__init__.py
@@ -11,7 +11,6 @@
     DomainNotFoundInDefineXMLError,
     InvalidDatasetFormat,
     InvalidJSONFormat,
-    NumberOfAttemptsExceeded,
     InvalidDictionaryVariable,
     UnsupportedDictionaryType,
     FailedSchemaValidation,
@@ -37,7 +36,6 @@
     "DomainNotFoundInDefineXMLError",
     "InvalidDatasetFormat",
     "InvalidJSONFormat",
-    "NumberOfAttemptsExceeded",
     "InvalidDictionaryVariable",
     "UnsupportedDictionaryType",
     "FailedSchemaValidation",
diff --git a/cdisc_rules_engine/exceptions/custom_exceptions.py b/cdisc_rules_engine/exceptions/custom_exceptions.py
index a0e3b140f..7e5b818b3 100644
--- a/cdisc_rules_engine/exceptions/custom_exceptions.py
+++ b/cdisc_rules_engine/exceptions/custom_exceptions.py
@@ -87,10 +87,6 @@ class InvalidCSVFile(EngineError):
     description = "CSV data is malformed."
 
 
-class NumberOfAttemptsExceeded(EngineError):
-    pass
-
-
 class InvalidDictionaryVariable(EngineError):
     description = (
         "Provided dictionary variable does not correspond to a dictionary term type"
diff --git a/cdisc_rules_engine/interfaces/data_service_interface.py b/cdisc_rules_engine/interfaces/data_service_interface.py
index 861bcc8d5..3b7d5a5dd 100644
--- a/cdisc_rules_engine/interfaces/data_service_interface.py
+++ b/cdisc_rules_engine/interfaces/data_service_interface.py
@@ -57,15 +57,6 @@ def get_variables_metadata(self, dataset_name: str) -> DatasetInterface:
         Gets variables metadata of a dataset.
         """
 
-    @abstractmethod
-    def get_dataset_by_type(
-        self, dataset_name: str, dataset_type: str, **params
-    ) -> DatasetInterface:
-        """
-        Generic function to return dataset based on the type.
-        dataset_type param can be: contents, metadata, variables_metadata.
-        """
-
     @abstractmethod
     def concat_split_datasets(
         self,
diff --git a/cdisc_rules_engine/models/dataset/dask_dataset.py b/cdisc_rules_engine/models/dataset/dask_dataset.py
index 7303bd1dd..f966d1d33 100644
--- a/cdisc_rules_engine/models/dataset/dask_dataset.py
+++ b/cdisc_rules_engine/models/dataset/dask_dataset.py
@@ -405,10 +405,6 @@ def partition_isin(partition):
         result = self._data.map_partitions(partition_isin)
         return result
 
-    def filter_by_value(self, column, values):
-        mask = self._data[column].isin(values)
-        return self.__class__(self._data[mask])
-
     def max(self, *args, **kwargs):
         result = self._data.max(*args, **kwargs)
         return self.__class__(result)
diff --git a/cdisc_rules_engine/models/dataset_types.py b/cdisc_rules_engine/models/dataset_types.py
index d54ca5655..f58bee8d1 100644
--- a/cdisc_rules_engine/models/dataset_types.py
+++ b/cdisc_rules_engine/models/dataset_types.py
@@ -3,6 +3,5 @@
 
 class DatasetTypes(BaseEnum):
     CONTENTS = "contents"
-    METADATA = "metadata"
-    RAW_METADATA = "raw_metadata"
+    DATASET_METADATA = "dataset_metadata"
     VARIABLES_METADATA = "variables_metadata"
diff --git a/cdisc_rules_engine/models/record_variable.py b/cdisc_rules_engine/models/record_variable.py
deleted file mode 100644
index 2c6568c87..000000000
--- a/cdisc_rules_engine/models/record_variable.py
+++ /dev/null
@@ -1,39 +0,0 @@
-from business_rules.variables import BaseVariables, generic_rule_variable
-
-
-class RecordVariable(BaseVariables):
-    def __init__(self, record):
-        self.record = record
-
-    # common variables
-    @generic_rule_variable(label="VALUE CHECK")
-    def check_value(self, params):
-        value = self.record.get(params.get("target"))
-        if isinstance(value, bytes):
-            value = value.decode("utf-8")
-        return value
-
-    @generic_rule_variable(label="VALUE CHECK PREFIX")
-    def check_value_prefix(self, params) -> str:
-        """
-        Returns prefix of a value that should be checked
-        """
-        value: str = self.record.get(params.get("target"))
-        if isinstance(value, bytes):
-            value = value.decode("utf-8")
-        prefix: str = params.get("prefix")
-        if prefix:
-            value = value[:prefix]
-        return value
-
-    @generic_rule_variable(label="VALUE CHECK SUFFIX")
-    def check_value_suffix(self, params: dict) -> str:
-        """
-        Returns suffix of a value that should be checked
-        """
-        value: str = self.check_value(params)
-        suffix: int = params.get("suffix")
-        if suffix:
-            # use last n chars of a string
-            value = value[-suffix:]
-        return value
diff --git a/cdisc_rules_engine/operations/base_operation.py b/cdisc_rules_engine/operations/base_operation.py
index 633726f69..fecf8d07f 100644
--- a/cdisc_rules_engine/operations/base_operation.py
+++ b/cdisc_rules_engine/operations/base_operation.py
@@ -29,7 +29,6 @@
     VariableMetadataNotFoundError,
     DomainNotFoundInDefineXMLError,
     InvalidDatasetFormat,
-    NumberOfAttemptsExceeded,
     InvalidDictionaryVariable,
     UnsupportedDictionaryType,
     FailedSchemaValidation,
@@ -79,7 +78,6 @@ def execute(self) -> DatasetInterface:
             VariableMetadataNotFoundError,
             DomainNotFoundInDefineXMLError,
             InvalidDatasetFormat,
-            NumberOfAttemptsExceeded,
             InvalidDictionaryVariable,
             UnsupportedDictionaryType,
             FailedSchemaValidation,
diff --git a/cdisc_rules_engine/operations/operations_factory.py b/cdisc_rules_engine/operations/operations_factory.py
index 37aee00cd..63db1dfb7 100644
--- a/cdisc_rules_engine/operations/operations_factory.py
+++ b/cdisc_rules_engine/operations/operations_factory.py
@@ -10,6 +10,9 @@
 )
 from cdisc_rules_engine.operations.distinct import Distinct
 from cdisc_rules_engine.operations.extract_metadata import ExtractMetadata
+from cdisc_rules_engine.operations.get_library_class_domains import (
+    GetLibraryClassDomains,
+)
 from cdisc_rules_engine.operations.get_xhtml_errors import GetXhtmlErrors
 from cdisc_rules_engine.operations.library_column_order import LibraryColumnOrder
 from cdisc_rules_engine.operations.library_model_column_order import (
@@ -102,6 +105,7 @@ class OperationsFactory(FactoryInterface):
         "get_column_order_from_dataset": DatasetColumnOrder,
         "get_column_order_from_library": LibraryColumnOrder,
         "get_codelist_attributes": CodeListAttributes,
+        "get_library_class_domains": GetLibraryClassDomains,
         "get_model_column_order": LibraryModelColumnOrder,
         "get_model_filtered_variables": LibraryModelVariablesFilter,
         "get_parent_model_column_order": ParentLibraryModelColumnOrder,
diff --git a/cdisc_rules_engine/plugin_loader.py b/cdisc_rules_engine/plugin_loader.py
index 2005da548..28899e0c6 100644
--- a/cdisc_rules_engine/plugin_loader.py
+++ b/cdisc_rules_engine/plugin_loader.py
@@ -40,19 +40,6 @@ def load(self):
             group_plugins: EntryPoints = entry_points().select(group=group_name)
             self.__register_group_plugins(factory_class, group_plugins)
 
-    @classmethod
-    def register_group_factory(
-        cls, group_name: str, factory_class: Type[FactoryInterface]
-    ):
-        """
-        Registers new plugin group and factory.
-        """
-        if not issubclass(factory_class, FactoryInterface):
-            raise ValueError(
-                f"Given class {factory_class} must implement FactoryInterface"
-            )
-        cls.__group_factory_map[group_name] = factory_class
-
     def __register_group_plugins(
         self, factory_class: Type[FactoryInterface], group_plugins: EntryPoints
     ):
diff --git a/cdisc_rules_engine/services/data_services/base_data_service.py b/cdisc_rules_engine/services/data_services/base_data_service.py
index 25a22f517..d1552d1aa 100644
--- a/cdisc_rules_engine/services/data_services/base_data_service.py
+++ b/cdisc_rules_engine/services/data_services/base_data_service.py
@@ -1,9 +1,7 @@
-import asyncio
 from abc import ABC, abstractmethod
-from functools import wraps, partial
+from functools import wraps
 from typing import Callable, List, Optional, Iterable, Iterator
 from concurrent.futures import ThreadPoolExecutor
-import os
 import numpy as np
 import dask.dataframe as dd
 
@@ -30,7 +28,6 @@
 from cdisc_rules_engine.models.dataset_metadata import DatasetMetadata
 from cdisc_rules_engine.models.dataset_types import DatasetTypes
 from cdisc_rules_engine.services import logger
-from cdisc_rules_engine.services.cdisc_library_service import CDISCLibraryService
 from cdisc_rules_engine.services.data_readers import DataReaderFactory
 from cdisc_rules_engine.utilities.utils import (
     get_dataset_cache_key_from_path,
@@ -105,9 +102,6 @@ def __init__(
         self.cache_service = cache_service
         self._reader_factory = reader_factory
         self._config = config
-        self.cdisc_library_service: CDISCLibraryService = CDISCLibraryService(
-            self._config.getValue("CDISC_LIBRARY_API_KEY", ""), self.cache_service
-        )
         self.standard = kwargs.get("standard")
         self.version = (kwargs.get("standard_version") or "").replace(".", "-")
         self.standard_substandard = kwargs.get("standard_substandard")
@@ -120,22 +114,6 @@ def __init__(
             self._initialize_datasets_metadata(**kwargs)
         )
 
-    def get_dataset_by_type(
-        self, dataset_name: str, dataset_type: str, **params
-    ) -> DatasetInterface:
-        """
-        Generic function to return dataset based on the type.
-        dataset_type param can be: contents, metadata, variables_metadata.
-        """
-        dataset_type_to_function_map: dict = {
-            DatasetTypes.CONTENTS.value: self.get_dataset,
-            DatasetTypes.METADATA.value: self.get_dataset_metadata,
-            DatasetTypes.VARIABLES_METADATA.value: self.get_variables_metadata,
-        }
-        return dataset_type_to_function_map[dataset_type](
-            dataset_name=dataset_name, **params
-        )
-
     def concat_split_datasets(
         self,
         func_to_call: Callable,
@@ -163,12 +141,6 @@ def concat_split_datasets(
 
         return full_dataset
 
-    def check_filepath(self, dataset_names: List[str]) -> List:
-        """
-        Check if single file with multiple datasets.
-        """
-        return any(not os.path.exists(name) for name in dataset_names)
-
     def get_dataset_class(
         self,
         dataset: DatasetInterface,
@@ -202,7 +174,7 @@ def get_data_structure(
             return OCCDS
         return OTHER
 
-    @cached_dataset(DatasetTypes.METADATA.value)
+    @cached_dataset(DatasetTypes.DATASET_METADATA.value)
     def get_dataset_metadata(self, dataset_name: str, **params) -> DatasetInterface:
         """
         Gets metadata of a dataset and returns it as a DataFrame.
@@ -349,14 +321,6 @@ def check_presence(key):
         elif check_presence("RDOMAIN"):
             return check_presence(variable)
 
-    def _domain_starts_with(self, domain, variable):
-        """
-        Checks if the given dataset-class string starts with
-         a particular variable string.
-        Returns True/False
-        """
-        return domain.startswith(variable)
-
     @staticmethod
     def _replace_nans_in_numeric_cols_with_none(dataset: DatasetInterface):
         """
@@ -383,17 +347,6 @@ def _replace_nans_in_specified_cols_with_none(
             dataset.data = replace_nan_values_in_df(dataset.data, valid_columns)
         return dataset
 
-    async def _async_get_dataset(
-        self, function_to_call: Callable, dataset_name: str, **kwargs
-    ) -> DatasetInterface:
-        """
-        Asynchronously executes passed function_to_call.
-        """
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(
-            None, partial(function_to_call, dataset_name=dataset_name, **kwargs)
-        )
-
     def _async_get_datasets(
         self, function_to_call: Callable, dataset_names: List[str], **kwargs
     ) -> Iterator[DatasetInterface]:
diff --git a/cdisc_rules_engine/services/data_services/dummy_data_service.py b/cdisc_rules_engine/services/data_services/dummy_data_service.py
index 27d9d78db..b2caa3796 100644
--- a/cdisc_rules_engine/services/data_services/dummy_data_service.py
+++ b/cdisc_rules_engine/services/data_services/dummy_data_service.py
@@ -6,7 +6,6 @@
 from cdisc_rules_engine.dummy_models.dummy_dataset import DummyDataset
 from cdisc_rules_engine.interfaces import CacheServiceInterface, ConfigInterface
 from cdisc_rules_engine.models.sdtm_dataset_metadata import SDTMDatasetMetadata
-from cdisc_rules_engine.models.dataset_types import DatasetTypes
 from cdisc_rules_engine.services.data_readers import DataReaderFactory
 from cdisc_rules_engine.services.data_readers.json_reader import JSONReader
 from cdisc_rules_engine.services.data_services import BaseDataService
@@ -112,18 +111,6 @@ def get_variables_metadata(self, dataset_name: str) -> PandasDataset:
             ] + [variable.format]
         return PandasDataset.from_dict(metadata_to_return)
 
-    def get_dataset_by_type(
-        self, dataset_name: str, dataset_type: str, **params
-    ) -> PandasDataset:
-        dataset_type_to_function_map: dict = {
-            DatasetTypes.CONTENTS.value: self.get_dataset,
-            DatasetTypes.METADATA.value: self.get_dataset_metadata,
-            DatasetTypes.VARIABLES_METADATA.value: self.get_variables_metadata,
-        }
-        return dataset_type_to_function_map[dataset_type](
-            dataset_name=dataset_name, **params
-        )
-
     def get_define_xml_contents(self, dataset_name: str) -> bytes:
         if not self.define_xml:
             # Search for define xml locally
diff --git a/cdisc_rules_engine/services/data_services/local_data_service.py b/cdisc_rules_engine/services/data_services/local_data_service.py
index 8e9d2a1c2..1893a0520 100644
--- a/cdisc_rules_engine/services/data_services/local_data_service.py
+++ b/cdisc_rules_engine/services/data_services/local_data_service.py
@@ -170,22 +170,6 @@ def get_define_xml_contents(self, dataset_name: str) -> bytes:
         with open(dataset_name, "rb") as f:
             return f.read()
 
-    def get_dataset_by_type(
-        self, dataset_name: str, dataset_type: str, **params
-    ) -> DatasetInterface:
-        """
-        Generic function to return dataset based on the type.
-        dataset_type param can be: contents, metadata, variables_metadata.
-        """
-        dataset_type_to_function_map: dict = {
-            DatasetTypes.CONTENTS.value: self.get_dataset,
-            DatasetTypes.METADATA.value: self.get_dataset_metadata,
-            DatasetTypes.VARIABLES_METADATA.value: self.get_variables_metadata,
-        }
-        return dataset_type_to_function_map[dataset_type](
-            dataset_name=dataset_name, **params
-        )
-
     def __read_metadata(
         self,
         dataset_path: str,
diff --git a/cdisc_rules_engine/services/data_services/usdm_data_service.py b/cdisc_rules_engine/services/data_services/usdm_data_service.py
index a2d06fd1d..34ebe2285 100644
--- a/cdisc_rules_engine/services/data_services/usdm_data_service.py
+++ b/cdisc_rules_engine/services/data_services/usdm_data_service.py
@@ -84,8 +84,6 @@ def __init__(
 
         self.dataset_content_index: List[dict] = self.__get_datasets_content_index()
 
-        self._jsonpath_cache = {}
-
         super(USDMDataService, self).__init__(
             cache_service, reader_factory, config, **kwargs
         )
@@ -243,16 +241,6 @@ def __get_record_data(self, node: dict, parent="") -> dict:
             flattened = {"value": node}
         return flattened
 
-    @staticmethod
-    def __get_parent(node):
-        # Native node: just return node itself
-        return node
-
-    @staticmethod
-    def __get_closest_non_list_ancestor(node):
-        # Native node: just return node itself
-        return node
-
     @staticmethod
     def jsonpath_to_pointer(path_expr: str) -> str:
         pointer = path_expr.replace("$.", "/").replace(".", "/")
@@ -323,12 +311,6 @@ def __find_definition(self, json, id: str):
         # Use the pre-built lookup dict for fast access
         return self._id_lookup.get(id, None)
 
-    def _get_parsed_jsonpath(self, path_expr):
-        key = path_expr.strip()
-        if key not in self._jsonpath_cache:
-            self._jsonpath_cache[key] = parse(key)
-        return self._jsonpath_cache[key]
-
     def __get_dataset(self, dataset_name: str) -> DatasetInterface:
         datasets = self.dataset_content_index
         dataset_paths = [
diff --git a/cdisc_rules_engine/services/datasetjson_metadata_reader.py b/cdisc_rules_engine/services/datasetjson_metadata_reader.py
index becc6474d..1d7664100 100644
--- a/cdisc_rules_engine/services/datasetjson_metadata_reader.py
+++ b/cdisc_rules_engine/services/datasetjson_metadata_reader.py
@@ -134,25 +134,6 @@ def _convert_variable_types(self):
                 rule_author_type_map[value]
             )
 
-    def _to_dict(self) -> dict:
-        """
-        This method is used to transform metadata_container
-        object into dictionary.
-        """
-        return {
-            "variable_labels": self._metadata_container.column_labels,
-            "variable_formats": self._metadata_container.column_formats,
-            "variable_names": self._metadata_container.column_names,
-            "variable_name_to_label_map": self._metadata_container.column_names_to_labels,  # noqa
-            "variable_name_to_data_type_map": self._metadata_container.readstat_variable_types,  # noqa
-            "variable_name_to_size_map": self._metadata_container.variable_storage_width,  # noqa
-            "number_of_variables": self._metadata_container.number_columns,
-            "dataset_label": self._metadata_container.file_label,
-            "first_record": self._first_record,
-            "dataset_name": self._dataset_name,
-            "dataset_modification_date": self._metadata_container.dataset_modification_date,  # noqa
-        }
-
     def _extract_adam_info(self, variable_names):
         ad = AdamVariableReader()
         adam_columns = ad.extract_columns(variable_names)
diff --git a/cdisc_rules_engine/services/datasetndjson_metadata_reader.py b/cdisc_rules_engine/services/datasetndjson_metadata_reader.py
index faf0ed399..a2bd01399 100644
--- a/cdisc_rules_engine/services/datasetndjson_metadata_reader.py
+++ b/cdisc_rules_engine/services/datasetndjson_metadata_reader.py
@@ -159,25 +159,6 @@ def _convert_variable_types(self):
                 rule_author_type_map[value]
             )
 
-    def _to_dict(self) -> dict:
-        """
-        This method is used to transform metadata_container
-        object into dictionary.
-        """
-        return {
-            "variable_labels": self._metadata_container.column_labels,
-            "variable_formats": self._metadata_container.column_formats,
-            "variable_names": self._metadata_container.column_names,
-            "variable_name_to_label_map": self._metadata_container.column_names_to_labels,  # noqa
-            "variable_name_to_data_type_map": self._metadata_container.readstat_variable_types,  # noqa
-            "variable_name_to_size_map": self._metadata_container.variable_storage_width,  # noqa
-            "number_of_variables": self._metadata_container.number_columns,
-            "dataset_label": self._metadata_container.file_label,
-            "first_record": self._first_record,
-            "dataset_name": self._dataset_name,
-            "dataset_modification_date": self._metadata_container.dataset_modification_date,  # noqa
-        }
-
     def _extract_adam_info(self, variable_names):
         ad = AdamVariableReader()
         adam_columns = ad.extract_columns(variable_names)
diff --git a/cdisc_rules_engine/services/datasetxpt_metadata_reader.py b/cdisc_rules_engine/services/datasetxpt_metadata_reader.py
index 02c1a5ff1..f20506c91 100644
--- a/cdisc_rules_engine/services/datasetxpt_metadata_reader.py
+++ b/cdisc_rules_engine/services/datasetxpt_metadata_reader.py
@@ -174,25 +174,6 @@ def _convert_variable_types(self):
                 rule_author_type_map[value]
             )
 
-    def _to_dict(self) -> dict:
-        """
-        This method is used to transform metadata_container
-        object into dictionary.
-        """
-        return {
-            "variable_labels": self._metadata_container.column_labels,
-            "variable_formats": self._metadata_container.column_formats,
-            "variable_names": self._metadata_container.column_names,
-            "variable_name_to_label_map": self._metadata_container.column_names_to_labels,  # noqa
-            "variable_name_to_data_type_map": self._metadata_container.readstat_variable_types,  # noqa
-            "variable_name_to_size_map": self._metadata_container.variable_storage_width,  # noqa
-            "number_of_variables": self._metadata_container.number_columns,
-            "dataset_label": self._metadata_container.file_label,
-            "first_record": self._first_record,
-            "dataset_name": self._dataset_name,
-            "dataset_modification_date": self._metadata_container.dataset_modification_date,  # noqa
-        }
-
     def _extract_adam_info(self, variable_names):
         ad = AdamVariableReader()
         adam_columns = ad.extract_columns(variable_names)
diff --git a/cdisc_rules_engine/services/define_xml/base_define_xml_reader.py b/cdisc_rules_engine/services/define_xml/base_define_xml_reader.py
index b801f24a7..7b6f18e33 100644
--- a/cdisc_rules_engine/services/define_xml/base_define_xml_reader.py
+++ b/cdisc_rules_engine/services/define_xml/base_define_xml_reader.py
@@ -12,6 +12,7 @@
 import odmlib.define_2_1.model  # noqa F401
 import odmlib.define_2_0.model  # noqa F401
 
+from cdisc_rules_engine.constants.domains import SUPPLEMENTARY_DOMAINS
 from cdisc_rules_engine.exceptions.custom_exceptions import (
     DomainNotFoundInDefineXMLError,
     FailedSchemaValidation,
@@ -19,7 +20,6 @@
 from cdisc_rules_engine.models.define import ValueLevelMetadata
 from cdisc_rules_engine.services import logger
 from cdisc_rules_engine.utilities.decorators import cached
-from cdisc_rules_engine.utilities.sdtm_utilities import is_supp_domain
 
 
 @dataclass
@@ -38,6 +38,14 @@ class StandardsCTMetadata:
     publishing_set: str = None
 
 
+@staticmethod
+def is_supp_domain(dataset_domain: str) -> bool:
+    """
+    Returns true if domain name starts with SUPP or SQ
+    """
+    return dataset_domain.startswith(SUPPLEMENTARY_DOMAINS)
+
+
 class BaseDefineXMLReader(ABC):
     """
     This class is responsible for extracting
diff --git a/cdisc_rules_engine/utilities/data_processor.py b/cdisc_rules_engine/utilities/data_processor.py
index 026df1761..7f8222686 100644
--- a/cdisc_rules_engine/utilities/data_processor.py
+++ b/cdisc_rules_engine/utilities/data_processor.py
@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Optional, TYPE_CHECKING
+from typing import List, TYPE_CHECKING
 
 from cdisc_rules_engine.models.dataset import PandasDataset, DaskDataset
 from cdisc_rules_engine.models.sdtm_dataset_metadata import SDTMDatasetMetadata
@@ -469,46 +469,6 @@ def merge_sdtm_datasets(
                 ] = None
         return result
 
-    @staticmethod
-    def filter_dataset_columns_by_metadata_and_rule(
-        columns: List[str],
-        define_metadata: List[dict],
-        library_metadata: dict,
-        rule: dict,
-    ) -> List[str]:
-        """
-        Leaves only those variables where:
-            variable origin type is the same as in rule and
-            variable core status is the same as in rule
-        """
-        targets: List[str] = []
-        for column in columns:
-            if DataProcessor.column_metadata_equal_to_define_and_library(
-                column, define_metadata, library_metadata, rule
-            ):
-                targets.append(column)
-        return targets
-
-    @staticmethod
-    def column_metadata_equal_to_define_and_library(
-        column: str,
-        define_metadata: List[dict],
-        library_metadata: dict,
-        rule: dict,
-    ) -> bool:
-        define_variable_metadata: Optional[dict] = search_in_list(
-            define_metadata, lambda item: item.get("define_variable_name") == column
-        )
-        if not define_variable_metadata:
-            return False
-        equal_origin_type: bool = define_variable_metadata[
-            "define_variable_origin_type"
-        ] == rule.get("variable_origin_type")
-        equal_core_status: bool = library_metadata.get(column, {}).get(
-            "core"
-        ) == rule.get("variable_core_status")
-        return equal_core_status and equal_origin_type
-
     @staticmethod
     def is_dummy_data(data_service: DataServiceInterface) -> bool:
         return isinstance(data_service, DummyDataService)
diff --git a/cdisc_rules_engine/utilities/dataset_preprocessor.py b/cdisc_rules_engine/utilities/dataset_preprocessor.py
index 620f8b7d5..f58a787f3 100644
--- a/cdisc_rules_engine/utilities/dataset_preprocessor.py
+++ b/cdisc_rules_engine/utilities/dataset_preprocessor.py
@@ -326,7 +326,7 @@ def _merge_standard_then_filter_idvar(
         standard_keys: List[str],
     ) -> pd.DataFrame:
         results = []
-        for child_idx, child_row in child_records.iterrows():
+        for _, child_row in child_records.iterrows():
             idvar = child_row.get("IDVAR")
             idvarval = child_row.get("IDVARVAL")
             parent_candidates = self._filter_parents_by_standard_keys(
@@ -463,7 +463,7 @@ def _merge_idvar_only(
         right_domain: str,
     ) -> pd.DataFrame:
         results = []
-        for child_idx, child_row in child_records.iterrows():
+        for _, child_row in child_records.iterrows():
             idvar = child_row.get("IDVAR")
             idvarval = child_row.get("IDVARVAL")
             parent_match = None
diff --git a/cdisc_rules_engine/utilities/decorators.py b/cdisc_rules_engine/utilities/decorators.py
index 01c12dcf6..7fcd05fcc 100644
--- a/cdisc_rules_engine/utilities/decorators.py
+++ b/cdisc_rules_engine/utilities/decorators.py
@@ -1,41 +1,5 @@
 from functools import wraps
-from typing import Callable, List
-
-from requests import Response
-
-from cdisc_rules_engine.exceptions.custom_exceptions import NumberOfAttemptsExceeded
-
-
-def retry_request(retries: int, status_code_ranges: List[int] = None):
-    """
-    Decorator used to retry a request if
-    any desired status was returned.
-    Wrapped function has to return requests.Response object.
-    """
-    if status_code_ranges is None:
-        status_code_ranges = [500]
-
-    def decorator(func: Callable):
-        @wraps(func)
-        def inner(*args, **kwargs):
-            for retry in range(retries):
-                response: Response = func(*args, **kwargs)
-                request_should_be_retried: bool = any(
-                    response.status_code >= code_range
-                    for code_range in status_code_ranges
-                )
-                # no need for else.
-                # If should be retied -> loop will go to the next iteration
-                if not request_should_be_retried:
-                    return response
-            raise NumberOfAttemptsExceeded(
-                f"Cannot perform request after {retries} retries. "
-                f"Function - {func.__name__}. Args - {args}. Kwargs - {kwargs}."
-            )
-
-        return inner
-
-    return decorator
+from typing import Callable
 
 
 def cached(cache_key: str):  # noqa: C901
diff --git a/cdisc_rules_engine/utilities/rule_processor.py b/cdisc_rules_engine/utilities/rule_processor.py
index de9908ce0..a6b53b773 100644
--- a/cdisc_rules_engine/utilities/rule_processor.py
+++ b/cdisc_rules_engine/utilities/rule_processor.py
@@ -1,7 +1,6 @@
 import re
-import copy
 
-from typing import List, Optional, Union, Tuple
+from typing import List, Optional, Tuple
 from cdisc_rules_engine.enums.rule_types import RuleTypes
 from cdisc_rules_engine.interfaces.cache_service_interface import (
     CacheServiceInterface,
@@ -28,7 +27,6 @@
 from cdisc_rules_engine.constants.use_cases import USE_CASE_DOMAINS
 from cdisc_rules_engine.interfaces import ConditionInterface
 from cdisc_rules_engine.models.operation_params import OperationParams
-from cdisc_rules_engine.models.rule_conditions import AllowedConditionsKeys
 from cdisc_rules_engine.exceptions.custom_exceptions import (
     DomainNotFoundError,
     OperationError,
@@ -550,56 +548,6 @@ def is_relationship_dataset(self, dataset_name: str) -> bool:
         )
         return result
 
-    def add_operator_to_rule_conditions(
-        self, rule: dict, target_to_operator_map: dict, domain: str
-    ):
-        """
-        Adds "operator" key to rule condition.
-        target_to_operator_map parameter is a dict
-        where keys are targets and values are operators.
-
-        The rule is passed and changed by reference.
-        """
-        conditions: ConditionInterface = rule["conditions"]
-        for condition in conditions.values():
-            target: str = (
-                condition.get("value", {}).get("target", "").replace("--", domain)
-            )
-            operator_to_add: Optional[Union[str, list]] = target_to_operator_map.get(
-                target
-            )
-            if not operator_to_add:
-                continue
-            if isinstance(operator_to_add, str):
-                condition["operator"] = operator_to_add
-            elif isinstance(operator_to_add, list):
-                nested_conditions = [
-                    {**condition, "operator": operator} for operator in operator_to_add
-                ]
-                condition.clear()  # delete all keys from dict
-                condition[AllowedConditionsKeys.ANY.value] = nested_conditions
-
-    def _preprocess_operation_params(
-        self, operation_params: OperationParams, domain_details: dict = None
-    ) -> OperationParams:
-        # uses shallow copy to not overwrite for subsequent
-        # operations and avoids costly deepcopy of dataframe
-        params_copy = copy.copy(operation_params)
-        current_domain = params_copy.domain
-        if domain_details.is_supp:
-            current_domain = domain_details.rdomain
-        for param_name in vars(params_copy):
-            if param_name in ("dataframe"):
-                continue
-            param_value = getattr(params_copy, param_name)
-            updated_value = self._replace_wildcards_in_value(
-                param_value, current_domain
-            )
-            if updated_value is not param_value:
-                updated_value = copy.deepcopy(updated_value)
-                setattr(params_copy, param_name, updated_value)
-        return params_copy
-
     def _replace_wildcards_in_value(self, value, domain: str):
         if value is None:
             return value
diff --git a/cdisc_rules_engine/utilities/sdtm_utilities.py b/cdisc_rules_engine/utilities/sdtm_utilities.py
index 0e464490e..5cd08c286 100644
--- a/cdisc_rules_engine/utilities/sdtm_utilities.py
+++ b/cdisc_rules_engine/utilities/sdtm_utilities.py
@@ -1,11 +1,3 @@
-import re
-
-from cdisc_rules_engine.constants.domains import (
-    AP_DOMAIN,
-    APFA_DOMAIN,
-    APRELSUB_DOMAIN,
-    SUPPLEMENTARY_DOMAINS,
-)
 from cdisc_rules_engine.constants.metadata_columns import (
     SOURCE_DATASET_NAME,
     SOURCE_ROW_NUMBER,
@@ -96,13 +88,6 @@ def convert_library_class_name_to_ct_class(class_name: str):
     return conversions.get(class_name.lower(), class_name.upper())
 
 
-def get_tabulation_model_type_and_version(model_link: dict) -> Tuple:
-    link = model_link.get("href")
-    model_type = "sdtm"
-    model_version = link.split("/")[-1]
-    return model_type, model_version
-
-
 def get_variables_metadata_from_standard(  # noqa
     library_metadata,
     data_service,
@@ -518,27 +503,6 @@ def add_variable_wildcards(
     }
 
 
-def is_supp_domain(dataset_domain: str) -> bool:
-    """
-    Returns true if domain name starts with SUPP or SQ
-    """
-    return dataset_domain.startswith(SUPPLEMENTARY_DOMAINS)
-
-
-def is_ap_domain(dataset_domain: str) -> bool:
-    """
-    Returns true if domain name is like AP-- / APFA APRELSUB.
-    """
-    if dataset_domain == APRELSUB_DOMAIN:
-        return True
-    if len(dataset_domain) == 6:
-        domain_to_check: str = APFA_DOMAIN
-    else:
-        domain_to_check: str = AP_DOMAIN
-    regex = r"^" + re.escape(domain_to_check) + "[a-zA-Z]{2,4}$"
-    return bool(re.match(regex, dataset_domain))
-
-
 def get_corresponding_datasets(
     datasets: Iterable[SDTMDatasetMetadata], dataset_metadata: SDTMDatasetMetadata
 ) -> List[SDTMDatasetMetadata]:
diff --git a/cdisc_rules_engine/utilities/utils.py b/cdisc_rules_engine/utilities/utils.py
index 7ab88b900..02a69a1fe 100644
--- a/cdisc_rules_engine/utilities/utils.py
+++ b/cdisc_rules_engine/utilities/utils.py
@@ -13,7 +13,6 @@
 from dataclasses import fields
 from datetime import datetime
 from typing import Callable, List, Optional, Union
-from uuid import UUID
 
 from cdisc_rules_engine.enums.execution_status import ExecutionStatus
 from cdisc_rules_engine.interfaces import ConditionInterface
@@ -103,19 +102,6 @@ def get_standard_codelist_cache_key(standard: str, version: str) -> str:
     return f"{standard.lower()}-{version.replace('.', '-')}-codelists"
 
 
-def is_valid_iso_date(date_to_validate: str) -> bool:
-    """
-    Validates a given date against an ISO Format.
-    Valid date example: 2022-02-04T15:29:20.173854
-    """
-    is_valid = True
-    try:
-        datetime.fromisoformat(date_to_validate)
-    except ValueError:
-        is_valid = False
-    return is_valid
-
-
 DATASET_CACHE_KEY_TEMPLATE: str = "{dataset_path}_{dataset_type}"
 
 
@@ -230,29 +216,6 @@ def serialize_rule(rule: dict) -> dict:
     return serialized_rule
 
 
-def get_cache_last_updated_key() -> str:
-    return "CACHE_LAST_UPDATED"
-
-
-def remove_none_keys_from_dict(dict_to_remove: dict):
-    """
-    Removes dict keys whose value is None.
-    Changes the dict by reference.
-    """
-    # dict can't change its size during iteration
-    dict_copy: dict = copy.deepcopy(dict_to_remove)
-    for key, value in dict_copy.items():
-        if value is None:
-            dict_to_remove.pop(key)
-
-
-def list_contains_duplicates(list_to_check: list) -> bool:
-    """
-    Checks if a list contains duplicated items.
-    """
-    return bool(len(list_to_check) > len(set(list_to_check)))
-
-
 def generate_report_filename(generation_time: str) -> str:
     timestamp = (
         datetime.fromisoformat(generation_time)
@@ -310,17 +273,6 @@ def search_in_list[
         return list_of_dicts[index]
 
 
-def is_valid_uuid(string_to_validate: str) -> bool:
-    """
-    Checks if a given string is a valid UUID.
-    """
-    try:
-        UUID(string_to_validate)
-    except ValueError:
-        return False
-    return True
-
-
 def get_dictionary_path(directory_path: str, file_name: str) -> str:
     """
     Creates a path to dictionary directory or file.
diff --git a/cdisc_rules_engine/utilities/validation_output_container.py b/cdisc_rules_engine/utilities/validation_output_container.py
deleted file mode 100644
index 224278712..000000000
--- a/cdisc_rules_engine/utilities/validation_output_container.py
+++ /dev/null
@@ -1,14 +0,0 @@
-class ValidationOutputContainer:
-    def __init__(self):
-        self.validation_output = {}
-
-    def add_output(self, validation_id, message):
-        if validation_id in self.validation_output:
-            self.validation_output[validation_id] = self.validation_output[
-                validation_id
-            ] + [message]
-        else:
-            self.validation_output[validation_id] = [message]
-
-    def get_validation_output(self, validation_id):
-        return self.validation_output.get(validation_id, [])
diff --git a/core.py b/core.py
index 299bd2759..98f0a5a70 100644
--- a/core.py
+++ b/core.py
@@ -48,7 +48,7 @@
 )
 
 
-def validate_encoding(ctx, param, value):
+def validate_encoding(_ctx, _param, value):
     if value is None:
         return DEFAULT_ENCODING
     try:
@@ -275,7 +275,7 @@ def _validate_no_arguments(logger) -> None:
     logger.error("You must pass one of the following arguments: --dataset-path, --data")
 
 
-def load_custom_dotenv(ctx, param, value):
+def load_custom_dotenv(_ctx, _param, value):
     if not value:
         return value
     if os.path.exists(value):
@@ -283,7 +283,7 @@ def load_custom_dotenv(ctx, param, value):
     return value
 
 
-def load_custom_dotenv_from_data_options(ctx, param, value):
+def load_custom_dotenv_from_data_options(_ctx, _param, value):
     if not value:
         return value
     if isinstance(value, str):
diff --git a/resources/schema/rule-merged/Operations.json b/resources/schema/rule-merged/Operations.json
index ed7cce0f9..a7307fd5a 100644
--- a/resources/schema/rule-merged/Operations.json
+++ b/resources/schema/rule-merged/Operations.json
@@ -147,7 +147,7 @@
       "properties": {
         "operator": {
           "const": "get_library_class_domains",
-          "markdownDescription": "\nReturns the list of domain for a given class from the CDISC Library Implementation Guide. This operation retrieves all domains that belong to a specified class (e.g., \"TRIAL DESIGN\", \"FINDINGS\", \"EVENTS\") based on the current standard and version. The operation uses the standard and version from the validation context as well as the optional `domain_class` parameter which is the name of the class to filter by (e.g., \"TRIAL DESIGN\", \"FINDINGS\", \"EVENTS\", \"INTERVENTIONS). NOTE: Class names are case-sensitive and should match the Library metadata format. If no `domain_class` parameter is provided, the operation returns all domains across all classes in the Implementation Guide:\n\n```yaml\n- operator: get_library_class_domains\n  id: $trial_design_domains\n  domain_class: \"TRIAL DESIGN\"\n```\n"
+          "markdownDescription": "\nReturns the list of domains for a given class from the CDISC Library Implementation Guide. This operation retrieves all domains that belong to a specified class (e.g., \"TRIAL DESIGN\", \"FINDINGS\", \"EVENTS\") based on the current standard and version. The operation uses the standard and version from the validation context as well as the optional `domain_class` parameter which is the name of the class to filter by (e.g., \"TRIAL DESIGN\", \"FINDINGS\", \"EVENTS\", \"INTERVENTIONS). NOTE: Class names are case-sensitive and should match the Library metadata format. If no `domain_class` parameter is provided, the operation returns all domains across all classes in the Implementation Guide:\n\n```yaml\n- operator: get_library_class_domains\n  id: $trial_design_domains\n  domain_class: \"TRIAL DESIGN\"\n```\n"
         }
       },
       "required": ["id", "operator"],
diff --git a/resources/schema/rule/Operations.md b/resources/schema/rule/Operations.md
index 4063cd73f..3cbdb837b 100644
--- a/resources/schema/rule/Operations.md
+++ b/resources/schema/rule/Operations.md
@@ -894,7 +894,7 @@ Output
 
 ### get_library_class_domains
 
-Returns the list of domain for a given class from the CDISC Library Implementation Guide. This operation retrieves all domains that belong to a specified class (e.g., "TRIAL DESIGN", "FINDINGS", "EVENTS") based on the current standard and version. The operation uses the standard and version from the validation context as well as the optional `domain_class` parameter which is the name of the class to filter by (e.g., "TRIAL DESIGN", "FINDINGS", "EVENTS", "INTERVENTIONS). NOTE: Class names are case-sensitive and should match the Library metadata format. If no `domain_class` parameter is provided, the operation returns all domains across all classes in the Implementation Guide:
+Returns the list of domains for a given class from the CDISC Library Implementation Guide. This operation retrieves all domains that belong to a specified class (e.g., "TRIAL DESIGN", "FINDINGS", "EVENTS") based on the current standard and version. The operation uses the standard and version from the validation context as well as the optional `domain_class` parameter which is the name of the class to filter by (e.g., "TRIAL DESIGN", "FINDINGS", "EVENTS", "INTERVENTIONS). NOTE: Class names are case-sensitive and should match the Library metadata format. If no `domain_class` parameter is provided, the operation returns all domains across all classes in the Implementation Guide:
 
 ```yaml
 - operator: get_library_class_domains
diff --git a/scripts/script_utils.py b/scripts/script_utils.py
index 99d01b2d0..29d621edb 100644
--- a/scripts/script_utils.py
+++ b/scripts/script_utils.py
@@ -536,14 +536,6 @@ def load_and_parse_rule(rule_file):
         return None
 
 
-def replace_rule_keys(rule):
-    if "Operations" in rule:
-        rule["actions"] = rule.pop("Operations")
-    if "Check" in rule:
-        rule["conditions"] = rule.pop("Check")
-        return rule
-
-
 def rule_matches_standard_version(rule, standard, version, substandard=None):
     normalized_version = version.replace("-", ".")
     for standard_info in rule["standards"]:
diff --git a/tests/unit/test_decorators.py b/tests/unit/test_decorators.py
deleted file mode 100644
index 3f41cbc41..000000000
--- a/tests/unit/test_decorators.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import pytest
-from requests import Response
-
-from cdisc_rules_engine.exceptions.custom_exceptions import NumberOfAttemptsExceeded
-from cdisc_rules_engine.utilities.decorators import retry_request
-
-
-def test_retry_request_decorator():
-    """
-    Unit test for retry_request.
-    Testing the case when a wrapped function
-    returned a response that should not be retried.
-    """
-    response_to_return = Response()
-    response_to_return.status_code = 200
-
-    @retry_request(
-        5,
-        [
-            500,
-        ],
-    )
-    def wrapped_func():
-        return response_to_return
-
-    response = wrapped_func()
-    assert response == response_to_return
-
-
-def test_retry_request_decorator_attempts_exceeded():
-    """
-    Unit test for retry_request.
-    Testing the case when a wrapped function
-    returned a response that should be retried
-    and the number of attempts exceeded.
-    """
-
-    @retry_request(
-        5,
-        [
-            500,
-        ],
-    )
-    def wrapped_func():
-        response = Response()
-        response.status_code = 500
-        return response
-
-    with pytest.raises(NumberOfAttemptsExceeded):
-        wrapped_func()
diff --git a/tests/unit/test_merge_supp_datasets.py b/tests/unit/test_merge_supp_datasets.py
index 3c5c72df6..6fbb02166 100644
--- a/tests/unit/test_merge_supp_datasets.py
+++ b/tests/unit/test_merge_supp_datasets.py
@@ -80,11 +80,8 @@ def test_data_processor_suppae_multiple_qnams():
     assert result.loc[0, "AEREL2"] == "POSSIBLE"
 
 
-@patch.object(LocalDataService, "check_filepath", return_value=False)
 @patch.object(LocalDataService, "_async_get_datasets")
-def test_merge_pivot_supp_dataset(
-    mock_async_get_datasets, mock_check_filepath, data_service
-):
+def test_merge_pivot_supp_dataset(mock_async_get_datasets, data_service):
     # Setup example datasets
     parent_dataset = PandasDataset(
         pd.DataFrame(
@@ -150,7 +147,6 @@ def dummy_func(dataset_name, **kwargs):
     " length of the merged dataset should match the parent dataset."
 
 
-@patch.object(LocalDataService, "check_filepath", return_value=False)
 @patch.object(LocalDataService, "_async_get_datasets")
 @pytest.mark.parametrize(
     "a_parent, id_var_val, expected_dataset",
@@ -193,7 +189,6 @@ def dummy_func(dataset_name, **kwargs):
 )
 def test_merge_supp_str_float(
     mock_async_get_datasets,
-    mock_check_filepath,
     data_service,
     a_parent,
     id_var_val,
@@ -243,7 +238,6 @@ def test_merge_supp_str_float(
     " length of the merged dataset should match the parent dataset."
 
 
-@patch.object(LocalDataService, "check_filepath", return_value=False)
 @patch.object(LocalDataService, "_async_get_datasets")
 def test_merge_supp_dataset_multi_idvar(mock_async_get_datasets, data_service):
     parent_dataset = PandasDataset(
@@ -325,7 +319,6 @@ def test_merge_supp_dataset_multi_idvar(mock_async_get_datasets, data_service):
     ), "Merged dataset should have same number of rows as parent"
 
 
-@patch.object(LocalDataService, "check_filepath", return_value=False)
 @patch.object(LocalDataService, "_async_get_datasets")
 def test_merge_supp_dataset_multi_idvar_aggregation(
     mock_async_get_datasets, data_service
@@ -374,7 +367,6 @@ def test_merge_supp_dataset_multi_idvar_aggregation(
     assert row["ECSITE"] == "Site A", "ECSITE from ECENDY=7 should be merged"
 
 
-@patch.object(LocalDataService, "check_filepath", return_value=False)
 @patch.object(LocalDataService, "_async_get_datasets")
 def test_merge_supp_dataset_same_qnam_validation_error(
     mock_async_get_datasets, data_service
diff --git a/tests/unit/test_utilities/test_data_processor.py b/tests/unit/test_utilities/test_data_processor.py
index c6bfa6c73..71f4e4597 100644
--- a/tests/unit/test_utilities/test_data_processor.py
+++ b/tests/unit/test_utilities/test_data_processor.py
@@ -1,4 +1,3 @@
-from typing import List
 import pandas as pd
 import pytest
 from cdisc_rules_engine.utilities.data_processor import DataProcessor
@@ -6,53 +5,6 @@
 from cdisc_rules_engine.enums.join_types import JoinTypes
 
 
-def test_filter_dataset_columns_by_metadata_and_rule():
-    """
-    Unit test for DataProcessor.filter_dataset_columns_by_metadata_and_rule function.
-    """
-    columns: List[str] = ["STUDYID", "DOMAIN", "AESEV", "AESER"]
-    define_metadata: List[dict] = [
-        {
-            "define_variable_name": "AESEV",
-            "define_variable_origin_type": "Collected",
-        },
-        {
-            "define_variable_name": "AESER",
-            "define_variable_origin_type": "Collected",
-        },
-    ]
-    library_metadata: dict = {
-        "STUDYID": {
-            "core": "Exp",
-        },
-        "DOMAIN": {
-            "core": "Exp",
-        },
-        "AESEV": {
-            "core": "Perm",
-        },
-        "AESER": {
-            "core": "Perm",
-        },
-        "AESEQ": {
-            "core": "Exp",
-        },
-    }
-    rule: dict = {
-        "variable_origin_type": "Collected",
-        "variable_core_status": "Perm",
-    }
-    filtered_columns: List[str] = (
-        DataProcessor.filter_dataset_columns_by_metadata_and_rule(
-            columns, define_metadata, library_metadata, rule
-        )
-    )
-    assert filtered_columns == [
-        "AESEV",
-        "AESER",
-    ]
-
-
 @pytest.mark.parametrize(
     "join_type, expected_df",
     [
diff --git a/tests/unit/test_utilities/test_rule_processor.py b/tests/unit/test_utilities/test_rule_processor.py
index 5bf2fd400..e985bfd09 100644
--- a/tests/unit/test_utilities/test_rule_processor.py
+++ b/tests/unit/test_utilities/test_rule_processor.py
@@ -22,7 +22,6 @@
     INTERVENTIONS,
 )
 from cdisc_rules_engine.models.dataset import PandasDataset, DaskDataset
-from cdisc_rules_engine.models.operation_params import OperationParams
 
 
 @pytest.mark.parametrize(
@@ -805,62 +804,6 @@ def test_perform_rule_operation_with_null_operations(
     assert df.equals(new_data)
 
 
-def test_preprocess_operation_params_wildcard_replacement(mock_data_service):
-    processor = RuleProcessor(mock_data_service, InMemoryCacheService())
-    df = PandasDataset.from_dict({"AESEQ": [1, 2, 3]})
-    operation_params = OperationParams(
-        core_id="test_id",
-        operation_id="test_op",
-        operation_name="test_operator",
-        dataframe=df,
-        target="--SEQ",
-        original_target="--SEQ",
-        domain="AE",
-        standard="sdtmig",
-        standard_version="3-4",
-        grouping=["--SEQ", "--DTC", "USUBJID"],
-        filter={"--STAT": "COMPLETED"},
-    )
-    domain_details = SDTMDatasetMetadata(
-        filename="ae.xpt", full_path="test/ae.xpt", name="AE", label="Adverse Events"
-    )
-    result = processor._preprocess_operation_params(operation_params, domain_details)
-    assert result.target == "AESEQ"
-    assert result.original_target == "AESEQ"
-    assert result.grouping == ["AESEQ", "AEDTC", "USUBJID"]
-    assert result.filter == {"AESTAT": "COMPLETED"}
-    # Check that original params and dataframe are not modified
-    assert operation_params.target == "--SEQ"
-    assert operation_params.grouping == ["--SEQ", "--DTC", "USUBJID"]
-    assert result.dataframe is operation_params.dataframe
-
-
-def test_preprocess_operation_params_supp_domain_uses_rdomain(mock_data_service):
-    processor = RuleProcessor(mock_data_service, InMemoryCacheService())
-    df = PandasDataset.from_dict({"AESEQ": [1, 2, 3]})
-    operation_params = OperationParams(
-        core_id="test_id",
-        operation_id="test_op",
-        operation_name="test_operator",
-        dataframe=df,
-        target="--SEQ",
-        original_target="--SEQ",
-        domain=None,
-        standard="sdtmig",
-        standard_version="3-4",
-    )
-    domain_details = SDTMDatasetMetadata(
-        filename="suppae.xpt",
-        full_path="test/suppae.xpt",
-        name="SUPPAE",
-        label="Supplemental AE",
-        first_record={"RDOMAIN": "AE"},
-    )
-    result = processor._preprocess_operation_params(operation_params, domain_details)
-    assert result.target == "AESEQ"
-    assert result.original_target == "AESEQ"
-
-
 @patch(
     "cdisc_rules_engine.services.data_services.LocalDataService.get_dataset_metadata"
 )
@@ -942,71 +885,6 @@ def test_perform_extract_metadata_operation(
     assert dataset_after_operation.equals(expected_dataset)
 
 
-def test_add_operator_to_conditions(mock_data_service):
-    """
-    Unit test for add_operator_to_rule_conditions method.
-    Checks nested conditions as well.
-    """
-    conditions = {
-        "all": [
-            {"name": "get_dataset", "value": {"target": "STUDYID"}},
-            {"name": "get_dataset", "value": {"target": "DOMAIN"}},
-            {
-                "any": [
-                    {"name": "get_dataset", "value": {"target": "--SEQ"}},
-                ],
-            },
-        ]
-    }
-    rule = {"conditions": ConditionCompositeFactory.get_condition_composite(conditions)}
-    processor = RuleProcessor(mock_data_service, InMemoryCacheService())
-    target_to_operator_map: dict = {
-        "STUDYID": "equal_to",
-        "DOMAIN": [
-            "less_than",
-            "not_empty",
-        ],
-        "AESEQ": "empty",
-    }
-    processor.add_operator_to_rule_conditions(rule, target_to_operator_map, "AE")
-    assert rule["conditions"].to_dict() == {
-        "all": [
-            {
-                "name": "get_dataset",
-                "operator": "equal_to",
-                "value": {
-                    "target": "STUDYID",
-                },
-            },
-            {
-                "any": [
-                    {
-                        "name": "get_dataset",
-                        "operator": "less_than",
-                        "value": {"target": "DOMAIN"},
-                    },
-                    {
-                        "name": "get_dataset",
-                        "operator": "not_empty",
-                        "value": {"target": "DOMAIN"},
-                    },
-                ]
-            },
-            {
-                "any": [
-                    {
-                        "name": "get_dataset",
-                        "operator": "empty",
-                        "value": {
-                            "target": "--SEQ",
-                        },
-                    },
-                ],
-            },
-        ]
-    }
-
-
 def test_extract_target_names_from_rule():
     conditions = {
         "any": [