SIENTIAPDE-1182

Remove deprecated files and configurations

- Deleted coverage.sh, Dockerfile, docker-compose.yml, email.html, input_sample.json, and Makefile as part of the cleanup process.
- Updated README.md to reflect the removal of these components and provide a clearer overview of the project structure and functionality.
- Added module-level docstrings to orchestrator, activities, and workflows for improved documentation and clarity on system architecture.

orchestrator/activities/__init__.py

@@ -0,0 +1,12 @@
+"""
+Temporal activity implementations for the orchestrator.
+
+This package contains all Temporal activity classes that implement
+specific operations for the orchestration workflows including:
+
+- Database operations (MongoDB, PostgreSQL, Redis)
+- Email services and notification delivery
+- Temporal schedule and resource management
+- Configuration formatting and slot distribution
+- Data validation and processing
+"""

orchestrator/activities/activities.py

@@ -16,6 +16,23 @@ with workflow.unsafe.imports_passed_through():
 class Activities(  # Couchbase,
         TemporalManager, SlotManager, Formatters, MongoDB, Email,
         Postgres):
+    """
+    Central activities orchestrator for Temporal workflow operations.
+
+    This class combines multiple activity components including temporal management,
+    slot management, data formatting, MongoDB operations, email services, and
+    PostgreSQL operations. It provides a unified interface for all activity
+    operations required by the orchestration workflows.
+
+    Args:
+        temporal_config (dict[str, Any]): Temporal server configuration
+        redis_config (dict[str, Any]): Redis server configuration
+        mongodb_config (dict[str, Any]): MongoDB connection configuration
+        email_config (dict[str, Any]): Email service configuration
+        postgres_config (dict[str, Any]): PostgreSQL database configuration
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
 
     def __init__(self,
                  temporal_config: dict[str, Any],
@@ -83,7 +100,11 @@ class Activities(  # Couchbase,
 
     def shutdown(self):
         """
-        Shutdown the MongoDB connection and clean up resources.
+        Shutdown all connections and clean up resources.
+
+        This method gracefully shuts down all database connections, email
+        services, and other resources to ensure proper cleanup when the
+        application terminates.
         """
         MongoDB.shutdown(self)
         Postgres.close(self)

orchestrator/activities/couchbase.py

@@ -15,6 +15,25 @@ with workflow.unsafe.imports_passed_through():
 
 
 class Couchbase(BaseActivity):
+    """
+    Couchbase database operations activity (currently unused).
+
+    This class provides Couchbase database connectivity and query operations
+    for Temporal workflows. It handles connection management, query execution,
+    and error reporting with automatic connection lifecycle management.
+
+    Args:
+        connection_string (str): Couchbase cluster connection string
+        username (str): Couchbase authentication username
+        password (str): Couchbase authentication password
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+
+    Note:
+        This class is currently commented out in the main Activities class
+        but maintained for potential future use.
+    """
+
     def __init__(self, connection_string: str, username: str,
                  password: str, logger: Logger,
                  notification_handler: NotificationHandler):

orchestrator/activities/email.py

@@ -19,6 +19,22 @@ with workflow.unsafe.imports_passed_through():
 
 
 class Email(BaseActivity):
+    """
+    Email service activity for sending workflow notifications.
+
+    This class provides email sending capabilities including HTML email
+    generation, attachment handling, and SMTP connection management with
+    automatic reconnection for workflow notification delivery.
+
+    Args:
+        sender_email (str): Email address for sending messages
+        sender_password (str): SMTP authentication password
+        smtp_server (str): SMTP server hostname
+        smtp_port (int): SMTP server port number
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
+
     def __init__(self, sender_email: str, sender_password: str,
                  smtp_server: str, smtp_port: int,
                  logger: Logger, notification_handler: NotificationHandler):
@@ -51,10 +67,24 @@ class Email(BaseActivity):
     @activity.defn(name="build_email_html")
     async def build_email_html(self, input_data: dict[str, Any]) -> dict[str, Any]:
         """
-        Builds the email html for each receiver group.
-        input_data:
-            - receiver_groups (dict): The receiver groups.
-            - mail_type (str): The mail type.
+        Build HTML email content for configured receiver groups.
+
+        This activity generates HTML email content for each receiver group
+        based on notification data and mail type. It processes notification
+        data through the email builder to create formatted HTML messages.
+
+        Args:
+            input_data (dict[str, Any]): Activity input parameters.
+                Required fields:
+                - metadata (dict[str, Any]): Workflow execution metadata
+                - receiver_groups (dict[str, Any]): Receiver group configurations with notifications
+                - mail_type (str): Type of email (Alerts/Reports)
+
+        Returns:
+            dict[str, Any]: Updated receiver groups with generated HTML content
+
+        Raises:
+            Exception: If HTML generation fails
         """
         metadata = input_data['metadata']
         receiver_groups = input_data['receiver_groups']
