def save_draft(self, message, timeout=None):
""" Encrypt (if necessary) and save the message as a draft.
Parameters
----------
message: protonmail.models.Message
Returns
-------
result: protonmail.responses.MessageResponse
"""
if not self.blocking:
return self._save_draft(message)
return run_sync(self._save_draft, message, timeout=timeout)
def send_message(self, message, timeout=None):
""" Encrypt and send the message.
Parameters
----------
message: protonmail.models.Message
Returns
-------
result: protonmail.responses.MessageResponse
"""
if not self.blocking:
return self._send_message(message)
return run_sync(self._send_message, message, timeout=timeout)
def read_message(self, message, timeout=None):
""" Read and decrypt a Message if necessary
Parameters
----------
message: protonmail.message.Message or Dict
Returns
-------
result: String
Decrypted message
"""
if not self.blocking:
return self._read_message(message)
return run_sync(self._read_message, message, timeout=timeout)
def get_user_info(self, timeout=None):
""" Get the info aboute this User
Parameters
----------
timeout: Int or Float
Time to wait when blocking
Returns
--------
result: User
"""
if not self.blocking:
return self._get_user_info()
return run_sync(self._get_user_info, timeout=timeout)
def get_addresses(self, timeout=None):
""" Get addresses this User has
Parameters
----------
timeout: Int or Float
Time to wait when blocking
Returns
--------
result: User
"""
if not self.blocking:
return self._get_addresses()
return run_sync(self._get_addresses, timeout=timeout)
def get_public_key(self, email, timeout=None):
""" Get the public keys for the given email
Parameters
----------
emails: String
Email to retrieve
timeout: Int or Float
Time to wait when blocking
Returns
--------
result: Dict
"""
if not self.blocking:
return self._get_public_key(email)
return run_sync(self._get_public_key, email, timeout=timeout)
def request(self,
path,
body=None,
method='GET',
cookies=None,
headers=None,
response=None,
timeout=None,
blocking=None,
**kwargs):
""" Perform the request automatically sending the authentication
cookies and expected headers.
Parameters
----------
path: String
The path to request
body: String, List, or Dict
The body of the request
method: String
Request method
cookies: CookieJar
Request cookies
headers: Dict
Request headers
response: protonmail.responses.Response
Expected response to parse from the request
blocking: Bool
Override default blocking
timeout: Number
Timeout to use when blocking
kwargs: Object
Extra kwarts to pass to treq (ex json)
"""
blocking = blocking if blocking is not None else self.client.blocking
def request():
return self._request(path, body, method, cookies, headers,
response, **kwargs)
if blocking:
return run_sync(request, timeout=timeout)
return request()
def create_draft(self, address=None, message=None, timeout=None):
""" Create a message as a draft. This will populate an ID for
the message.
Parameters
----------
address: protonmail.models.Address or None
Address to send with, if None, the default will be used
message: protonmail.models.Message or None
Message to create a draft for, if None, one will be created
timeout: Int or Float
Timeout to wait when blocking
Returns
-------
result: protonmail.responses.MessageResponse
"""
if not self.blocking:
return self._create_draft(address, message)
return run_sync(self._create_draft, address, message, timeout=timeout)
def logout(self, timeout=None):
""" Logout of Protonmail """
if not self.client.blocking:
return self._logout()
return run_sync(self._logout, timeout=timeout)
def unlock(self, password, timeout=None):
""" Unlock to Protonmail """
if not self.client.blocking:
return self._unlock(password)
return run_sync(self._unlock, password, timeout=timeout)
def login(self, password, unlock=True, timeout=None):
""" Login and unlock Protonmail """
if not self.client.blocking:
return self._login(password, unlock)
return run_sync(self._login, password, unlock, timeout=timeout)
def send_simple(self, **kwargs):
""" Simple API for sending email """
if not self.blocking:
return self._send_simple(**kwargs)
return run_sync(self._send_simple, **kwargs)
def check_events(self, timeout=None):
""" Check for updates"""
if not self.blocking:
return self._check_events()
return run_sync(self._check_events, timeout=timeout)