teradataml 17.20.0.6__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/common/aed_utils.py

@@ -1249,7 +1249,7 @@ class AedUtils:
 
         return self.aed_context._validate_aed_return_code(ret_code[0], node_type)
 
-    def _aed_groupby(self, nodeid, groupby_expr):
+    def _aed_groupby(self, nodeid, groupby_expr, option=None):
         """
         This wrapper function facilitates a integration with 'aed_groupby',
         a C++ function, in AED library, with Python tdml library.
@@ -1260,6 +1260,7 @@ class AedUtils:
         PARAMETERS:
             nodeid - A DAG node, a input to the select API.
             groupby_expr - Columns, to be given from the data frame.
+            option - Option, to be given from the GROUP BY Clause.
 
         EXAMPLES:
             aed_table_nodeid = AedObj._aed_table("dbname.tablename")
@@ -1284,7 +1285,10 @@ class AedUtils:
                                                   ]
 
         arg_name = ["group by"]
-        arg_value = [groupby_expr]
+        # If option is passed, add prefix of the option to the groupby_expr,
+        # else, add prefix as empty string.
+        arg_value = ["{} | {}".format(option, groupby_expr)] if option\
+            else ["{}| {}".format("", groupby_expr)]
         temp_table_name = UtilFuncs._generate_temp_table_name(prefix="groupby_", use_default_database=True, quote=False)
         output_table = [UtilFuncs._extract_table_name(temp_table_name)]
         output_schema = [UtilFuncs._extract_db_name(temp_table_name)]

teradataml/common/constants.py

@@ -64,14 +64,14 @@ class TeradataConstants(Enum):
     TERADATA_LOCAL_SCRIPT = 4
     CONTAINER = 5
     TERADATA_TEXT_FILE = 6
+    TERADATA_APPLY = 7
     TABLE_COLUMN_LIMIT = 2048
     TERADATA_JOINS = ["inner", "left", "right", "full", "cross"]
     TERADATA_JOIN_OPERATORS = ['>=', '<=', '<>', '!=', '>', '<', '=']
     # Order of operators
     # shouldn't be changed. This is the order in which join condition is tested - first, operators
     # with two characters and then the operators with single character.
-    SUPPORTED_ENGINES = {"ENGINE_ML" : {"name" : "mle", "file" : "mlengine_alias_definitions"},
-                         "ENGINE_SQL" : {"name" : "sqle", "file" : "sqlengine_alias_definitions"}}
+    SUPPORTED_ENGINES = {"ENGINE_SQL" : {"name" : "sqle", "file" : "sqlengine_alias_definitions"}}
     SUPPORTED_VANTAGE_VERSIONS = {"vantage1.0": "v1.0", "vantage1.1": "v1.1",
                                   "vantage1.3": "v1.3", "vantage2.0": "v1.1"}
     RANGE_SEPARATORS = [":"]
@@ -179,65 +179,16 @@ class FunctionArgumentMapperConstants(Enum):
 
 class ModelCatalogingConstants(Enum):
     MODEL_CATALOG_DB = "TD_ModelCataloging"
-    MODEL_ENGINE_ML = "ML Engine"
     MODEL_ENGINE_ADVSQL = "Advanced SQL Engine"
 
-    MODEL_TDML = "teradataml"
-
-    # Stored Procedure Names
-    SAVE_MODEL = "SYSLIB.SaveModel"
-    DELETE_MODEL = "SYSLIB.DeleteModel"
-    PUBLISH_MODEL = "SYSLIB.PublishModel"
-
     # ModelCataloging Direct Views
     MODELS = "ModelsV"
-    MODELS_DETAILS = "ModelDetailsV"
-    MODELS_OBJECTS = "ModelObjectsV"
-    MODELS_ATTRS = "ModelAttributesV"
-    MODELS_PERF = "ModelPerformanceV"
-    MODELS_LOC = "ModelLocationV"
 
     # ModelCataloging Derived Views
     MODELSX = "ModelsVX"
-    MODELS_DETAILSX = "ModelDetailsVX"
-    MODELS_INPUTSX = "ModelTrainingDataVX"
 
     # Columns names used for Filter
-    MODEL_NAME = "Name"
-    MODEL_ID = "ModelId"
     CREATED_BY = "CreatedBy"
-    MODEL_ACCESS = "ModelAccess"
-    MODEL_DERIVED_NAME = "ModelName"
-    MODEL_DERIVED_ALGORITHM = "ModelAlgorithm"
-    MODEL_DERIVED_PREDICTION_TYPE = "ModelPredictionType"
-    MODEL_DERIVED_BUILD_TIME = "ModelBuildTime"
-    MODEL_DERIVED_TARGET_COLUMN = "ModelTargetColumn"
-    MODEL_DERIVED_GENENG = "ModelGeneratingEngine"
-    MODEL_DERIVED_GENCLIENT = "ModelGeneratingClient"
-    MODEL_ATTR_CLIENT_NAME = "ClientSpecificAttributeName"
-    MODEL_ATTR_NAME = "AttributeName"
-    MODEL_ATTR_VALUE = "AttributeValue"
-    MODEL_ATTR_VALUEC = "AttributeValueC"
-    MODEL_CLIENT_CLASS_KEY = "__class_name__"
-    MODEL_INPUT_NROWS = "NRows"
-    MODEL_INPUT_NCOLS = "NCols"
-
-    MODEL_OBJ_NAME = "TableReferenceName"
-    MODEL_OBJ_CLIENT_NAME = "ClientSpecificTableReferenceName"
-    MODEL_OBJ_TABLE_NAME = "TableName"
-
-    MODEL_INPUT_NAME = "InputName"
-    MODEL_INPUT_CLIENT_NAME = "ClientSpecificInputName"
-    MODEL_INPUT_TABLE_NAME = "TableName"
-
-    MODEL_LIST_LIST = ['ModelName','ModelAlgorithm','ModelGeneratingEngine',
-                       'ModelGeneratingClient','CreatedBy','CreatedDate']
-
-    # Valid and default status and access
-    MODEL_VALID_STATUS = ['ACTIVE', 'RETIRED', 'CANDIDATE', 'PRODUCTION', 'IN-DEVELOPMENT']
-    DEFAULT_SAVE_STATUS = 'In-Development'
-    DEFAULT_SAVE_ACCESS = 'Private'
-    PUBLIC_ACCESS = 'Public'
 
     # Expected Prediction Types
     PREDICTION_TYPE_CLASSIFICATION = 'CLASSIFICATION'
@@ -477,12 +428,10 @@ class TableOperatorConstants(Enum):
     INDB_EXEC = "IN-DB"
     # Local execution mode.
     LOCAL_EXEC = "LOCAL"
-    # Sandbox execution mode.
-    SANDBOX_EXEC = "SANDBOX"
     # Remote user environment mode.
     REMOTE_EXEC = "REMOTE"
 
-    EXEC_MODE = [LOCAL_EXEC, SANDBOX_EXEC, INDB_EXEC, REMOTE_EXEC]
+    EXEC_MODE = [LOCAL_EXEC, INDB_EXEC, REMOTE_EXEC]
     # map_row operation.
     MAP_ROW_OP = "map_row"
     # map_partition operation.
@@ -1283,7 +1232,6 @@ class SQLFunctionConstants(Enum):
         "sign": "SIGN",
         "signum": "SIGN",
         "sqrt": "SQRT",
-        "trunc": "TRUNC",
         "width_bucket": "WIDTH_BUCKET",
         "zeroifnull": "ZEROIFNULL",
 
@@ -1310,7 +1258,6 @@ class SQLFunctionConstants(Enum):
         "nvp": "NVP",
         "oreplace": "OREPLACE",
         "otranslate": "OTRANSLATE",
-        "replace": "OREPLACE",
         "reverse": "REVERSE",
         "right": "RIGHT",
         "rpad": "RPAD",
@@ -1339,13 +1286,58 @@ class SQLFunctionConstants(Enum):
         "shiftleft": "SHIFTLEFT",
         "shiftright": "SHIFTRIGHT",
         "subbitstr": "SUBBITSTR",
-        "to_byte": "TO_BYTE",
 
         # Regular Expression Functions
         "regexp_instr": "REGEXP_INSTR",
         "regexp_replace": "REGEXP_REPLACE",
         "regexp_similar": "REGEXP_SIMILAR",
-        "regexp_substr": "REGEXP_SUBSTR"
+        "regexp_substr": "REGEXP_SUBSTR",
+        
+        # DateTime Functions
+        'week_begin': 'td_week_begin',
+        'week_start': 'td_week_begin',
+        'week_end': 'td_week_end',
+        'quarter_begin': 'td_quarter_begin',
+        'quarter_start': 'td_quarter_begin',
+        'quarter_end': 'td_quarter_end',
+        'month_begin': 'td_month_begin',
+        'month_start': 'td_month_begin',
+        'month_end': 'td_month_end',
+        'year_begin': 'td_year_begin',
+        'year_start': 'td_year_begin',
+        'year_end': 'td_year_end',
+        'last_sunday': 'td_sunday',
+        'last_monday': 'td_monday',
+        'last_tuesday': 'td_tuesday',
+        'last_wednesday': 'td_wednesday',
+        'last_thursday': 'td_thursday',
+        'last_friday': 'td_friday',
+        'last_saturday': 'td_saturday',
+        'day_of_week': 'DayNumber_Of_Week',
+        'day_of_month': 'DayNumber_Of_Month',
+        'day_of_year': 'DayNumber_Of_Year',
+        'day_of_calendar': 'DayNumber_Of_Calendar',
+        'week_of_month': 'WeekNumber_Of_Month',
+        'week_of_quarter': 'WeekNumber_Of_Quarter',
+        'week_of_year': 'WeekNumber_Of_Year',
+        'week_of_calendar': 'WeekNumber_Of_Calendar',
+        'month_of_year': 'MonthNumber_Of_Year',
+        'month_of_calendar': 'MonthNumber_Of_Calendar',
+        'month_of_quarter': 'MonthNumber_Of_Quarter',
+        'quarter_of_year': 'QuarterNumber_Of_Year',
+        'quarter_of_calendar': 'QuarterNumber_Of_Calendar',
+        'year_of_calendar': 'YearNumber_Of_Calendar',
+        'day_occurrence_of_month': 'DayOccurrence_Of_Month',
+        'year': 'year',
+        'month': 'month',
+        'hour': 'hour',
+        'minute': 'minute',
+        'second': 'second',
+        'week': 'week',
+        'next_day': 'next_day',
+        'months_between': 'months_between',
+        'add_months': 'add_months',
+        'oadd_months': 'oadd_months'
     }
 
 

teradataml/common/deprecations.py

@@ -0,0 +1,160 @@
+import warnings
+from functools import wraps
+
+
+def package_deprecation(version, replacement=None, type="class"):
+    """
+    Define a deprecation decorator.
+
+    PARAMETERS:
+        replacement:
+            Optional Argument.
+            `replacement` should refer to the new API to be used instead.
+
+        type:
+            Optional Argument.
+             Specifies the type of entity being deprecated.
+             For example,
+                class or function
+
+    EXAMPLES:
+        @package_deprecation('16.20.x.y')
+        def old_func(): ...
+        @package_deprecation('16.20.x.y', 'teradataml.analytics.mle')
+        def old_func(): ..."""
+
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            msg = "\nThe \"{}\" {} has moved to a new package in version {}."
+            if replacement:
+                msg += "\nImport from the teradataml package, or directly from the {} module." + \
+                       "\nSee the teradataml {} User Guide for more information."
+            warnings.warn(msg.format('.'.join([func.__module__, func.__name__]), type, version,
+                                     replacement + '.' + func.__name__, version),
+                          category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wraps(func)(wrapper)
+
+    return decorator
+
+
+def argument_deprecation(tdml_version, deprecated_arguments, behaviour=False, alternatives=None):
+    """
+    Decorator for deprecating of argument(s) for a function or class constructor.
+
+    PARAMETERS:
+        tdml_version:
+            Required Argument.
+            Specifies the teradataml version when the argument will be deprecated.
+            Types: str
+
+        deprecated_arguments:
+            Required Argument.
+            Specifies the name(s) of the argument(s) to be deprecated.
+            Types: str OR list of Strings (str)
+
+        behaviour:
+            Optional Argument.
+            Specifies whether behaviour of the argument is deprecated.
+            Types: bool
+
+        alternatives:
+            Optional Argument.
+            Specifies the name(s) of the argument(s) that are alternative
+            to the deprecate arguments.
+            Types: str OR list of Strings (str)
+
+
+    EXAMPLES:
+        # Example 1: Deprecate behavior of arguments "arg1" and "arg2".
+        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], True)
+        def old_func(self): ...
+
+        # Example 2: Deprecate argument completely.
+        @argument_deprecation("17.20.00.02", "old_arg")
+        def old_func(self): ...
+
+        # Example 3: Deprecate arguments completely with alternative.
+        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], False, ["new_arg"])
+        def old_func(self): ...
+
+        # Example 4: Deprecate behavior of arguments "old_arg1" and "old_arg2" and provide alternatives.
+        @argument_deprecation("17.20.00.02", ["arg1", "arg2"], True, ["alt_arg1", "alt_arg2"])
+        def old_func(self): ...
+
+    """
+
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            msg = "\nThe argument(s) \"{}\" will be deprecated in {}."
+            if behaviour:
+                msg = "\nBehaviour of the argument(s) \"{}\" will change in {}."
+            msg = msg.format(deprecated_arguments, tdml_version)
+            if alternatives is not None:
+                msg += "\nUse argument(s) \"{}\" instead.".format(alternatives)
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wraps(func)(wrapper)
+
+    return decorator
+
+
+def function_deprecation(tdml_version, behaviour=False, alternatives=None):
+    """
+    Decorator for deprecating a function.
+
+    PARAMETERS:
+        tdml_version:
+            Required Argument.
+            Specifies the teradataml version when the function will be deprecated.
+            Types: str
+
+        behaviour:
+            Optional Argument.
+            Specifies whether behaviour of the function is deprecated.
+            Default value: False
+            Types: bool
+
+
+        alternatives:
+            Optional Argument.
+            Specifies the name of the function that is alternative
+            to the deprecate function.
+            Default value: None
+            Types: str
+
+
+    EXAMPLES:
+        # Example 1: Deprecate behavior of function "old_func".
+        @function_deprecation("17.20.00.03", True)
+        def old_func(self): ...
+
+        # Example 2: Deprecate function "old_func" completely.
+        @function_deprecation("17.20.00.03")
+        def old_func(self): ...
+
+        # Example 3: Deprecate function "old_func" completely with alternative function "new_func".
+        @function_deprecation("17.20.00.03", False, "new_func")
+        def old_func(self): ...
+
+        # Example 4: Deprecate behavior of function "old_func".
+        @function_deprecation("17.20.00.03", True)
+        def old_func(self): ...
+    """
+
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            msg = "\nThe function \"{}\" will be deprecated in {}."
+            if behaviour:
+                msg = "\nBehaviour of the function \"{}\" will change in {}."
+            msg = msg.format(func.__name__, tdml_version)
+            if alternatives is not None:
+                msg += "\nInstead, Use following function \"{}\".".format(alternatives)
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wraps(func)(wrapper)
+
+    return decorator

teradataml/common/garbagecollector.py

@@ -34,8 +34,7 @@ class GarbageCollector():
     """
     The class has functionality to add temporary tables/views/scripts/container to
     garbage collection, so that they can be dropped when connection is disconnected/lost.