@@ -147,10 +177,24 @@ class Email(BaseActivity):
     @activity.defn(name="send_email")
     async def send_email(self, input_data: dict[str, Any]) -> dict[str, Any]:
         """
-        Sends an email to the receivers of each group.
-        input_data:
-            - receiver_groups (dict): The receiver groups.
-            - mail_type (str): The mail type.
+        Send email notifications to configured receiver groups.
+
+        This activity sends HTML emails with attachments to all configured
+        receiver groups. It handles SMTP connection management, attachment
+        processing, and error reporting with automatic reconnection support.
+
+        Args:
+            input_data (dict[str, Any]): Activity input parameters.
+                Required fields:
+                - metadata (dict[str, Any]): Workflow execution metadata
+                - receiver_groups (dict[str, Any]): Receiver groups with HTML content
+                - mail_type (str): Type of email being sent (Alerts/Reports)
+
+        Returns:
+            dict[str, Any]: Updated receiver groups with sending status
+
+        Raises:
+            Exception: If email sending fails for all groups
         """
         metadata = input_data['metadata']
         receiver_groups = input_data['receiver_groups']

orchestrator/activities/formatters.py

@@ -22,6 +22,21 @@ topic_separator = "\n ========== \n"
 
 
 class Formatters(BaseActivity):
+    """
+    Schedule and slot configuration formatting activity.
+
+    This class provides formatting operations for schedules and OPC slots,
+    converting pipeline configurations into Temporal-compatible formats
+    and managing slot distribution across active ingestors for optimal
+    resource utilization.
+
+    Args:
+        scouter_namespace (str): Scouter workflow namespace
+        laborious_namespace (str): Laborious workflow namespace
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
+
     def __init__(self,
                  scouter_namespace: str,
                  laborious_namespace: str,

orchestrator/activities/mongo_db.py

@@ -41,6 +41,22 @@ def clear_mongo_id(docs: list) -> list:
 
 
 class MongoDB(BaseActivity):
+    """
+    MongoDB operations activity for Temporal workflows.
+
+    This class provides MongoDB database operations including document
+    querying, aggregation, timestamp management, and collection management
+    with TTL indexes. It handles all MongoDB interactions required by
+    the orchestration system.
+
+    Args:
+        connection_string (str): MongoDB connection string
+        database_name (str): Target database name
+        ttl_index_seconds (int): TTL index duration in seconds
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
+
     def __init__(self, connection_string: str, database_name: str, ttl_index_seconds: int,
                  logger: Logger,
                  notification_handler: NotificationHandler):
@@ -415,14 +431,25 @@ class MongoDB(BaseActivity):
     @activity.defn(name="load_latest_data")
     async def load_latest_data(self, input_data: dict[str, Any]) -> list[dict[str, Any]]:
         """
-        Loads the latest data from MongoDB.
-        input_data:
-            - metadata (dict): The metadata of the workflow.
-            - collection_name (str): The name of the collection to load data from.
-            - last_data_timestamp (str): The timestamp of the last data to load.
-            - base_data_filter (dict): The base data filter to apply to the query.
-        returns:
-            - data (list[dict]): The data loaded from MongoDB.
+        Load the latest data from MongoDB collection since a specified timestamp.
+
+        This activity retrieves data from a MongoDB collection, optionally
+        filtering by timestamp to enable incremental data processing. It
+        handles connection management and provides comprehensive error reporting.
+
+        Args:
+            input_data (dict[str, Any]): Activity input parameters.
+                Required fields:
+                - metadata (dict[str, Any]): Workflow execution metadata
+                - collection_name (str): Name of the MongoDB collection
+                - last_data_timestamp (str | None): Last processed timestamp for filtering
+                - base_data_filter (dict[str, Any]): Base query filter conditions
+
+        Returns:
+            list[dict[str, Any]]: Retrieved data, or empty list if no data found
+
+        Raises:
+            Exception: If MongoDB operation fails
         """
         metadata = input_data['metadata']
         collection_name = input_data['collection_name']

orchestrator/activities/slot_manager.py

@@ -15,6 +15,22 @@ with workflow.unsafe.imports_passed_through():
 
 
 class SlotManager(Redis):
+    """
+    Redis-based OPC slot management activity.
+
+    This class manages OPC server slots and notification processing through
+    Redis operations. It provides functionality for loading, updating, and
+    deleting OPC slots, managing active ingestors, and handling notification
+    caching with timestamp management.
+
+    Args:
+        host (str): Redis server hostname
+        port (int): Redis server port number
+        username (str): Redis authentication username
+        password (str): Redis authentication password
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
 
     def __init__(self, host: str, port: int,
                  username: str, password: str,

orchestrator/activities/temporal_manager.py

@@ -19,6 +19,22 @@ with workflow.unsafe.imports_passed_through():
 
 
 class TemporalManager(BaseActivity):
+    """
+    Temporal workflow and schedule management activity.
+
+    This class manages Temporal schedules across multiple namespaces,
+    providing operations for schedule creation, updates, deletion, and
+    normalization. It handles connections to both scouter and laborious
+    namespaces for comprehensive workflow orchestration.
+
+    Args:
+        host (str): Temporal server host address
+        scouter_namespace (str): Scouter workflow namespace
+        laborious_namespace (str): Laborious workflow namespace  
+        logger (Logger): Application logger instance
+        notification_handler (NotificationHandler): Notification management handler
+    """
+
     def __init__(self, host: str, scouter_namespace: str, laborious_namespace: str,
                  logger: Logger, notification_handler: NotificationHandler):