new changes and optimizatoins

Author: SafiullahOmar

src/dt4acc/custom_tango/device_exporter_complete.py

@@ -10,7 +10,6 @@
 from typing import Dict, List, Optional
 from tango import Database, DbDevInfo, DevFailed
 
-# Add src to path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from dt4acc.core.utils.logger import get_logger
@@ -26,7 +25,7 @@ class CompleteDeviceExporter:
 
     def __init__(self, timeout_seconds: int = 60, batch_size: int = 50):
         self.timeout_seconds = timeout_seconds
-        self.batch_size = batch_size  # Process devices in batches
+        self.batch_size = batch_size  
         self.exported_devices = []
         self.db = None
         self._init_database()
@@ -36,16 +35,14 @@ def _init_database(self):
         try:
             logger.info("🔗 Initializing database connection...")
             self.db = Database()
-            # Test connection
             servers = self.db.get_server_list()
-            logger.info(f"✅ Database connected, found {len(servers)} servers")
+            logger.info(f"Database connected, found {len(servers)} servers")
         except Exception as e:
-            logger.error(f"❌ Database connection failed: {e}")
+            logger.error(f"Database connection failed: {e}")
             raise
 
     def _format_device_name(self, name: str, device_type: str) -> str:
         """Format device name according to Tango conventions."""
-        # Clean the name and make it Tango-compatible
         clean_name = name.replace(" ", "_").replace("-", "_").upper()
         return f"{device_type}_{clean_name}"
 
@@ -80,22 +77,21 @@ def db_worker():
     def _export_devices_in_batches(self, devices: List[str], device_type: str, device_class) -> int:
         """Export devices in batches to avoid overwhelming the system."""
         if not devices:
-            logger.warning(f"⚠️ No {device_type} devices found")
+            logger.warning(f" No {device_type} devices found")
             return 0
 
-        logger.info(f"📊 Found {len(devices)} {device_type} devices")
-        logger.info(f"🔄 Exporting in batches of {self.batch_size}...")
+        logger.info(f" Found {len(devices)} {device_type} devices")
+        logger.info(f"Exporting in batches of {self.batch_size}...")
 
         exported_count = 0
         failed_count = 0
 
