ಪೈಥಾನ್‌ನ imaplib ಬಳಸಿ ಇಮೇಲ್ ಆಟೊಮೇಷನ್‌ನಲ್ಲಿ ಪರಿಣಿತಿ ಪಡೆಯಿರಿ. ಈ ಆಳವಾದ ಮಾರ್ಗದರ್ಶಿಯು IMAP ಸರ್ವರ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸುವುದು, ಹುಡುಕುವುದು, ಇಮೇಲ್‌ಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು, ಲಗತ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗಳನ್ನು ವೃತ್ತಿಪರರಂತೆ ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ.
ಪೈಥಾನ್ IMAP ಕ್ಲೈಂಟ್: ಇಮೇಲ್ ಹಿಂಪಡೆಯುವಿಕೆ ಮತ್ತು ಮೇಲ್‌ಬಾಕ್ಸ್ ನಿರ್ವಹಣೆಗೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ
ವಿಶ್ವದಾದ್ಯಂತ ವ್ಯಾಪಾರಗಳು ಮತ್ತು ವ್ಯಕ್ತಿಗಳಿಗೆ ಇಮೇಲ್ ಡಿಜಿಟಲ್ ಸಂವಹನದ ಒಂದು ಮೂಲಾಧಾರವಾಗಿ ಉಳಿದಿದೆ. ಆದಾಗ್ಯೂ, ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಇಮೇಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಪುನರಾವರ್ತಿತ ಕೆಲಸವಾಗಬಹುದು. ಇನ್‌ವಾಯ್ಸ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದರಿಂದ ಮತ್ತು ಅಧಿಸೂಚನೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದರಿಂದ ಹಿಡಿದು ಪ್ರಮುಖ ಸಂಭಾಷಣೆಗಳನ್ನು ಆರ್ಕೈವ್ ಮಾಡುವವರೆಗೆ, ಹಸ್ತಚಾಲಿತ ಪ್ರಯತ್ನವು ಬೇಗನೆ ಅಗಾಧವಾಗಬಹುದು. ಇಲ್ಲಿಯೇ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಟೊಮೇಷನ್ ಹೊಳೆಯುತ್ತದೆ, ಮತ್ತು ಪೈಥಾನ್, ತನ್ನ ಶ್ರೀಮಂತ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯೊಂದಿಗೆ, ನಿಮ್ಮ ಇನ್‌ಬಾಕ್ಸ್‌ನ ಮೇಲೆ ಹಿಡಿತ ಸಾಧಿಸಲು ಶಕ್ತಿಯುತ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಅಂತರ್ನಿರ್ಮಿತ imaplib ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಮೊದಲಿನಿಂದ ಪೈಥಾನ್ IMAP ಕ್ಲೈಂಟ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಿಮ್ಮನ್ನು ಕರೆದೊಯ್ಯುತ್ತದೆ. ನೀವು ಇಮೇಲ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಮಾತ್ರವಲ್ಲದೆ, ಅವುಗಳ ವಿಷಯವನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು, ಲಗತ್ತುಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು, ಮತ್ತು ಸಂದೇಶಗಳನ್ನು ಓದಿದೆ ಎಂದು ಗುರುತಿಸುವ ಮೂಲಕ, ಅವುಗಳನ್ನು ಸ್ಥಳಾಂತರಿಸುವ ಮೂಲಕ ಅಥವಾ ಅಳಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಮೇಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಸಹ ಕಲಿಯುವಿರಿ. ಈ ಲೇಖನದ ಅಂತ್ಯದ ವೇಳೆಗೆ, ನಿಮ್ಮ ಅತ್ಯಂತ ಬೇಸರದ ಇಮೇಲ್ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ನಿಮ್ಮ ಸಮಯವನ್ನು ಉಳಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಉತ್ಪಾದಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ನೀವು ಸಜ್ಜಾಗುತ್ತೀರಿ.
ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: IMAP vs. POP3 vs. SMTP
ಕೋಡ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ಇಮೇಲ್ ಅನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಭೂತ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಮೂರು ಸಂಕ್ಷಿಪ್ತ ರೂಪಗಳನ್ನು ಕೇಳುತ್ತೀರಿ: SMTP, POP3, ಮತ್ತು IMAP. ಪ್ರತಿಯೊಂದೂ ಒಂದು ವಿಶಿಷ್ಟ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸುತ್ತದೆ.
- SMTP (Simple Mail Transfer Protocol): ಇದು ಇಮೇಲ್ ಕಳುಹಿಸಲು ಇರುವ ಪ್ರೋಟೋಕಾಲ್. SMTP ಅನ್ನು ನಿಮ್ಮ ಪತ್ರವನ್ನು ತೆಗೆದುಕೊಂಡು ಸ್ವೀಕರಿಸುವವರ ಮೇಲ್‌ಬಾಕ್ಸ್ ಸರ್ವರ್‌ಗೆ ತಲುಪಿಸುವ ಅಂಚೆ ಸೇವೆ ಎಂದು ಯೋಚಿಸಿ. ನಿಮ್ಮ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಇಮೇಲ್ ಕಳುಹಿಸಿದಾಗ, ಅದು SMTP ಅನ್ನು ಬಳಸುತ್ತಿದೆ.
- POP3 (Post Office Protocol 3): ಇದು ಇಮೇಲ್ ಹಿಂಪಡೆಯಲು ಇರುವ ಪ್ರೋಟೋಕಾಲ್. POP3 ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು, ಎಲ್ಲಾ ಹೊಸ ಸಂದೇಶಗಳನ್ನು ನಿಮ್ಮ ಸ್ಥಳೀಯ ಕ್ಲೈಂಟ್‌ಗೆ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು, ಮತ್ತು ನಂತರ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಅವುಗಳನ್ನು ಸರ್ವರ್‌ನಿಂದ ಅಳಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದು ಅಂಚೆ ಕಚೇರಿಗೆ ಹೋಗಿ, ನಿಮ್ಮ ಎಲ್ಲಾ ಮೇಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಿ, ಮತ್ತು ಅದನ್ನು ಮನೆಗೆ ತೆಗೆದುಕೊಂಡು ಹೋಗುವಂತಿದೆ; ಒಮ್ಮೆ ಅದು ನಿಮ್ಮ ಮನೆಯಲ್ಲಿದ್ದರೆ, ಅದು ಇನ್ನು ಮುಂದೆ ಅಂಚೆ ಕಚೇರಿಯಲ್ಲಿ ಇರುವುದಿಲ್ಲ. ಬಹು-ಸಾಧನಗಳ ಜಗತ್ತಿನಲ್ಲಿ ಅದರ ಮಿತಿಗಳಿಂದಾಗಿ ಈ ಮಾದರಿಯು ಇಂದು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ.
- IMAP (Internet Message Access Protocol): ಇದು ಇಮೇಲ್ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಇರುವ ಆಧುನಿಕ ಪ್ರೋಟೋಕಾಲ್. POP3 ಗಿಂತ ಭಿನ್ನವಾಗಿ, IMAP ಸಂದೇಶಗಳನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ ಬಿಡುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ ಸಂಪರ್ಕಿತ ಕ್ಲೈಂಟ್‌ಗಳಾದ್ಯಂತ ಸ್ಥಿತಿಯನ್ನು (ಓದಿದ್ದು, ಓದಿಲ್ಲದ್ದು, ಫ್ಲ್ಯಾಗ್ ಮಾಡಿದ್ದು, ಅಳಿಸಿದ್ದು) ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತದೆ. ನೀವು ನಿಮ್ಮ ಫೋನ್‌ನಲ್ಲಿ ಇಮೇಲ್ ಓದಿದಾಗ, ಅದು ನಿಮ್ಮ ಲ್ಯಾಪ್‌ಟಾಪ್‌ನಲ್ಲಿ ಓದಿದೆ ಎಂದು ಕಾಣಿಸುತ್ತದೆ. ಈ ಸರ್ವರ್-ಕೇಂದ್ರಿತ ಮಾದರಿಯು ಆಟೊಮೇಷನ್‌ಗೆ ಪರಿಪೂರ್ಣವಾಗಿದೆ ಏಕೆಂದರೆ ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತೊಂದು ಕ್ಲೈಂಟ್‌ನಂತೆ ಮೇಲ್‌ಬಾಕ್ಸ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು, ಮತ್ತು ಅದು ಮಾಡುವ ಬದಲಾವಣೆಗಳು ಎಲ್ಲೆಡೆ ಪ್ರತಿಫಲಿಸುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಗಾಗಿ, ನಾವು ಪ್ರತ್ಯೇಕವಾಗಿ IMAP ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ.
ಪೈಥಾನ್‌ನ imaplib ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು
ಪೈಥಾನ್‌ನ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು imaplib ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು IMAP ಸರ್ವರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಬೇಕಾದ ಎಲ್ಲಾ ಅಗತ್ಯ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುವ ಒಂದು ಮಾಡ್ಯೂಲ್. ಪ್ರಾರಂಭಿಸಲು ಯಾವುದೇ ಬಾಹ್ಯ ಪ್ಯಾಕೇಜ್‌ಗಳು ಅಗತ್ಯವಿಲ್ಲ.
ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು
- ಪೈಥಾನ್ ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿರಬೇಕು: ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಪೈಥಾನ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ (3.6 ಅಥವಾ ಹೊಸದು) ಇನ್‌ಸ್ಟಾಲ್ ಆಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- IMAP ಸಕ್ರಿಯಗೊಳಿಸಿದ ಇಮೇಲ್ ಖಾತೆ: ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಇಮೇಲ್ ಪೂರೈಕೆದಾರರು (Gmail, Outlook, Yahoo, ಇತ್ಯಾದಿ) IMAP ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತಾರೆ. ನಿಮ್ಮ ಖಾತೆಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನೀವು ಇದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕಾಗಬಹುದು.
ಭದ್ರತೆಗೆ ಮೊದಲ ಆದ್ಯತೆ: ನಿಮ್ಮ ಮುಖ್ಯ ಪಾಸ್‌ವರ್ಡ್ ಅಲ್ಲ, ಆಪ್ ಪಾಸ್‌ವರ್ಡ್‌ಗಳನ್ನು ಬಳಸಿ
ಭದ್ರತೆಗಾಗಿ ಇದು ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಹಂತವಾಗಿದೆ. ನಿಮ್ಮ ಮುಖ್ಯ ಇಮೇಲ್ ಖಾತೆಯ ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ. ನಿಮ್ಮ ಕೋಡ್ ಎಂದಾದರೂ ರಾಜಿಗೊಳಗಾದರೆ, ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಖಾತೆಯು ಅಪಾಯದಲ್ಲಿದೆ. ಎರಡು-ಅಂಶದ ದೃಢೀಕರಣ (2FA) ಬಳಸುವ ಹೆಚ್ಚಿನ ಪ್ರಮುಖ ಇಮೇಲ್ ಪೂರೈಕೆದಾರರು ನೀವು "ಆಪ್ ಪಾಸ್‌ವರ್ಡ್" ಅನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿದೆ.
ಆಪ್ ಪಾಸ್‌ವರ್ಡ್ ಒಂದು ಅನನ್ಯ, 16-ಅಂಕಿಯ ಪಾಸ್‌ಕೋಡ್ ಆಗಿದ್ದು, ಅದು ನಿಮ್ಮ ಪ್ರಾಥಮಿಕ ಪಾಸ್‌ವರ್ಡ್ ಅಥವಾ 2FA ಕೋಡ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲದೆ ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ನಿಮ್ಮ ಖಾತೆಯನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುಮತಿ ನೀಡುತ್ತದೆ. ನೀವು ಒಂದನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ನಿಮ್ಮ ಮುಖ್ಯ ಪಾಸ್‌ವರ್ಡ್‌ಗೆ ಪರಿಣಾಮ ಬೀರದಂತೆ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಹಿಂತೆಗೆದುಕೊಳ್ಳಬಹುದು.
- Gmail ಗಾಗಿ: ನಿಮ್ಮ Google ಖಾತೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳು -> ಭದ್ರತೆ -> 2-ಹಂತದ ಪರಿಶೀಲನೆ -> ಆಪ್ ಪಾಸ್‌ವರ್ಡ್‌ಗಳಿಗೆ ಹೋಗಿ.
- Outlook/Microsoft ಗಾಗಿ: ನಿಮ್ಮ Microsoft ಖಾತೆ ಭದ್ರತಾ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ -> ಸುಧಾರಿತ ಭದ್ರತಾ ಆಯ್ಕೆಗಳು -> ಆಪ್ ಪಾಸ್‌ವರ್ಡ್‌ಗಳಿಗೆ ಹೋಗಿ.
- ಇತರ ಪೂರೈಕೆದಾರರಿಗಾಗಿ: ಅವರ ದಸ್ತಾವೇಜನ್ನು "app password" ಅಥವಾ "application-specific password" ಗಾಗಿ ಹುಡುಕಿ.
ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ, ಈ ಆಪ್ ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಯಾವುದೇ ಇತರ ರುಜುವಾತಿನಂತೆ ಪರಿಗಣಿಸಿ. ಉತ್ತಮ ಅಭ್ಯಾಸವೆಂದರೆ ಅದನ್ನು ನಿಮ್ಮ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಇಡುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅಥವಾ ಸುರಕ್ಷಿತ ರಹಸ್ಯಗಳ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದು.
ಮೂಲಭೂತ ಸಂಪರ್ಕ
IMAP ಸರ್ವರ್‌ಗೆ ಸುರಕ್ಷಿತ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲು, ಲಾಗಿನ್ ಮಾಡಲು, ಮತ್ತು ನಂತರ ಆಕರ್ಷಕವಾಗಿ ಲಾಗ್ ಔಟ್ ಮಾಡಲು ನಮ್ಮ ಮೊದಲ ಕೋಡ್ ತುಣುಕನ್ನು ಬರೆಯೋಣ. ನಮ್ಮ ಸಂಪರ್ಕವು ಎನ್‌ಕ್ರಿಪ್ಟ್ ಆಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು imaplib.IMAP4_SSL ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
import imaplib
import os
# --- Credentials ---
# It's best to load these from environment variables or a config file
# For this example, we'll define them here. Replace with your details.
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.example.com" # e.g., "imap.gmail.com"
# --- Connect to the IMAP server ---
# We use a try...finally block to ensure we logout gracefully
conn = None
try:
# Connect using SSL for a secure connection
conn = imaplib.IMAP4_SSL(IMAP_SERVER)
# Login to the account
status, messages = conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
if status == 'OK':
print("Successfully logged in!")
# We will add more logic here later
else:
print(f"Login failed: {messages}")
finally:
if conn:
# Always logout and close the connection
conn.logout()
print("Logged out and connection closed.")
ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಅಡಿಪಾಯವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. try...finally ಬ್ಲಾಕ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ನಮ್ಮ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದರೂ ಸಹ, conn.logout() ಅನ್ನು ಕರೆಯಲಾಗುವುದು ಎಂದು ಅದು ಖಾತರಿಪಡಿಸುತ್ತದೆ, ಸರ್ವರ್‌ನೊಂದಿಗಿನ ಅಧಿವೇಶನವನ್ನು ಮುಚ್ಚುತ್ತದೆ.
ನಿಮ್ಮ ಮೇಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವುದು
ಒಮ್ಮೆ ಲಾಗಿನ್ ಆದ ನಂತರ, ನಿಮ್ಮ ಖಾತೆಯಲ್ಲಿರುವ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗಳೊಂದಿಗೆ (ಸಾಮಾನ್ಯವಾಗಿ ಫೋಲ್ಡರ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ನೀವು ಸಂವಹನ ನಡೆಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು.
ಎಲ್ಲಾ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು
ಯಾವ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗಳು ಲಭ್ಯವಿವೆ ಎಂಬುದನ್ನು ನೋಡಲು, ನೀವು conn.list() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು. ಔಟ್‌ಪುಟ್ ಸ್ವಲ್ಪ ಗೊಂದಲಮಯವಾಗಿರಬಹುದು, ಆದ್ದರಿಂದ ಹೆಸರುಗಳ ಸ್ವಚ್ಛ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಸ್ವಲ್ಪ ಪಾರ್ಸಿಂಗ್ ಅಗತ್ಯವಿದೆ.
# Inside the 'try' block after a successful login:
status, mailbox_list = conn.list()
if status == 'OK':
print("Available Mailboxes:")
for mailbox in mailbox_list:
# The raw mailbox entry is a byte string that needs decoding
# It's often formatted like: (\HasNoChildren) "/" "INBOX"
# We can do some basic parsing to clean it up
parts = mailbox.decode().split(' "/" ')
if len(parts) == 2:
mailbox_name = parts[1].strip('"')
print(f"- {mailbox_name}")
ಇದು ನಿಮ್ಮ ಇಮೇಲ್ ಪೂರೈಕೆದಾರರನ್ನು ಅವಲಂಬಿಸಿ 'INBOX', 'Sent', '[Gmail]/Spam', ಇತ್ಯಾದಿ ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.
ಮೇಲ್‌ಬಾಕ್ಸ್ ಆಯ್ಕೆ ಮಾಡುವುದು
ನೀವು ಇಮೇಲ್‌ಗಳನ್ನು ಹುಡುಕುವ ಅಥವಾ ಹಿಂಪಡೆಯುವ ಮೊದಲು, ನೀವು ಕೆಲಸ ಮಾಡಲು ಒಂದು ಮೇಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕು. ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಆಯ್ಕೆಯೆಂದರೆ 'INBOX'. conn.select() ವಿಧಾನವು ಮೇಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ನೀವು ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಉದ್ದೇಶಿಸದಿದ್ದರೆ (ಇಮೇಲ್‌ಗಳನ್ನು ಓದಿದೆ ಎಂದು ಗುರುತಿಸುವಂತಹ) ಅದನ್ನು ಓದಲು-ಮಾತ್ರ ಮೋಡ್‌ನಲ್ಲಿಯೂ ತೆರೆಯಬಹುದು.
# Select the 'INBOX' to work with.
# Use readonly=True if you don't want to change email flags (e.g., from UNSEEN to SEEN)
status, messages = conn.select('INBOX', readonly=False)
if status == 'OK':
total_messages = int(messages[0])
print(f"INBOX selected. Total messages: {total_messages}")
else:
print(f"Failed to select INBOX: {messages}")
ನೀವು ಮೇಲ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದಾಗ, ಸರ್ವರ್ ಅದರಲ್ಲಿರುವ ಒಟ್ಟು ಸಂದೇಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಹುಡುಕುವ ಮತ್ತು ಹಿಂಪಡೆಯುವ ಎಲ್ಲಾ ನಂತರದ ಆಜ್ಞೆಗಳು ಈ ಆಯ್ಕೆಮಾಡಿದ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗೆ ಅನ್ವಯಿಸುತ್ತವೆ.
ಇಮೇಲ್‌ಗಳನ್ನು ಹುಡುಕುವುದು ಮತ್ತು ಹಿಂಪಡೆಯುವುದು
ಇದು ಇಮೇಲ್ ಹಿಂಪಡೆಯುವಿಕೆಯ ತಿರುಳು. ಈ ಪ್ರಕ್ರಿಯೆಯು ಎರಡು ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ: ಮೊದಲನೆಯದಾಗಿ, ನಿರ್ದಿಷ್ಟ ಮಾನದಂಡಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಸಂದೇಶಗಳನ್ನು ಅವುಗಳ ಅನನ್ಯ ID ಗಳನ್ನು ಪಡೆಯಲು ಹುಡುಕುವುದು, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಆ ID ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆ ಸಂದೇಶಗಳ ವಿಷಯವನ್ನು ಹಿಂಪಡೆಯುವುದು.
search() ನ ಶಕ್ತಿ
search() ವಿಧಾನವು ನಂಬಲಾಗದಷ್ಟು ಬಹುಮುಖವಾಗಿದೆ. ಇದು ಇಮೇಲ್‌ಗಳನ್ನೇ ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ, ಬದಲಿಗೆ ನಿಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಸಂದೇಶ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗಳ (ID ಗಳು) ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ID ಗಳು ಪ್ರಸ್ತುತ ಅಧಿವೇಶನ ಮತ್ತು ಆಯ್ಕೆಮಾಡಿದ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿವೆ.
ಕೆಲವು ಸಾಮಾನ್ಯ ಹುಡುಕಾಟ ಮಾನದಂಡಗಳು ಇಲ್ಲಿವೆ:
'ALL': ಮೇಲ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂದೇಶಗಳು.'UNSEEN': ಇನ್ನೂ ಓದದ ಸಂದೇಶಗಳು.'SEEN': ಓದಿದ ಸಂದೇಶಗಳು.'FROM "sender@example.com"': ನಿರ್ದಿಷ್ಟ ಕಳುಹಿಸುವವರಿಂದ ಬಂದ ಸಂದೇಶಗಳು.'TO "recipient@example.com"': ನಿರ್ದಿಷ್ಟ ಸ್ವೀಕರಿಸುವವರಿಗೆ ಕಳುಹಿಸಿದ ಸಂದೇಶಗಳು.'SUBJECT "Your Subject Line"': ನಿರ್ದಿಷ್ಟ ವಿಷಯವನ್ನು ಹೊಂದಿರುವ ಸಂದೇಶಗಳು.'BODY "a keyword in the body"': ಬಾಡಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿರುವ ಸಂದೇಶಗಳು.'SINCE "01-Jan-2024"': ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕದಂದು ಅಥವಾ ನಂತರ ಸ್ವೀಕರಿಸಿದ ಸಂದೇಶಗಳು.'BEFORE "31-Jan-2024"': ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕದ ಮೊದಲು ಸ್ವೀಕರಿಸಿದ ಸಂದೇಶಗಳು.
ನೀವು ಮಾನದಂಡಗಳನ್ನು ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಕಳುಹಿಸುವವರಿಂದ ಬಂದ ಎಲ್ಲಾ ಓದದ ಇಮೇಲ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ವಿಷಯದೊಂದಿಗೆ ಹುಡುಕಲು, ನೀವು '(UNSEEN FROM "alerts@example.com" SUBJECT "System Alert")' ಗಾಗಿ ಹುಡುಕುತ್ತೀರಿ.
ಅದನ್ನು ಕಾರ್ಯರೂಪದಲ್ಲಿ ನೋಡೋಣ:
# Search for all unread emails in the INBOX
status, message_ids = conn.search(None, 'UNSEEN')
if status == 'OK':
# message_ids is a list of byte strings, e.g., [b'1 2 3']
# We need to split it into individual IDs
email_id_list = message_ids[0].split()
if email_id_list:
print(f"Found {len(email_id_list)} unread emails.")
else:
print("No unread emails found.")
else:
print("Search failed.")
fetch() ಮೂಲಕ ಇಮೇಲ್ ವಿಷಯವನ್ನು ಹಿಂಪಡೆಯುವುದು
ಈಗ ನೀವು ಸಂದೇಶ ID ಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ, ನೀವು ನಿಜವಾದ ಇಮೇಲ್ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು fetch() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು. ನೀವು ಇಮೇಲ್‌ನ ಯಾವ ಭಾಗಗಳನ್ನು ಬಯಸುತ್ತೀರಿ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು.
'RFC822': ಇದು ಎಲ್ಲಾ ಹೆಡರ್‌ಗಳು ಮತ್ತು ಬಾಡಿ ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಸಂಪೂರ್ಣ ಕಚ್ಚಾ ಇಮೇಲ್ ವಿಷಯವನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮತ್ತು ಸಮಗ್ರ ಆಯ್ಕೆಯಾಗಿದೆ.'BODY[]': `RFC822` ಗೆ ಸಮಾನಾರ್ಥಕ.'ENVELOPE': ದಿನಾಂಕ, ವಿಷಯ, ಇಂದ, ಗೆ, ಮತ್ತು In-Reply-To ನಂತಹ ಪ್ರಮುಖ ಹೆಡರ್ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ. ನಿಮಗೆ ಕೇವಲ ಮೆಟಾಡೇಟಾ ಅಗತ್ಯವಿದ್ದರೆ ಇದು ವೇಗವಾಗಿರುತ್ತದೆ.'BODY[HEADER]': ಕೇವಲ ಹೆಡರ್‌ಗಳನ್ನು ಮಾತ್ರ ಹಿಂಪಡೆಯುತ್ತದೆ.
ನಾವು ಕಂಡುಕೊಂಡ ಮೊದಲ ಓದದ ಇಮೇಲ್‌ನ ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ಹಿಂಪಡೆಯೋಣ:
if email_id_list:
first_email_id = email_id_list[0]
# Fetch the email data for the given ID
# 'RFC822' is a standard that specifies the format of text messages
status, msg_data = conn.fetch(first_email_id, '(RFC822)')
if status == 'OK':
for response_part in msg_data:
# The fetch command returns a tuple, where the second part is the email content
if isinstance(response_part, tuple):
raw_email = response_part[1]
# Now we have the raw email data as bytes
# The next step is to parse it
print("Successfully fetched an email.")
# We will process `raw_email` in the next section
else:
print("Fetch failed.")
email ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ ಇಮೇಲ್ ವಿಷಯವನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು
fetch() ನಿಂದ ಹಿಂತಿರುಗಿದ ಕಚ್ಚಾ ಡೇಟಾವು RFC 822 ಮಾನದಂಡದ ಪ್ರಕಾರ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲಾದ ಬೈಟ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ. ಇದು ಸುಲಭವಾಗಿ ಓದಬಲ್ಲದಲ್ಲ. ಪೈಥಾನ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ email ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಈ ಕಚ್ಚಾ ಸಂದೇಶಗಳನ್ನು ಬಳಕೆದಾರ-ಸ್ನೇಹಿ ಆಬ್ಜೆಕ್ಟ್ ರಚನೆಗೆ ಪಾರ್ಸ್ ಮಾಡಲು ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.
Message ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವುದು
ಮೊದಲ ಹಂತವೆಂದರೆ `email.message_from_bytes()` ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಚ್ಚಾ ಬೈಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು Message ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು.
import email
from email.header import decode_header
# Assuming `raw_email` contains the byte data from the fetch command
email_message = email.message_from_bytes(raw_email)
ಪ್ರಮುಖ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯುವುದು (ಹೆಡರ್‌ಗಳು)
ಒಮ್ಮೆ ನೀವು Message ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು ಅದರ ಹೆಡರ್‌ಗಳನ್ನು ನಿಘಂಟಿನಂತೆ ಪ್ರವೇಶಿಸಬಹುದು.
# Get subject, from, to, and date
subject = email_message["Subject"]
from_ = email_message["From"]
to_ = email_message["To"]
date_ = email_message["Date"]
# Email headers can contain non-ASCII characters, so we need to decode them
def decode_email_header(header):
decoded_parts = decode_header(header)
header_str = ""
for part, encoding in decoded_parts:
if isinstance(part, bytes):
# If there's an encoding, use it. Otherwise, default to utf-8.
header_str += part.decode(encoding or 'utf-8')
else:
header_str += part
return header_str
subject = decode_email_header(subject)
from_ = decode_email_header(from_)
print(f"Subject: {subject}")
print(f"From: {from_}")
decode_email_header ಎಂಬ ಸಹಾಯಕ ಕಾರ್ಯವು ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಹೆಡರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅಂತರರಾಷ್ಟ್ರೀಯ ಅಕ್ಷರ ಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಎನ್‌ಕೋಡ್ ಮಾಡಲ್ಪಡುತ್ತವೆ. ನೀವು ಅದನ್ನು ಸರಿಯಾಗಿ ಡಿಕೋಡ್ ಮಾಡದಿದ್ದರೆ email_message["Subject"] ಅನ್ನು ಪ್ರವೇಶಿಸುವುದು ಗೊಂದಲಮಯ ಅಕ್ಷರ ಅನುಕ್ರಮಗಳೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನೀಡಬಹುದು.
ಇಮೇಲ್ ಬಾಡಿಗಳು ಮತ್ತು ಲಗತ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು
ಆಧುನಿಕ ಇಮೇಲ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ "ಮಲ್ಟಿಪಾರ್ಟ್" ಆಗಿರುತ್ತವೆ, ಅಂದರೆ ಅವು ವಿಷಯದ ವಿವಿಧ ಆವೃತ್ತಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ (ಸರಳ ಪಠ್ಯ ಮತ್ತು HTML ನಂತಹ) ಮತ್ತು ಲಗತ್ತುಗಳನ್ನು ಸಹ ಒಳಗೊಂಡಿರಬಹುದು. ನಾವು ಹುಡುಕುತ್ತಿರುವುದನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಈ ಭಾಗಗಳ ಮೂಲಕ ನಡೆಯಬೇಕಾಗಿದೆ.
msg.is_multipart() ವಿಧಾನವು ಇಮೇಲ್ ಬಹು ಭಾಗಗಳನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ನಮಗೆ ಹೇಳುತ್ತದೆ, ಮತ್ತು msg.walk() ಅವುಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
def process_email_body(msg):
body = ""
attachments = []
if msg.is_multipart():
# Iterate through email parts
for part in msg.walk():
content_type = part.get_content_type()
content_disposition = str(part.get("Content-Disposition"))
try:
# Get the email body
if content_type == "text/plain" and "attachment" not in content_disposition:
payload = part.get_payload(decode=True)
charset = part.get_content_charset() or 'utf-8'
body = payload.decode(charset)
# Get attachments
elif "attachment" in content_disposition:
filename = part.get_filename()
if filename:
# Decode filename if needed
decoded_filename = decode_email_header(filename)
attachments.append({
'filename': decoded_filename,
'data': part.get_payload(decode=True)
})
except Exception as e:
print(f"Error processing part: {e}")
else:
# Not a multipart message, just get the payload
payload = msg.get_payload(decode=True)
charset = msg.get_content_charset() or 'utf-8'
body = payload.decode(charset)
return body, attachments
# Using the function with our fetched message
email_body, email_attachments = process_email_body(email_message)
print("\n--- Email Body ---")
print(email_body)
if email_attachments:
print("\n--- Attachments ---")
for att in email_attachments:
print(f"Filename: {att['filename']}")
# Example of saving an attachment
with open(att['filename'], 'wb') as f:
f.write(att['data'])
print(f"Saved attachment: {att['filename']}")
ಈ ಕಾರ್ಯವು ಪ್ರತಿ ಭಾಗದ Content-Type ಮತ್ತು Content-Disposition ಹೆಡರ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಸರಳ ಪಠ್ಯ ಬಾಡಿ ಮತ್ತು ಫೈಲ್ ಲಗತ್ತುಗಳ ನಡುವೆ ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ವ್ಯತ್ಯಾಸವನ್ನು ತೋರಿಸುತ್ತದೆ.
ಸುಧಾರಿತ ಮೇಲ್‌ಬಾಕ್ಸ್ ನಿರ್ವಹಣೆ
ಇಮೇಲ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುವುದು ಕೇವಲ ಅರ್ಧದಷ್ಟು ಯುದ್ಧ. ನಿಜವಾದ ಆಟೊಮೇಷನ್ ಸರ್ವರ್‌ನಲ್ಲಿನ ಸಂದೇಶಗಳ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದಕ್ಕಾಗಿ store() ಆಜ್ಞೆಯು ನಿಮ್ಮ ಪ್ರಾಥಮಿಕ ಸಾಧನವಾಗಿದೆ.
ಇಮೇಲ್‌ಗಳನ್ನು ಗುರುತಿಸುವುದು (ಓದಿದ್ದು, ಓದಿಲ್ಲದ್ದು, ಫ್ಲ್ಯಾಗ್ ಮಾಡಿದ್ದು)
ನೀವು ಸಂದೇಶದ ಮೇಲೆ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು, ತೆಗೆದುಹಾಕಬಹುದು ಅಥವಾ ಬದಲಾಯಿಸಬಹುದು. ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಫ್ಲ್ಯಾಗ್ \Seen, ಇದು ಓದುವ/ಓದದ ಸ್ಥಿತಿಯನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ.
- ಓದಿದೆ ಎಂದು ಗುರುತಿಸಿ:
conn.store(msg_id, '+FLAGS', '\Seen') - ಓದಿಲ್ಲ ಎಂದು ಗುರುತಿಸಿ:
conn.store(msg_id, '-FLAGS', '\Seen') - ಇಮೇಲ್‌ಗೆ ಫ್ಲ್ಯಾಗ್/ಸ್ಟಾರ್ ಮಾಡಿ:
conn.store(msg_id, '+FLAGS', '\Flagged') - ಇಮೇಲ್‌ನಿಂದ ಫ್ಲ್ಯಾಗ್ ತೆಗೆದುಹಾಕಿ:
conn.store(msg_id, '-FLAGS', '\Flagged')
ಇಮೇಲ್‌ಗಳನ್ನು ನಕಲಿಸುವುದು ಮತ್ತು ಸ್ಥಳಾಂತರಿಸುವುದು
IMAP ನಲ್ಲಿ ನೇರ "move" ಆಜ್ಞೆಯಿಲ್ಲ. ಇಮೇಲ್ ಅನ್ನು ಸ್ಥಳಾಂತರಿಸುವುದು ಎರಡು-ಹಂತದ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ:
conn.copy()ಬಳಸಿ ಸಂದೇಶವನ್ನು ಗಮ್ಯಸ್ಥಾನದ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗೆ ನಕಲಿಸಿ.\Deletedಫ್ಲ್ಯಾಗ್ ಬಳಸಿ ಮೂಲ ಸಂದೇಶವನ್ನು ಅಳಿಸುವಿಕೆಗಾಗಿ ಗುರುತಿಸಿ.
# Assuming `msg_id` is the ID of the email to move
# 1. Copy to the 'Archive' mailbox
status, _ = conn.copy(msg_id, 'Archive')
if status == 'OK':
print(f"Message {msg_id.decode()} copied to Archive.")
# 2. Mark the original for deletion
conn.store(msg_id, '+FLAGS', '\Deleted')
print(f"Message {msg_id.decode()} marked for deletion.")
ಇಮೇಲ್‌ಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ಅಳಿಸುವುದು
ಸಂದೇಶವನ್ನು \Deleted ನೊಂದಿಗೆ ಗುರುತಿಸುವುದು ಅದನ್ನು ತಕ್ಷಣವೇ ತೆಗೆದುಹಾಕುವುದಿಲ್ಲ. ಇದು ಹೆಚ್ಚಿನ ಇಮೇಲ್ ಕ್ಲೈಂಟ್‌ಗಳಲ್ಲಿ ಅದನ್ನು ವೀಕ್ಷಣೆಯಿಂದ ಮರೆಮಾಡುತ್ತದೆ. ಪ್ರಸ್ತುತ ಆಯ್ಕೆಮಾಡಿದ ಮೇಲ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಅಳಿಸುವಿಕೆಗಾಗಿ ಗುರುತಿಸಲಾದ ಎಲ್ಲಾ ಸಂದೇಶಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ತೆಗೆದುಹಾಕಲು, ನೀವು expunge() ವಿಧಾನವನ್ನು ಕರೆಯಬೇಕು.
ಎಚ್ಚರಿಕೆ: expunge() ಬದಲಾಯಿಸಲಾಗದು. ಒಮ್ಮೆ ಕರೆದರೆ, ಡೇಟಾ ಶಾಶ್ವತವಾಗಿ ಹೋಗುತ್ತದೆ.
# This will permanently delete all messages with the \Deleted flag
status, response = conn.expunge()
if status == 'OK':
print(f"{len(response)} messages expunged (permanently deleted).")
expunge() ನ ಒಂದು ನಿರ್ಣಾಯಕ ಅಡ್ಡಪರಿಣಾಮವೆಂದರೆ ಅದು ಮೇಲ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ನಂತರದ ಸಂದೇಶಗಳಿಗೆ ಸಂದೇಶ ID ಗಳನ್ನು ಮರು-ಸಂಖ್ಯೆ ಮಾಡಬಹುದು. ಈ ಕಾರಣಕ್ಕಾಗಿ, ನೀವು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಬಯಸುವ ಎಲ್ಲಾ ಸಂದೇಶಗಳನ್ನು ಗುರುತಿಸುವುದು, ನಿಮ್ಮ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು (ನಕಲಿಸುವುದು ಮತ್ತು ಅಳಿಸುವಿಕೆಗಾಗಿ ಗುರುತಿಸುವಂತಹ), ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಅಧಿವೇಶನದ ಕೊನೆಯಲ್ಲಿ ಒಮ್ಮೆ expunge() ಅನ್ನು ಕರೆಯುವುದು ಉತ್ತಮ.
ಎಲ್ಲವನ್ನೂ ಒಟ್ಟುಗೂಡಿಸುವುದು: ಒಂದು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ
ನೈಜ-ಪ್ರಪಂಚದ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಸಂಪೂರ್ಣ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸೋಣ: "invoices@mycorp.com" ನಿಂದ ಬಂದ ಓದದ ಇಮೇಲ್‌ಗಳಿಗಾಗಿ ಇನ್‌ಬಾಕ್ಸ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಿ, ಯಾವುದೇ PDF ಲಗತ್ತುಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ, ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ಇಮೇಲ್ ಅನ್ನು "Processed-Invoices" ಹೆಸರಿನ ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗೆ ಸ್ಥಳಾಂತರಿಸಿ.
import imaplib
import email
from email.header import decode_header
import os
# --- Configuration ---
EMAIL_ACCOUNT = "your_email@example.com"
APP_PASSWORD = "your_16_digit_app_password"
IMAP_SERVER = "imap.gmail.com"
TARGET_SENDER = "invoices@mycorp.com"
DESTINATION_MAILBOX = "Processed-Invoices"
DOWNLOAD_DIR = "invoices"
# Create download directory if it doesn't exist
if not os.path.isdir(DOWNLOAD_DIR):
os.mkdir(DOWNLOAD_DIR)
def decode_email_header(header):
# (Same function as defined earlier)
decoded_parts = decode_header(header)
header_str = ""
for part, encoding in decoded_parts:
if isinstance(part, bytes):
header_str += part.decode(encoding or 'utf-8')
else:
header_str += part
return header_str
conn = None
try:
# --- Connect and Login ---
conn = imaplib.IMAP4_SSL(IMAP_SERVER)
conn.login(EMAIL_ACCOUNT, APP_PASSWORD)
print("Login successful.")
# --- Select INBOX ---
conn.select('INBOX')
print("INBOX selected.")
# --- Search for emails ---
search_criteria = f'(UNSEEN FROM "{TARGET_SENDER}")'
status, message_ids = conn.search(None, search_criteria)
if status != 'OK':
raise Exception("Search failed")
email_id_list = message_ids[0].split()
if not email_id_list:
print("No new invoices found.")
else:
print(f"Found {len(email_id_list)} new invoices to process.")
# --- Process Each Email ---
for email_id in email_id_list:
print(f"\nProcessing email ID: {email_id.decode()}")
# Fetch the email
status, msg_data = conn.fetch(email_id, '(RFC822)')
if status != 'OK':
print(f"Failed to fetch email ID {email_id.decode()}")
continue
raw_email = msg_data[0][1]
email_message = email.message_from_bytes(raw_email)
subject = decode_email_header(email_message["Subject"])
print(f" Subject: {subject}")
# Look for attachments
for part in email_message.walk():
if part.get_content_maintype() == 'multipart':
continue
if part.get('Content-Disposition') is None:
continue
filename = part.get_filename()
if filename and filename.lower().endswith('.pdf'):
decoded_filename = decode_email_header(filename)
filepath = os.path.join(DOWNLOAD_DIR, decoded_filename)
# Save the attachment
with open(filepath, 'wb') as f:
f.write(part.get_payload(decode=True))
print(f" -> Downloaded attachment: {decoded_filename}")
# --- Move the processed email ---
# 1. Copy to destination mailbox
status, _ = conn.copy(email_id, DESTINATION_MAILBOX)
if status == 'OK':
# 2. Mark original for deletion
conn.store(email_id, '+FLAGS', '\Deleted')
print(f" Email moved to '{DESTINATION_MAILBOX}'.")
# --- Expunge and Clean Up ---
if email_id_list:
conn.expunge()
print("\nExpunged deleted emails.")
except Exception as e:
print(f"An error occurred: {e}")
finally:
if conn:
conn.logout()
print("Logged out.")
ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆ
ದೃಢವಾದ ಆಟೊಮೇಷನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:
- ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆ: ಲಾಗಿನ್ ವೈಫಲ್ಯಗಳು (
imaplib.IMAP4.error), ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು, ಅಥವಾ ಪಾರ್ಸಿಂಗ್ ದೋಷಗಳಂತಹ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಹಿಡಿಯಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನುtry...exceptಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಸುತ್ತಿ. - ಸಂರಚನಾ ನಿರ್ವಹಣೆ: ರುಜುವಾತುಗಳನ್ನು ಎಂದಿಗೂ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ. ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳು (
os.getenv()), ಸಂರಚನಾ ಫೈಲ್ (ಉದಾ., INI ಅಥವಾ YAML), ಅಥವಾ ಮೀಸಲಾದ ರಹಸ್ಯ ನಿರ್ವಾಹಕವನ್ನು ಬಳಸಿ. - ಲಾಗಿಂಗ್:
print()ಹೇಳಿಕೆಗಳ ಬದಲು, ಪೈಥಾನ್‌ನloggingಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿ. ಇದು ನಿಮ್ಮ ಔಟ್‌ಪುಟ್‌ನ ಶಬ್ದಾಡಂಬರವನ್ನು ನಿಯಂತ್ರಿಸಲು, ಫೈಲ್‌ಗಳಿಗೆ ಬರೆಯಲು, ಮತ್ತು ಸಮಯಮುದ್ರೆಗಳನ್ನು ಸೇರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಗಮನಿಸದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಅಮೂಲ್ಯವಾಗಿದೆ. - ದರ ಮಿತಿ: ಉತ್ತಮ ಇಂಟರ್ನೆಟ್ ಪ್ರಜೆಯಾಗಿರಿ. ಇಮೇಲ್ ಸರ್ವರ್ ಅನ್ನು ಅತಿಯಾಗಿ ಪೋಲ್ ಮಾಡಬೇಡಿ. ನೀವು ಹೊಸ ಮೇಲ್‌ಗಾಗಿ ಆಗಾಗ್ಗೆ ಪರಿಶೀಲಿಸಬೇಕಾದರೆ, ಸೆಕೆಂಡುಗಳ ಬದಲು ಹಲವಾರು ನಿಮಿಷಗಳ ಮಧ್ಯಂತರಗಳನ್ನು ಪರಿಗಣಿಸಿ.
- ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳು: ಇಮೇಲ್ ಒಂದು ಜಾಗತಿಕ ಗುಣಮಟ್ಟವಾಗಿದೆ, ಮತ್ತು ನೀವು ವಿವಿಧ ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳನ್ನು ಎದುರಿಸುತ್ತೀರಿ. ಯಾವಾಗಲೂ ಇಮೇಲ್ ಭಾಗದಿಂದ ಚಾರ್‌ಸೆಟ್ ಅನ್ನು ನಿರ್ಧರಿಸಲು ಪ್ರಯತ್ನಿಸಿ (
part.get_content_charset()) ಮತ್ತು `UnicodeDecodeError` ಅನ್ನು ತಪ್ಪಿಸಲು ಒಂದು ಫಾಲ್‌ಬ್ಯಾಕ್ ('utf-8' ನಂತಹ) ಅನ್ನು ಹೊಂದಿರಿ.
ತೀರ್ಮಾನ
ನೀವು ಈಗ ಪೈಥಾನ್‌ನ imaplib ಬಳಸಿ ಇಮೇಲ್ ಸರ್ವರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಸಂಪೂರ್ಣ ಜೀವನಚಕ್ರದ ಮೂಲಕ ಪ್ರಯಾಣಿಸಿದ್ದೀರಿ. ನಾವು ಸುರಕ್ಷಿತ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸುವುದು, ಮೇಲ್‌ಬಾಕ್ಸ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು, ಶಕ್ತಿಯುತ ಹುಡುಕಾಟಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು, ಸಂಕೀರ್ಣ ಮಲ್ಟಿಪಾರ್ಟ್ ಇಮೇಲ್‌ಗಳನ್ನು ಹಿಂಪಡೆಯುವುದು ಮತ್ತು ಪಾರ್ಸಿಂಗ್ ಮಾಡುವುದು, ಲಗತ್ತುಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು, ಮತ್ತು ಸರ್ವರ್‌ನಲ್ಲಿ ಸಂದೇಶ ಸ್ಥಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದೆ.
ಈ ಜ್ಞಾನದ ಶಕ್ತಿ ಅಗಾಧವಾಗಿದೆ. ನೀವು ಬೆಂಬಲ ಟಿಕೆಟ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವರ್ಗೀಕರಿಸಲು, ದೈನಂದಿನ ವರದಿಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು, ಸುದ್ದಿಪತ್ರಗಳನ್ನು ಆರ್ಕೈವ್ ಮಾಡಲು, ಎಚ್ಚರಿಕೆ ಇಮೇಲ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಕ್ರಿಯೆಗಳನ್ನು ಪ್ರಚೋದಿಸಲು, ಮತ್ತು ಇನ್ನೂ ಹೆಚ್ಚಿನ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಇನ್‌ಬಾಕ್ಸ್, ಒಮ್ಮೆ ಹಸ್ತಚಾಲಿತ ಶ್ರಮದ ಮೂಲವಾಗಿದ್ದು, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಕೆಲಸದ ಹರಿವುಗಳಿಗಾಗಿ ಶಕ್ತಿಯುತ, ಸ್ವಯಂಚಾಲಿತ ಡೇಟಾ ಮೂಲವಾಗಬಹುದು.
ನೀವು ಮೊದಲು ಯಾವ ಇಮೇಲ್ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುತ್ತೀರಿ? ಸಾಧ್ಯತೆಗಳು ನಿಮ್ಮ ಕಲ್ಪನೆಯಿಂದ ಮಾತ್ರ ಸೀಮಿತವಾಗಿವೆ. ಸಣ್ಣದಾಗಿ ಪ್ರಾರಂಭಿಸಿ, ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿನ ಉದಾಹರಣೆಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಿ, ಮತ್ತು ನಿಮ್ಮ ಇನ್‌ಬಾಕ್ಸ್‌ನ ಆಳದಿಂದ ನಿಮ್ಮ ಸಮಯವನ್ನು ಮರಳಿ ಪಡೆಯಿರಿ.