-    Writes to a output file where the database name & table/view/script names and sandbox
-    container id are persisted.
+    Writes to a output file where the database name & table/view/script names are persisted.
     """
     __garbage_persistent_file_name = getpass.getuser() + "_garbagecollect.info"
     __garbagecollector_folder_name = '.teradataml'
@@ -45,6 +44,7 @@ class GarbageCollector():
     __gc_views = []
     __gc_scripts = []
     __gc_container = []
+    __gc_apply = []
 
     @staticmethod
     def _get_temp_dir_name():
@@ -127,6 +127,8 @@ class GarbageCollector():
             GarbageCollector.__gc_views.append(object_name)
         elif object_type == TeradataConstants.CONTAINER:
             GarbageCollector.__gc_container.append(object_name)
+        elif object_type == TeradataConstants.TERADATA_APPLY:
+            GarbageCollector.__gc_apply.append(object_name)
         else:
             GarbageCollector.__gc_scripts.append(object_name)
 
@@ -158,11 +160,10 @@ class GarbageCollector():
             err_msg = "{}Failed to cleanup following views: {}\n".format(err_msg, str(GarbageCollector.__gc_views))
             raise_error = True
         if len(GarbageCollector.__gc_scripts) != 0:
-            err_msg = "{}Failed to cleanup following scripts: {}\n".format(err_msg, str(GarbageCollector.__gc_scripts))
+            err_msg = "{}Failed to cleanup following STO scripts: {}\n".format(err_msg, str(GarbageCollector.__gc_scripts))
             raise_error = True
-        if len(GarbageCollector.__gc_container) != 0:
-            err_msg = "{}Failed to cleanup sandbox container: {}\n". \
-                format(err_msg, GarbageCollector.__gc_container)
+        if len(GarbageCollector.__gc_apply) != 0:
+            err_msg = "{}Failed to cleanup following OpenAF scripts: {}\n".format(err_msg, str(GarbageCollector.__gc_apply))
             raise_error = True
         if raise_error:
             raise RuntimeError(err_msg)
@@ -179,6 +180,9 @@ class GarbageCollector():
                 Required Argument.
                 Name of the temporary table/view/script along with database name, container.
                 that needs to be garbage collected.
+                Note:
+                    If "object_type" is TeradataConstants.TERADATA_APPLY, then the format of
+                    "object_name" should be <user_env_name(str)>::<apply_script_name>.
                 Types: str
 
             object_type:
@@ -200,18 +204,7 @@ class GarbageCollector():
             try:
                 tempfilename = GarbageCollector.__make_temp_file_name()
                 writecontent = str(GarbageCollector.__version) + "," + str(os.getpid())
-                if object_type == TeradataConstants.TERADATA_TABLE:
-                    writecontent += "," + str(TeradataConstants.TERADATA_TABLE.value)
-                elif object_type == TeradataConstants.TERADATA_VIEW:
-                    writecontent += "," + str(TeradataConstants.TERADATA_VIEW.value)
-                elif object_type == TeradataConstants.TERADATA_TEXT_FILE:
-                    writecontent += "," + str(TeradataConstants.TERADATA_TEXT_FILE.value)
-                elif object_type == TeradataConstants.TERADATA_LOCAL_SCRIPT:
-                    writecontent += "," + str(TeradataConstants.TERADATA_LOCAL_SCRIPT.value)
-                elif object_type == TeradataConstants.CONTAINER:
-                    writecontent += "," + str(TeradataConstants.CONTAINER.value)
-                else:
-                    writecontent += "," + str(TeradataConstants.TERADATA_SCRIPT.value)
+                writecontent += "," + str(object_type.value)
                 writecontent += "," + object_name + "\n"
                 with open(tempfilename, 'a+') as fgc:
                     fgc.write(writecontent)
@@ -267,7 +260,7 @@ class GarbageCollector():
                 fgc.close()
 
     @staticmethod
-    def __delete_gc_tempdir_local_file(db_object, file_extension='py'):
+    def __delete_gc_tempdir_local_file(db_object, object_type=TeradataConstants.TERADATA_TABLE):
         """
         DESCRIPTION:
             Creates path to the file in temp directory on client machine
