Pep8+coding rules for email_fetcher

tracim/tracim/lib/email_fetcher.py

+# -*- coding: utf-8 -*-
+
 import sys
 import time
 import imaplib
 from typing import Union
 from email.message import Message
 from email.header import Header, decode_header, make_header
-from email.utils import parseaddr,parsedate_tz,mktime_tz
+from email.utils import parseaddr, parsedate_tz, mktime_tz
 from email import message_from_bytes
 
 import requests
 from tracim.controllers.events import VALID_TOKEN_VALUE
 
 
-TRACIM_SPECIAL_KEY_HEADER="X-Tracim-Key"
+TRACIM_SPECIAL_KEY_HEADER = "X-Tracim-Key"
+
 
-def str_header(header:Header):
+def str_header(header: Header) -> str:
     return str(make_header(decode_header(header)))
 
-def decode_mail(msg:Message)-> dict:
+
+def decode_mail(msg: Message)-> dict:
     """
     Get useful header and body content and decode from Message
     :param msg:
     :return:
     """
-    mailData = {}
+    mail_data = {}
 
     try:
-        mailData['subject'] = str_header(msg['subject'])
-        mailData['msg_id'] = str_header(msg['Message-ID'])
-        mailData['from'] = parseaddr(msg['From'])[1]
+        mail_data['subject'] = str_header(msg['subject'])
+        mail_data['msg_id'] = str_header(msg['Message-ID'])
+        mail_data['from'] = parseaddr(msg['From'])[1]
         # Reply key
-        mailData['to'] = parseaddr(msg['To'])[1]
+        mail_data['to'] = parseaddr(msg['To'])[1]
 
-        mailData['references'] = parseaddr(msg['References'])[1]
+        mail_data['references'] = parseaddr(msg['References'])[1]
         if TRACIM_SPECIAL_KEY_HEADER in msg:
-            mailData[TRACIM_SPECIAL_KEY_HEADER] = str_header(msg[TRACIM_SPECIAL_KEY_HEADER])
+            mail_data[TRACIM_SPECIAL_KEY_HEADER] = str_header(msg[TRACIM_SPECIAL_KEY_HEADER])  # nopep8
         # date
         date_h = str_header(msg['Date'])
         date_tuple = parsedate_tz(date_h)
 
-        mailData['date'] = datetime.datetime.fromtimestamp(mktime_tz(date_tuple))
+        mail_data['date'] = datetime.datetime.fromtimestamp(
+            mktime_tz(date_tuple)
+        )
 
-    except Exception as e:
+    except Exception:
         # TODO: exception -> mail not correctly formatted
-        return None
-    #email.utils.mktime_tz(date_tuple))
-    #print( "Local Date:", local_date.strftime("%a, %d %b %Y %H:%M:%S"))
-    ## TODO : msg.get_body look like the best way to get body but it's a new feature now (08112017).
+        return {}
+    # TODO : msg.get_body look like the best way to get body
+    # but it's a new feature now (08112017).
     for part in msg.walk():
         if not part.get_content_type() == "text/plain":
             continue
         else:
             # TODO: check if decoding is working correctly
             charset = part.get_content_charset('iso-8859-1')
-            mailData['body']= part.get_payload(decode=True).decode(charset)
+            mail_data['body'] = part.get_payload(decode=True).decode(charset)
             break
-    return mailData
+    return mail_data
+
 
-def get_tracim_content_key(mailData:dict) -> Union[str,None]:
+def get_tracim_content_key(mail_data: dict) -> Union[str, None]:
 
-    """ Link mailData dict to tracim content
+    """ Link mail_data dict to tracim content
     First try checking special header, them check 'to' header
     and finally check first(oldest) mail-id of 'references' header
     """
     key = None
-    if TRACIM_SPECIAL_KEY_HEADER in mailData:
-        key = mailData[TRACIM_SPECIAL_KEY_HEADER]
-    if key is None and 'to' in mailData:
-        key = find_key_from_mail_adress(mailData['to'])
-    if key is None and 'references' in mailData:
-        mail_adress = mailData['references']
+    if TRACIM_SPECIAL_KEY_HEADER in mail_data:
+        key = mail_data[TRACIM_SPECIAL_KEY_HEADER]
+    if key is None and 'to' in mail_data:
+        key = find_key_from_mail_adress(mail_data['to'])
+    if key is None and 'references' in mail_data:
+        mail_adress = mail_data['references']
         key = find_key_from_mail_adress(mail_adress)
     return key
 
-def find_key_from_mail_adress(mail_address:str) -> Union[str,None]:
+
+def find_key_from_mail_adress(mail_address: str) -> Union[str, None]:
     """ Parse mail_adress-like string
     to retrieve key.
 
     :param mail_address: user+key@something like string
     :return: key
     """
-    username= mail_address.split('@')[0]
+    username = mail_address.split('@')[0]
     username_data = username.split('+')
     if len(username_data) == 2:
         key = username_data[1]
 
         self._is_active = True
 
-
-    def run(self):
+    def run(self) -> None:
         while self._is_active:
             time.sleep(self.delay)
             self._connect()
             self._notify_tracim()
             self._disconnect()
 
-    def stop(self):
+    def stop(self) -> None:
         self._is_active = False
 
-    def _connect(self):
-        ## verify if connected ?
+    def _connect(self) -> None:
+        # verify if connected ?
         if self._connection:
             self._disconnect()
         # TODO: Support unencrypted connection ?
         # TODO: Support keyfile,certfile ?
-        self._connection = imaplib.IMAP4_SSL(self.host,self.port)
+        self._connection = imaplib.IMAP4_SSL(self.host, self.port)
         try:
-            rv, data = self._connection.login(self.user,self.password)
+            self._connection.login(self.user, self.password)
         except Exception as e:
             log = 'IMAP login error: {}'
             logger.debug(self, log.format(e.__str__()))
 
-    def _disconnect(self):
+    def _disconnect(self) -> None:
         if self._connection:
             self._connection.close()
             self._connection.logout()
             self._connection = None
 
-    def _fetch(self):
+    def _fetch(self) -> None:
         """
         Get news message from mailbox
         """
                     if rv == 'OK':
                         msg = message_from_bytes(data[0][1])
                         self._mails.append(msg)
-                        ret = True
                     else:
                         # TODO : Check best debug value
                         log = 'IMAP : Unable to get mail : {}'
-                        logger.debug(self,log.format(str(rv)))
+                        logger.debug(self, log.format(str(rv)))
             else:
-                #TODO : Distinct error from empty mailbox ?
+                # TODO : Distinct error from empty mailbox ?
                 pass
-        else :
+        else:
             # TODO : Check best debug value
             log = 'IMAP : Unable to open mailbox : {}'
-            logger.debug(self,log.format(str(rv)))
+            logger.debug(self, log.format(str(rv)))
 
-    def _notify_tracim(self):
+    def _notify_tracim(self) -> None:
         while self._mails:
             mail = self._mails.pop()
             decoded_mail = decode_mail(mail)
-            msg = {"token" : VALID_TOKEN_VALUE,
-                   "user_mail" : decoded_mail['from'],
-                   "content_id" : get_tracim_content_key(decoded_mail),
+            msg = {"token": VALID_TOKEN_VALUE,
+                   "user_mail": decoded_mail['from'],
+                   "content_id": get_tracim_content_key(decoded_mail),
                    "payload": {
-                       "content": decoded_mail['body']
+                       "content": decoded_mail['body'],
                    }}
 
-            requests.post(self.endpoint,json=msg)
+            requests.post(self.endpoint, json=msg)
             pass