addedd missing tests file

examples/digital_fingerprinting/production/morpheus/dfp/modules/dfp_modules.py

@@ -56,7 +56,7 @@ def make_dfp_training_module(module_id: str, namespace: str):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()
@@ -109,7 +109,7 @@ def make_dfp_split_users_module(module_id: str, namespace: str):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
         config = builder.get_current_module_config()
 
@@ -206,7 +206,7 @@ def make_dfp_rolling_window_module(module_id: str, namespace: str):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()
@@ -336,7 +336,7 @@ def make_dfp_preporcessing_module(module_id: str, namespace: str):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()

morpheus/modules/file_batcher_module.py

@@ -43,7 +43,7 @@ def make_file_batcher_module(module_id, namespace):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         TimestampFileObj = namedtuple("TimestampFileObj", ["timestamp", "file_object"])

morpheus/modules/file_to_df_module.py

@@ -57,7 +57,7 @@ def make_file_to_df_module(module_id, namespace):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()

morpheus/modules/mlflow_model_writer_module.py

@@ -54,7 +54,7 @@ def make_mlflow_model_writer_module(module_id, namespace):
         Namespace to virtually cluster the modules.
     """
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()

morpheus/modules/nested_module.py

@@ -17,8 +17,8 @@
 
 import srf
 
-from morpheus.utils.decorators import is_module_registered
 from morpheus.utils.decorators import register_module
+from morpheus.utils.decorators import verify_module_registration
 
 logger = logging.getLogger(f"morpheus.{__name__}")
 
@@ -38,12 +38,12 @@ def make_nested_module(module_id: str, namespace: str, ordered_modules_meta: typ
         The sequence in which the edges between the nodes are made will be determined by ordered modules meta.
     """
 
-    @is_module_registered
-    def is_module_exists(module_id=None, namespace=None):
+    @verify_module_registration
+    def verify_module_existance(module_id, namespace):
         logger.debug("Registry contains module {} with namespace {}".format(module_id, namespace))
         return True
 
-    @register_module(module_id=module_id, namespace=namespace)
+    @register_module(module_id, namespace)
     def module_init(builder: srf.Builder):
 
         config = builder.get_current_module_config()
@@ -62,7 +62,7 @@ def module_init(builder: srf.Builder):
         #                ________________________ ______
         for x, y in ordered_modules_meta:
 
-            is_module_exists(module_id=x, namespace=y)
+            verify_module_existance(x, y)
 
             curr_module = builder.load_module(x, y, module_id, config)
 

morpheus/stages/general/linear_modules_stage.py

@@ -20,7 +20,7 @@
 from morpheus.config import Config
 from morpheus.pipeline.single_port_stage import SinglePortStage
 from morpheus.pipeline.stream_pair import StreamPair
-from morpheus.utils.decorators import is_module_registered
+from morpheus.utils.decorators import verify_module_registration
 
 logger = logging.getLogger("morpheus.{}".format(__name__))
 
@@ -77,19 +77,20 @@ def accepted_types(self) -> typing.Tuple:
     def _get_cpp_module_node(self, builder: srf.Builder) -> srf.SegmentObject:
         raise NotImplementedError("No C++ node is available for this module type")
 
-    @is_module_registered
-    def _load_module(self, builder: srf.Builder, module_id: str, namespace: str, module_name: str):
+    def _build_single(self, builder: srf.Builder, input_stream: StreamPair) -> StreamPair:
 
-        module = builder.load_module(module_id, namespace, module_name, self._module_config)
+        @verify_module_registration
+        def load_module(module_id: str, namespace: str, module_name: str, builder: srf.Builder):
 
-        return module
+            module = builder.load_module(module_id, namespace, module_name, self._module_config)
+            logger.info("Module '{}' with namespace '{}' is successfully loaded.".format(module_id, namespace))
 
-    def _build_single(self, builder: srf.Builder, input_stream: StreamPair) -> StreamPair:
+            return module
 
-        module = self._load_module(builder=builder,
-                                   module_id=self._module_config["module_id"],
-                                   namespace=self._module_config["namespace"],
-                                   module_name=self._module_config["module_name"])
+        module = load_module(self._module_config["module_id"],
+                             self._module_config["namespace"],
+                             module_name=self._module_config["module_name"],
+                             builder=builder)
 
         mod_in_stream = module.input_port("input")
         mod_out_stream = module.output_port("output")

morpheus/utils/decorators.py

@@ -24,7 +24,7 @@
 registry = srf.ModuleRegistry
 
 
-def is_module_registered(func):
+def verify_module_registration(func):
     """
     Module availability in the module registry is verified by this function.
 
@@ -39,29 +39,29 @@ def is_module_registered(func):
     """
 
     @functools.wraps(func)
-    def inner_func(*args, **kwargs):
-
-        module_id = kwargs["module_id"]
-        namespace = kwargs["namespace"]
+    def inner_func(module_id, namespace, **kwargs):
 
         if module_id is None or namespace is None:
             raise TypeError("TypeError: a string-like object is required for module_id and namespace, not 'NoneType'")
 
         if not registry.contains(module_id, namespace):
-            raise Exception("Module {} doesn't exist in the namespace {}".format(module_id, namespace))
+            raise Exception("Module '{}' doesn't exist in the namespace '{}'".format(module_id, namespace))
 
-        return func(*args, **kwargs)
+        return func(module_id, namespace, **kwargs)
 
     return inner_func
 
 
-def register_module(**kwargs):
+def register_module(module_id, namespace):
     """
     Registers a module if not exists in the module registry.
 
     Parameters
     ----------
-    **kwargs : Function arguments.
+    module_id : str
+        Unique identifier for a module in the module registry.
+    namespace : str
+        Namespace to virtually cluster the modules.
 
     Returns
     -------
@@ -70,15 +70,13 @@ def register_module(**kwargs):
     """
 
     def inner_func(func):
-
-        module_id = kwargs["module_id"]
-        namespace = kwargs["namespace"]
-
         # Register a module if not exists in the registry.
         if not registry.contains(module_id, namespace):
             registry.register_module(module_id, namespace, get_srf_version_as_list(), func)
-            logger.info("Module {} was successfully registered with {} namespace.".format(module_id, namespace))
+            logger.debug("Module '{}' was successfully registered with '{}' namespace.".format(module_id, namespace))
         else:
-            logger.info("Module: {} already exists in the given namespace: {}".format(module_id, namespace))
+            logger.debug("Module: '{}' already exists in the given namespace '{}'".format(module_id, namespace))
+
+        return func
 
     return inner_func

tests/test_decorators.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from morpheus.utils.decorators import register_module
+from morpheus.utils.decorators import verify_module_registration
+
+
+def test_register_module():
+
+    @register_module("TestModule", "test_morpheus_modules")
+    def module_init():
+        return True
+
+    assert module_init()
+
+    # Attempting to register duplicate module raises an error.
+    with pytest.raises(TypeError):
+
+        @register_module(None, "test_morpheus_modules")
+        def module_init2():
+            pass
+
+        module_init2()
+
+
+def test_verify_module_registration():
+
+    @verify_module_registration
+    def verify_module_existence(module_id, namespace):
+        return True
+
+    assert verify_module_existence("TestModule", "test_morpheus_modules")
+
+    with pytest.raises(TypeError):
+        verify_module_existence(None, "test_morpheus_modules")
+
+    with pytest.raises(Exception):
+        verify_module_existence("TestModule2", "test_morpheus_modules")
+
+    with pytest.raises(Exception):
+        verify_module_existence("TestModule", "default")