@@ -279,11 +272,11 @@ class GarbageCollector():
                 Specifies the name of the file/script to be deleted.
                 Types: str
 
-            file_extension:
+            object_type:
                 Optional Argument.
-                Specifies extension of the file.
-                Default Value: 'py'
-                Types: str
+                Specifies the type of the object (table/view/script) to be deleted.
+                Default Value: TeradataConstants.TERADATA_TABLE
+                Types: TeradataConstants
 
         RETURNS:
             None.
@@ -293,16 +286,21 @@ class GarbageCollector():
 
         EXAMPLES:
             GarbageCollector.__delete_gc_tempdir_local_file(
-                'ALICE.ml__script_executor__<uniqueID>','py')
+                'ALICE.ml__script_executor__<uniqueID>.py', TeradataConstants.TERADATA_TABLE)
         """
         try:
             tempdir = GarbageCollector._get_temp_dir_name()
             script_alias = tdmlutil.utils.UtilFuncs._teradata_unquote_arg(
                 tdmlutil.utils.UtilFuncs._extract_table_name(db_object), quote='"')
 
+            if object_type == TeradataConstants.TERADATA_APPLY.value:
+                # Apply script is stored in the format <user_env_name>::<apply_script_name>.
+                _, script_file = script_alias.split("::")
+                script_alias = script_file
+
             # Currently assumed that the file name will be '<UIF_ID>.py'.
             # That is how the scripts will be created and installed from teradataml.
-            file_name = os.path.join(tempdir, '{}.{}'.format(script_alias, file_extension))
+            file_name = os.path.join(tempdir, script_alias)
             GarbageCollector._delete_local_file(file_name)
         except Exception as e:
             raise
@@ -333,7 +331,8 @@ class GarbageCollector():
                 Specifies whether to delete the entry from one of the following:
                 * __gc_tables - list of tables created
                 * __gc_views - list of views created
-                * __gc_scripts - list of scripts installed
+                * __gc_scripts - list of STO scripts installed
+                * __gc_apply - list of OpenAF scripts installed
                 When set to True, the entry is removed from the appropriate list.
                 This argument comes in handy for the GC validation to
                 make sure that all intended tables/views/scripts are dropped by GC.
@@ -378,12 +377,12 @@ class GarbageCollector():
                                                                           object_type)
 
                         # If object is a script, also delete the local copy of the file.
-                        if object_type == TeradataConstants.TERADATA_SCRIPT:
-                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, "py")
-                        elif object_type == TeradataConstants.TERADATA_TEXT_FILE:
-                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, "txt")
-                        elif object_type == TeradataConstants.TERADATA_LOCAL_SCRIPT:
-                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, "py")
+                        if object_type in \
+                            [TeradataConstants.TERADATA_SCRIPT,
+                             TeradataConstants.TERADATA_APPLY,
+                             TeradataConstants.TERADATA_TEXT_FILE,
+                             TeradataConstants.TERADATA_LOCAL_SCRIPT]:
+                            GarbageCollector.__delete_gc_tempdir_local_file(db_object, object_type)
                 fgc.truncate()
         except Exception as e:
             raise
@@ -436,6 +435,8 @@ class GarbageCollector():
                 GarbageCollector.__gc_views.remove(object_name)
             elif TeradataConstants.CONTAINER == object_type:
                 GarbageCollector.__gc_container.remove(object_name)
+            elif TeradataConstants.TERADATA_APPLY == object_type:
+                GarbageCollector.__gc_apply.remove(object_name)
             else:
                 GarbageCollector.__gc_scripts.remove(object_name)
 
@@ -465,54 +466,6 @@ class GarbageCollector():
         except:
             pass
 
-    @staticmethod
-    def __delete_docker_sandbox_env(sandbox_env_object):
-        """
-        DESCRIPTION:
-            Function to delete the specified sandbox container.
-
-        PARAMETERS:
-            sandbox_env_object:
-                Required Argument.
-                Specifies a string containing container id or '|' separated container id and image name
-                that needs to be cleaned up.
-                Types: str
-
-        RETURNS:
-            None.
-
-        RAISES:
-            docker.errors.NotFound, docker.errors.APIError.
-
-        EXAMPLES:
-            GarbageCollector.__delete_docker_sandbox_env(sandbox_env_object = '7efjglkfl'|'stoimage1').
-            GarbageCollector.__delete_docker_sandbox_env(sandbox_env_object = '7efjglkfl').
-        """
-        import docker
-        client = docker.APIClient()
-        try:
-            # Splitting it with '|' as most often image names doesn't contain it.
-            res = sandbox_env_object.split('|')
-            # Stop and remove the container using the container id, i.e., the first element in 'res'.
-            client.stop(res[0])
-            client.remove_container(res[0])
-            if len(res) == 2:
-                # Remove the image using the using image name, i.e., the second element in 'res'.
-                client.remove_image(res[1])
-        except docker.errors.NotFound as err1:
-            raise err1
-        except docker.errors.APIError as err2:
-            raise err2
-        except Exception as err3:
-            raise err3
-        finally:
-            client.close()
-            # Reset configuration parameters "sandbox_container_id" and
-            # "_container_started_by_teradataml" after raising exceptions if any.
-            configure._container_started_by_teradataml = None
-            if configure.sandbox_container_id == res[0]:
-                configure.sandbox_container_id = None
-
     @staticmethod
     def _cleanup_garbage_collector():
         """
