Renaming,classmethod instead of staticmethod,'' instead of ""

tracim/development.ini.base

 # Token for communication between mail fetcher and tracim controller
 email.reply.token = mysecuretoken
 # Delay in seconds between each check
-email.reply.delay = 60
+email.reply.check.heartbeat = 60
 
 ## Radical (CalDav server) configuration
 # radicale.server.host = 0.0.0.0

tracim/tracim/config/app_cfg.py

         self.EMAIL_REPLY_IMAP_FOLDER = tg.config.get(
             'email.reply.imap.folder',
         )
-        self.EMAIL_REPLY_DELAY = int(tg.config.get(
-            'email.reply.delay',
+        self.EMAIL_REPLY_CHECK_HEARTBEAT = int(tg.config.get(
+            'email.reply.check.heartbeat',
         ))
         self.EMAIL_REPLY_TOKEN = tg.config.get(
             'email.reply.token',

tracim/tracim/controllers/events.py

 from tracim.model.data import ContentType
 
 
-class EventsRestController(RestController):
+class EventRestController(RestController):
 
     @tg.expose('json')
     def post(self):

tracim/tracim/controllers/root.py

 from tracim.controllers.previews import PreviewsController
 from tracim.controllers.user import UserRestController
 from tracim.controllers.workspace import UserWorkspaceRestController
-from tracim.controllers.events import EventsRestController
+from tracim.controllers.events import EventRestController
 from tracim.lib import CST
 from tracim.lib.base import logger
 from tracim.lib.content import ContentApi
     previews = PreviewsController()
 
     content = ContentController()
-    events = EventsRestController()
+    events = EventRestController()
     # api
     api = APIController()
 

tracim/tracim/lib/daemons.py

             user=cfg.EMAIL_REPLY_IMAP_USER,
             password=cfg.EMAIL_REPLY_IMAP_PASSWORD,
             folder=cfg.EMAIL_REPLY_IMAP_FOLDER,
-            delay=cfg.EMAIL_REPLY_DELAY,
+            delay=cfg.EMAIL_REPLY_CHECK_HEARTBEAT,
             # FIXME - G.M - 2017-11-15 - proper tracim url formatting
             endpoint=cfg.WEBSITE_BASE_URL + "/events",
             token=cfg.EMAIL_REPLY_TOKEN,

tracim/tracim/lib/email_fetcher.py

 
 from tracim.lib.base import logger
 
-TRACIM_SPECIAL_KEY_HEADER = "X-Tracim-Key"
-BS_HTML_BODY_PARSE_CONFIG = {
-    'tag_blacklist': ["script", "style", "blockquote"],
+TRACIM_SPECIAL_KEY_HEADER = 'X-Tracim-Key'
+BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG = {
+    'tag_blacklist': ['script', 'style', 'blockquote'],
     'class_blacklist': ['moz-cite-prefix', 'gmail_extra', 'gmail_quote',
                         'yahoo_quoted'],
     'id_blacklist': ['reply-intro'],
                       'thead', 'tr', 'td', 'tbody', 'table', 'p', 'pre'],
     'attrs_whitelist': ['href'],
 }
+CONTENT_TYPE_TEXT_PLAIN = 'text/plain'
+CONTENT_TYPE_TEXT_HTML = 'text/html'
 
 
 class DecodedMail(object):
         body = None
         if body_part:
             charset = body_part.get_content_charset('iso-8859-1')
-            ctype = body_part.get_content_type()
-            if ctype == "text/plain":
+            content_type = body_part.get_content_type()
+            if content_type == CONTENT_TYPE_TEXT_PLAIN:
                 txt_body = body_part.get_payload(decode=True).decode(
                     charset)
                 body = DecodedMail._parse_txt_body(txt_body)
 
-            elif ctype == "text/html":
+            elif content_type == CONTENT_TYPE_TEXT_HTML:
                 html_body = body_part.get_payload(decode=True).decode(
                     charset)
                 body = DecodedMail._parse_html_body(html_body)
 
         return body
 
-    @staticmethod
-    def _parse_txt_body(txt_body: str):
+    @classmethod
+    def _parse_txt_body(cls, txt_body: str):
         txt_body = EmailReplyParser.parse_reply(txt_body)
         html_body = markdown.markdown(txt_body)
         body = DecodedMail._parse_html_body(html_body)
         return body
 
-    @staticmethod
-    def _parse_html_body(html_body: str):
+    @classmethod
+    def _parse_html_body(cls, html_body: str):
         soup = BeautifulSoup(html_body)
-        config = BS_HTML_BODY_PARSE_CONFIG
+        config = BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG
         for tag in soup.findAll():
             if DecodedMail._tag_to_extract(tag):
                 tag.extract()
                 tag.unwrap()
         return str(soup)
 
-    @staticmethod
-    def _tag_to_extract(tag) -> bool:
-        config = BS_HTML_BODY_PARSE_CONFIG
+    @classmethod
+    def _tag_to_extract(cls, tag) -> bool:
+        config = BEAUTIFULSOUP_HTML_BODY_PARSE_CONFIG
         if tag.name.lower() in config['tag_blacklist']:
             return True
         if 'class' in tag.attrs:
                     return True
         return False
 
-
     def _get_mime_body_message(self) -> typing.Optional[Message]:
         # FIXME - G.M - 2017-11-16 - Use stdlib msg.get_body feature for py3.6+
         # FIXME - G.M - 2017-11-16 - Check support for non-multipart mail
         part = None
         # Check for html
         for part in self._message.walk():
-            ctype = part.get_content_type()
-            cdispo = str(part.get('Content-Disposition'))
-            if ctype == 'text/html' and 'attachment' not in cdispo:
+            content_type = part.get_content_type()
+            content_dispo = str(part.get('Content-Disposition'))
+            if content_type == CONTENT_TYPE_TEXT_HTML \
+                    and 'attachment' not in content_dispo:
                 return part
         # check for plain text
         for part in self._message.walk():
-            ctype = part.get_content_type()
-            cdispo = str(part.get('Content-Disposition'))
-            if ctype == 'text/plain' and 'attachment' not in cdispo:
+            content_type = part.get_content_type()
+            content_dispo = str(part.get('Content-Disposition'))
+            if content_type == CONTENT_TYPE_TEXT_PLAIN and 'attachment' \
+                    not in content_dispo:
                 return part
         return part
 
 
         return key
 
-    @staticmethod
-    def find_key_from_mail_address(mail_address: str) \
+    @classmethod
+    def find_key_from_mail_address(cls, mail_address: str) \
             -> typing.Optional[str]:
         """ Parse mail_adress-like string
         to retrieve key.
 class MailFetcher(object):
 
     def __init__(self,
-                 host: str, port: str, user: str, password: str, folder: str,
-                 delay: int, endpoint: str, token:str) \
+                 host: str,
+                 port: str,
+                 user: str,
+                 password: str,
+                 folder: str,
+                 delay: int,
+                 endpoint: str,
+                 token: str) \
             -> None:
         """
         Fetch mail from a mailbox folder through IMAP and add their content to
         unsended_mail = []
         while self._mails:
             mail = self._mails.pop()
-            msg = {"token": self.token,
-                   "user_mail": mail.get_from_address(),
-                   "content_id": mail.get_key(),
-                   "payload": {
-                       "content": mail.get_body(),
+            msg = {'token': self.token,
+                   'user_mail': mail.get_from_address(),
+                   'content_id': mail.get_key(),
+                   'payload': {
+                       'content': mail.get_body(),
                    }}
             try:
                 r = requests.post(self.endpoint, json=msg)