SIENTIAPDE-1243: Refactor: Rename 'laborious' package to 'model_manager'

This commit renames the 'laborious' package to 'model_manager' across the entire project. This includes renaming directories, modules, references in code, configuration files, and documentation to reflect the new package name. This change improves clarity and consistency within the project.

model_manager/activities/activities.py

@@ -0,0 +1,99 @@
+from temporalio import activity, workflow
+
+with workflow.unsafe.imports_passed_through():
+    from sientia_do.temporal.activities.postgres import Postgres
+    from sientia_do.notifications.handlers import CoreNotificationHandler as NotificationHandler
+    from sientia_do.observability.logger import Logger
+    from model_manager.activities.mlflow import MLFlow
+    from model_manager.activities.gates import Gates
+    from model_manager.activities.opc import OPC
+    from typing import Any
+
+
+class Activities(Postgres, MLFlow, Gates, OPC):
+    """
+    Main activities orchestrator for the Laborious system.
+
+    This class combines functionality from multiple activity classes to provide
+    a unified interface for all workflow operations. It manages database connections,
+    MLFlow model interactions, data quality validation, and OPC server communications.
+
+    The class implements multiple inheritance to combine specialized functionality:
+    - Postgres: Database operations and data persistence
+    - MLFlow: Model inference and transformation operations
+    - Gates: Data quality validation and filtering mechanisms
+    - OPC: Real-time data export to OPC servers
+
+    Attributes:
+        postgres_config (dict): PostgreSQL connection configuration
+        mlflow_config (dict): MLFlow server configuration
+        opc_config (dict): OPC server configuration
+        logger (Logger): Logging and observability instance
+        notification_handler (NotificationHandler): Notification management instance
+    """
+
+    def __init__(self,
+                 postgres_config: dict[str, Any],
+                 mlflow_config: dict[str, Any],
+                 opc_config: dict[str, Any],
+                 logger: Logger,
+                 notification_handler: NotificationHandler):
+        """
+        Initialize the Activities orchestrator with all required configurations.
+
+        This constructor initializes all parent classes with their respective
+        configurations and sets up the foundation for all activity operations.
+
+        Args:
+            postgres_config: PostgreSQL connection configuration dictionary
+                Required keys: host, port, user, password, dbname, min_connections, max_connections
+            mlflow_config: MLFlow server configuration dictionary
+                Required keys: host, port, username, password
+            opc_config: OPC server configuration dictionary
+                Can contain multiple server configurations
+            logger: Logger instance for observability and debugging
+            notification_handler: Notification handler for alerts and monitoring
+
+        Raises:
+            Exception: If any parent class initialization fails
+        """
+        # Initialize parent classes
+        Postgres.__init__(self, host=postgres_config['host'],
+                          port=postgres_config['port'],
+                          user=postgres_config['user'],
+                          password=postgres_config['password'],
+                          dbname=postgres_config['dbname'],
+                          min_connections=postgres_config['min_connections'],
+                          max_connections=postgres_config['max_connections'],
+                          logger=logger,
+                          notification_handler=notification_handler)
+
+        MLFlow.__init__(self, mlflow_host=mlflow_config['host'],
+                        mlflow_port=mlflow_config['port'],
+                        mlflow_username=mlflow_config['username'],
+                        mlflow_password=mlflow_config['password'],
+                        logger=logger,
+                        notification_handler=notification_handler)
+
+        Gates.__init__(self, logger=logger,
+                       notification_handler=notification_handler)
+
+        OPC.__init__(self,
+                     opc_servers=opc_config,
+                     logger=logger,
+                     notification_handler=notification_handler)
+
+    async def shutdown(self):
+        """
+        Gracefully shutdown all activities and clean up resources.
+
+        This method ensures proper cleanup of all resources including:
+        - PostgreSQL connection pools
+        - OPC server connections
+        - Any other resources that need explicit cleanup
+
+        The method should be called before the application terminates to ensure
+        proper resource cleanup and prevent resource leaks.
+        """
+        Postgres.close(self)
+        await OPC.shutdown(self)