@@ -561,45 +514,38 @@ class GarbageCollector():
                             database_object = recordparts[3].strip()
 
                             # Create the TeradataConstant to use with __delete_object_from_gc_list().
-                            object_type_enum = TeradataConstants.TERADATA_SCRIPT
-                            if object_type == TeradataConstants.TERADATA_TABLE.value:
-                                object_type_enum = TeradataConstants.TERADATA_TABLE
-                            elif object_type == TeradataConstants.TERADATA_VIEW.value:
-                                object_type_enum = TeradataConstants.TERADATA_VIEW
-                            elif object_type == TeradataConstants.TERADATA_TEXT_FILE.value:
-                                object_type_enum = TeradataConstants.TERADATA_TEXT_FILE
-                            elif object_type == TeradataConstants.TERADATA_LOCAL_SCRIPT.value:
-                                object_type_enum = TeradataConstants.TERADATA_LOCAL_SCRIPT
-                            elif object_type == TeradataConstants.CONTAINER.value:
-                                object_type_enum = TeradataConstants.CONTAINER
+                            object_type_enum = TeradataConstants(object_type)
+
                             try:
                                 # Drop the table/view/script/container based on database object type retrieved from the collector file.
                                 # # Drop table.
                                 if TeradataConstants.TERADATA_TABLE.value == object_type:
                                     tdmlutil.utils.UtilFuncs._drop_table(database_object,
                                                                          check_table_exist=False)