-        # Process devices in batches
         for i in range(0, len(devices), self.batch_size):
             batch = devices[i:i + self.batch_size]
             batch_num = (i // self.batch_size) + 1
             total_batches = (len(devices) + self.batch_size - 1) // self.batch_size
 
-            logger.info(f"📦 Processing batch {batch_num}/{total_batches} ({len(batch)} devices)...")
+            logger.info(f"Processing batch {batch_num}/{total_batches} ({len(batch)} devices)...")
 
             for device_name in batch:
                 try:
@@ -109,35 +105,30 @@ def _export_devices_in_batches(self, devices: List[str], device_type: str, devic
                     self.exported_devices.append(device_info.name)
                     exported_count += 1
 
-                    # Log progress every 10 devices
                     if exported_count % 10 == 0:
-                        logger.info(f"✅ Exported {exported_count} {device_type} devices so far...")
+                        logger.info(f" Exported {exported_count} {device_type} devices so far...")
 
                 except Exception as e:
                     failed_count += 1
-                    logger.warning(f"⚠️ Failed to export {device_type} {device_name}: {e}")
+                    logger.warning(f" Failed to export {device_type} {device_name}: {e}")
                     continue
 
-            # Small delay between batches to avoid overwhelming the system
             if i + self.batch_size < len(devices):
                 time.sleep(0.1)
 
-        logger.info(f"✅ Exported {exported_count} {device_type} devices")
+        logger.info(f"Exported {exported_count} {device_type} devices")
         if failed_count > 0:
-            logger.warning(f"⚠️ Failed to export {failed_count} {device_type} devices")
+            logger.warning(f" Failed to export {failed_count} {device_type} devices")
 
         return exported_count
 
     def export_magnet_devices(self) -> int:
         """Export ALL magnet devices with timeout protection."""
         try:
-            logger.info("🔧 Exporting ALL magnet devices...")
 
-            # Get magnet data with timeout
             def get_magnet_data():
                 from dt4acc.custom_epics.data.querries import get_magnets
                 magnets = list(get_magnets())
-                # Extract unique magnet names
                 unique_magnets = list(set(magnet.get('name', '') for magnet in magnets if magnet.get('name')))
                 return unique_magnets
 
@@ -150,15 +141,14 @@ def get_magnet_data():
             return self._export_devices_in_batches(magnets, "MagnetDevice", MagnetDevice)
 
         except Exception as e:
-            logger.error(f"❌ Magnet export failed: {e}")
+            logger.error(f"Magnet export failed: {e}")
             return 0
 
     def export_power_converter_devices(self) -> int:
         """Export ALL power converter devices with timeout protection."""
         try:
             logger.info("🔧 Exporting ALL power converter devices...")
 
-            # Get power converter data with timeout
             def get_pc_data():
                 from dt4acc.custom_epics.data.querries import get_unique_power_converters
                 return get_unique_power_converters()
@@ -172,13 +162,13 @@ def get_pc_data():
             return self._export_devices_in_batches(power_converters, "PowerConverterDevice", PowerConverterDevice)
 
         except Exception as e:
-            logger.error(f"❌ Power converter export failed: {e}")
+            logger.error(f" Power converter export failed: {e}")
             return 0
 
     def export_twiss_orbit_device(self) -> int:
         """Export TwissOrbit device."""
         try:
-            logger.info("🔧 Exporting TwissOrbit device...")
+            logger.info("Exporting TwissOrbit device...")
 
             device_info = DbDevInfo()
             device_info._class = TwissOrbitDevice.__name__
@@ -188,17 +178,17 @@ def export_twiss_orbit_device(self) -> int:
             self.db.add_device(device_info)
             self.exported_devices.append(device_info.name)
 
-            logger.info("✅ Exported TwissOrbitDevice_MAIN")
+            logger.info("Exported TwissOrbitDevice_MAIN")
             return 1
 
         except Exception as e:
-            logger.error(f"❌ TwissOrbit device export failed: {e}")
+            logger.error(f"TwissOrbit device export failed: {e}")
             return 0
 
     def export_bpm_device(self) -> int:
         """Export BPM device."""
         try:
-            logger.info("🔧 Exporting BPM device...")
+            logger.info(" Exporting BPM device...")
 
             device_info = DbDevInfo()
             device_info._class = BPMDevice.__name__
@@ -208,16 +198,16 @@ def export_bpm_device(self) -> int:
             self.db.add_device(device_info)
             self.exported_devices.append(device_info.name)
 
-            logger.info("✅ Exported BPMDevice_MAIN")
+            logger.info(" Exported BPMDevice_MAIN")
             return 1
 
         except Exception as e:
-            logger.error(f"❌ BPM device export failed: {e}")
+            logger.error(f" BPM device export failed: {e}")
             return 0
 
     def export_all_devices(self) -> Dict[str, int]:
         """Export ALL devices with comprehensive error handling."""
-        logger.info("🚀 Starting COMPLETE device export...")
+        logger.info("Starting COMPLETE device export...")
         start_time = time.time()
 
         results = {
@@ -229,20 +219,14 @@ def export_all_devices(self) -> Dict[str, int]:
         }
 
         try:
-            # Export each device type with individual error handling
-            logger.info("📦 Exporting ALL power converters...")
             results['power_converters'] = self.export_power_converter_devices()
 
-            logger.info("📦 Exporting ALL magnets...")
             results['magnets'] = self.export_magnet_devices()
 
-            logger.info("📦 Exporting TwissOrbit device...")
             results['twiss_orbit'] = self.export_twiss_orbit_device()
 
-            logger.info("📦 Exporting BPM device...")
             results['bpm'] = self.export_bpm_device()
 
-            # Calculate total
             results['total'] = sum([
                 results['power_converters'],
                 results['magnets'],
@@ -253,12 +237,10 @@ def export_all_devices(self) -> Dict[str, int]:
             end_time = time.time()
             duration = end_time - start_time
 
-            logger.info(f"✅ COMPLETE device export finished in {duration:.2f} seconds")
-            logger.info(f"📊 TOTAL DEVICES EXPORTED: {results['total']}")
+          
             return results
 
         except Exception as e:
-            logger.error(f"❌ Complete device export failed: {e}")
             return results
 
     def get_exported_devices(self) -> List[str]:

src/dt4acc/custom_tango/heartbeat_service.py

@@ -11,7 +11,6 @@
 import signal
 from datetime import datetime
 
-# Add src to path (now we're in custom_tango folder)
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
 
 from dt4acc.core.utils.logger import get_logger
@@ -33,36 +32,27 @@ def __init__(self, interval_seconds: int = 1, log_interval: int = 10):
     def initialize_view(self):
         """Initialize the view instance."""
         try:
-            print("🔧 Initializing view for heartbeat service...")
-            logger.info("🔧 Initializing view for heartbeat service...")
+            logger.info("Initializing view for heartbeat service...")
 
-            # Set environment variable for Tango view
             os.environ["server"] = "tango"
 
-            # Get the view instance
             self.view = get_view_instance()
-            print(f"✅ View initialized: {type(self.view).__name__}")
-            logger.info(f"✅ View initialized: {type(self.view).__name__}")
+            logger.info(f" View initialized: {type(self.view).__name__}")
 
-            # Test if view has heart_beat method
             if hasattr(self.view, 'heart_beat'):
-                print(f"✅ View has heart_beat method")
-                logger.info(f"✅ View has heart_beat method")
+                logger.info(f"View has heart_beat method")
                 return True
             else:
-                print(f"❌ View does not have heart_beat method")
-                logger.error(f"❌ View does not have heart_beat method")
+                logger.error(f" View does not have heart_beat method")
                 return False
 
         except Exception as e:
-            print(f"❌ Failed to initialize view: {e}")
-            logger.error(f"❌ Failed to initialize view: {e}")
+            logger.error(f"Failed to initialize view: {e}")
             return False
 
     async def heartbeat_loop(self):
         """Main heartbeat loop."""
-        print("💓 Starting heartbeat loop...")
-        logger.info("💓 Starting heartbeat loop...")
+        logger.info("Starting heartbeat loop...")
 
         self.start_time = datetime.now()
         self.iteration = 0
@@ -72,67 +62,50 @@ async def heartbeat_loop(self):
                 await asyncio.sleep(self.interval_seconds)
                 self.iteration += 1
 
-                # Call the heart_beat method to catch updates
                 await self.view.heart_beat()
 
-                # Also check for any pending updates in the view
                 if hasattr(self.view, 'monitor_updates'):
-                    # This will trigger any pending calculations
                     pass
 
-                # Log progress every N iterations
                 if self.iteration % self.log_interval == 0:
                     elapsed = datetime.now() - self.start_time
-                    print(f"💓 Heartbeat iteration {self.iteration} (elapsed: {elapsed})")
-                    logger.info(f"💓 Heartbeat iteration {self.iteration} (elapsed: {elapsed})")
+                    logger.info(f"Heartbeat iteration {self.iteration} (elapsed: {elapsed})")
 
             except asyncio.CancelledError:
-                print("💓 Heartbeat loop was cancelled")
-                logger.warning("💓 Heartbeat loop was cancelled")
+                logger.warning("Heartbeat loop was cancelled")
                 break
             except Exception as e:
-                print(f"❌ Heartbeat error at iteration {self.iteration}: {e}")
-                logger.error(f"❌ Heartbeat error at iteration {self.iteration}: {e}")
+                logger.error(f"Heartbeat error at iteration {self.iteration}: {e}")
                 # Continue running even if there's an error
                 await asyncio.sleep(self.interval_seconds)
 
-        print("💓 Heartbeat loop stopped")
-        logger.info("💓 Heartbeat loop stopped")
+        logger.info("Heartbeat loop stopped")
 
     def start(self):
         """Start the heartbeat service."""
         if self.running:
-            print("⚠️ Heartbeat service is already running")
             return False
 
-        print("🚀 Starting Heartbeat Service...")
-        logger.info("🚀 Starting Heartbeat Service...")
+        logger.info("Starting Heartbeat Service...")
 
-        # Initialize view
         if not self.initialize_view():
             print("❌ Failed to initialize view. Cannot start heartbeat.")
             return False
 
-        # Start the heartbeat loop
         self.running = True
 
         try:
-            # Create and run the event loop
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
 
-            print("💓 Heartbeat service started successfully!")
-            logger.info("💓 Heartbeat service started successfully!")
+            logger.info(" Heartbeat service started successfully!")
 
-            # Run the heartbeat loop
             loop.run_until_complete(self.heartbeat_loop())
 
         except KeyboardInterrupt:
-            print("\n⏹️ Heartbeat service interrupted by user")
-            logger.info("💓 Heartbeat service interrupted by user")
+            logger.info(" Heartbeat service interrupted by user")
         except Exception as e:
-            print(f"❌ Heartbeat service error: {e}")
-            logger.error(f"❌ Heartbeat service error: {e}")
+            logger.error(f"Heartbeat service error: {e}")
         finally:
             self.stop()
             try:
@@ -145,22 +118,18 @@ def stop(self):
         if not self.running:
             return
 
-        print("🛑 Stopping Heartbeat Service...")
-        logger.info("🛑 Stopping Heartbeat Service...")
+        logger.info(" Stopping Heartbeat Service...")
 
         self.running = False
 
         if self.start_time:
             total_time = datetime.now() - self.start_time
-            print(f"📊 Heartbeat service ran for {total_time} ({self.iteration} iterations)")
-            logger.info(f"📊 Heartbeat service ran for {total_time} ({self.iteration} iterations)")
+            logger.info(f"Heartbeat service ran for {total_time} ({self.iteration} iterations)")
 
-        print("✅ Heartbeat service stopped")
-        logger.info("✅ Heartbeat service stopped")
+        logger.info("Heartbeat service stopped")
 
 def signal_handler(signum, frame):
     """Handle interrupt signals."""
-    print(f"\n📡 Received signal {signum}. Stopping heartbeat service...")
     if heartbeat_service:
         heartbeat_service.stop()
     sys.exit(0)
@@ -169,28 +138,22 @@ def main():
     """Main entry point for heartbeat service."""
     global heartbeat_service
 
-    print("💓 Standalone Heartbeat Service")
     print("=" * 50)
     print("This service runs independently of the Tango server.")
     print("Make sure the Tango server is running before starting this service.")
     print("Press Ctrl+C to stop the service.")
     print("=" * 50)
 
-    # Register signal handlers
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
 
-    # Create heartbeat service
     heartbeat_service = HeartbeatService(interval_seconds=1, log_interval=10)
 
     try:
-        # Start the service
         heartbeat_service.start()
     except KeyboardInterrupt:
-        print("\n⏹️ Service stopped by user")
     except Exception as e:
-        print(f"❌ Service failed: {e}")
-        logger.error(f"❌ Service failed: {e}")
+        logger.error(f" Service failed: {e}")
 
 if __name__ == "__main__":
     heartbeat_service = None