+
                                 # # Drop view.
                                 elif TeradataConstants.TERADATA_VIEW.value == object_type:
                                     tdmlutil.utils.UtilFuncs._drop_view(database_object,
                                                                         check_view_exist=False)
 
-                                elif TeradataConstants.TERADATA_TEXT_FILE.value == object_type:
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, "txt")
+                                elif object_type in [TeradataConstants.TERADATA_LOCAL_SCRIPT.value,
+                                                    TeradataConstants.TERADATA_TEXT_FILE.value]:
+                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
 
-                                # Drop script executor python file generated while
-                                # running Script
-                                elif TeradataConstants.TERADATA_LOCAL_SCRIPT.value == object_type:
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, "py")
+                                # # Drop Apply script.
+                                elif TeradataConstants.TERADATA_APPLY.value == object_type:
+                                    tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                            file_type=object_type_enum)
+                                    # Delete the script locally
+                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
 
-                                # Remove sandbox container.
-                                elif TeradataConstants.CONTAINER.value == object_type:
-                                    GarbageCollector.__delete_docker_sandbox_env(database_object)
-                                # # Drop script.
+                                # # Drop STO script.
                                 else:
                                     tdmlutil.utils.UtilFuncs._delete_script(database_object,
+                                                                            file_type=object_type_enum,
                                                                             check_script_exist=False)
                                     # Delete the script locally
-                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, "py")
+                                    GarbageCollector.__delete_gc_tempdir_local_file(database_object, object_type)
 
                                 # Finally, delete the entry from gc lists if required.
                                 GarbageCollector.__delete_object_from_gc_list(database_object,
@@ -619,12 +565,23 @@ class GarbageCollector():
                                     # Delete entry from gc lists of required.
                                     GarbageCollector.__delete_object_from_gc_list(database_object,
                                                                                   object_type_enum)
+                            except (TeradataMlException, RuntimeError) as err:
+                                if "Failed to execute get_env" in str(err) or \
+                                    "Failed to execute remove_file" in str(err):
+                                    # For removing files in OpenAF environment.
+                                    GarbageCollector.__deleterow(contentrecord)
+                                    # Delete entry from gc lists of required.
+                                    GarbageCollector.__delete_object_from_gc_list(database_object,
+                                                                                  object_type_enum)
                             except FileNotFoundError:
                                 # This will occur only when the item being deleted is a file,
                                 # and it's local copy is not found.
                                 GarbageCollector.__deleterow(contentrecord)
-                                GarbageCollector.__gc_scripts.remove(database_object)
-                    except Exception:
+                                if object_type == TeradataConstants.TERADATA_APPLY:
+                                    GarbageCollector.__gc_apply.remove(database_object)
+                                elif object_type == TeradataConstants.TERADATA_SCRIPT:
+                                    GarbageCollector.__gc_scripts.remove(database_object)
+                    except Exception as err:
                         pass
                         # logger.error(Messages.get_message(MessageCodes.TDMLDF_DELETE_GARBAGE_COLLECTOR) + str(err))
         except Exception as e: