mailbox-org-api 2.2__tar.gz → 2.4__tar.gz

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mailbox-org-api
-Version: 2.2
-Summary: A library to access the mailbox.org Business API.
+Version: 2.4
+Summary: A library to access the mailbox Business API.
 Author: Hendrik Schlange
 Author-email: Hendrik Schlange <mail@heshsum.de>
 Project-URL: Homepage, https://github.com/heshsum/mailbox-org-api
@@ -36,11 +36,15 @@ pip install mailbox-org-api
 pip install git+https://github.com/heshsum/mailbox-org-api
 ```
 
-## Usage
+## Usage and documentation
 Basic usage is fairly straightforward. The naming scheme of the functions is similar to the naming at mailbox.org,
-but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).  
+but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).
+
+Therefore, the functions mirror the functions as provided and documented at mailbox: 
+[api.mailbox.org](https://api.mailbox.org)
+
 Additionally, some helper functions for common or more complicated tasks are included to make life a bit easier, 
-e.g. for changing plans, password and to retrieve invoices.  
+e.g. for changing plans, password and to retrieving invoices.
 
 ```python
 from mailbox_org_api import APIClient
@@ -87,6 +91,8 @@ api.mail_set_forwards('foo@bar.com', ['forward1@bar.com', 'forward2@bar.com'])
 api.deauth()
 ```
 
+More information can be found in the [Wiki](https://github.com/heshsum/mailbox-org-api/wiki)
+
 ## Common tasks
 mailbox_org_api includes a number of helper functions to make common tasks simpler. These include:
 
@@ -163,21 +169,21 @@ Usage:
 api.account_invoice_get_token('BMBO-1234-24')
 ```
 
-### account_invoice_get_pdf
+### account_invoice_get_file
 Invoices are provided as Based64 encoded gz Strings. This function
 1. takes the invoice ID
 2. retrieves the token for the invoice
 3. gets the binary data
 4. decodes the Base64
 5. decompresses it
-6. returns the bytes of the actual PDF
+6. returns the bytes of the actual invoice file
 
 Usage
 ```python
 invoice_id = 'BMBO-1234-24'
-account_name = 'some_user'
+account_name = 'foo'
 with open(invoice_id + '.pdf', 'w') as file:
-    file.write(api.account_invoice_get_pdf(account_name, invoice_id))
+    file.write(api.account_invoice_get_file(account_name, invoice_id, 'PDF'))
 ```
 
 ## Here be dragons

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/README.md

@@ -19,11 +19,15 @@ pip install mailbox-org-api
 pip install git+https://github.com/heshsum/mailbox-org-api
 ```
 
-## Usage
+## Usage and documentation
 Basic usage is fairly straightforward. The naming scheme of the functions is similar to the naming at mailbox.org,
-but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).  
+but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).
+
+Therefore, the functions mirror the functions as provided and documented at mailbox: 
+[api.mailbox.org](https://api.mailbox.org)
+
 Additionally, some helper functions for common or more complicated tasks are included to make life a bit easier, 
-e.g. for changing plans, password and to retrieve invoices.  
+e.g. for changing plans, password and to retrieving invoices.
 
 ```python
 from mailbox_org_api import APIClient
@@ -70,6 +74,8 @@ api.mail_set_forwards('foo@bar.com', ['forward1@bar.com', 'forward2@bar.com'])
 api.deauth()
 ```
 
+More information can be found in the [Wiki](https://github.com/heshsum/mailbox-org-api/wiki)
+
 ## Common tasks
 mailbox_org_api includes a number of helper functions to make common tasks simpler. These include:
 
@@ -146,21 +152,21 @@ Usage:
 api.account_invoice_get_token('BMBO-1234-24')
 ```
 
-### account_invoice_get_pdf
+### account_invoice_get_file
 Invoices are provided as Based64 encoded gz Strings. This function
 1. takes the invoice ID
 2. retrieves the token for the invoice
 3. gets the binary data
 4. decodes the Base64
 5. decompresses it
-6. returns the bytes of the actual PDF
+6. returns the bytes of the actual invoice file
 
 Usage
 ```python
 invoice_id = 'BMBO-1234-24'
-account_name = 'some_user'
+account_name = 'foo'
 with open(invoice_id + '.pdf', 'w') as file:
-    file.write(api.account_invoice_get_pdf(account_name, invoice_id))
+    file.write(api.account_invoice_get_file(account_name, invoice_id, 'PDF'))
 ```
 
 ## Here be dragons

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/mailbox_org_api/APIClient.py

@@ -2,24 +2,28 @@
 Module for the mailbox Business API client
 """
 import json
+from typing import Any
+
 import requests
 from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
 from requests.exceptions import RequestException
-import typing_extensions
+from urllib3.util.retry import Retry
+
 from mailbox_org_api.APIError import APIError
 from mailbox_org_api.Account import Account
-from mailbox_org_api.Mail import Mail
 from mailbox_org_api.Invoice import Invoice
+from mailbox_org_api.Mail import Mail
 
 headers = {'content-type': 'application/json'}
 
 keys_to_string = ['additional_cloud_quota', 'additional_mail_quota']
 
+
 class APIClient:
     """
     Object for API Client
     """
+
     def __init__(self, debug_output=False, max_retries=5):
         # URL of the API
         self.url = "https://api.mailbox.org/v1/"
@@ -62,7 +66,7 @@ class APIClient:
         self.jsonrpc_id += 1
         return str(self.jsonrpc_id)
 
-    def api_request(self, method: str, params: dict) -> dict:
+    def api_request(self, method: str, params: dict) -> dict | Any:
         """
         Function to send API calls
         :param method: the method to call
@@ -125,7 +129,7 @@ class APIClient:
         :param password: the password
         :return: the API response for the request
         """
-        api_response = self.api_request('auth', {'user':username, 'pass':password})
+        api_response = self.api_request('auth', {'user': username, 'pass': password})
         if api_response['session']:
             # Level gives information about the calls available
             self.level = api_response["level"]
@@ -143,7 +147,7 @@ class APIClient:
         Function to close the current API session
         :return: True if the API session is closed, False otherwise
         """
-        api_response = self.api_request('deauth',{})
+        api_response = self.api_request('deauth', {})
         if api_response:
             # The auth header is stripped
             self.session.headers.pop("HPLS-AUTH")
@@ -156,7 +160,7 @@ class APIClient:
         Function for hello world, just to test the connection
         :return: The response from the mailbox.org Business API
         """
-        return self.api_request('hello.world',{})
+        return self.api_request('hello.world', {})
 
     def hello_innerworld(self):
         """
@@ -210,9 +214,9 @@ class APIClient:
         :param account: the account name to get
         :return: the response from the mailbox.org Business API
         """
-        return self.api_request('account.get', {'account':account})
+        return self.api_request('account.get', {'account': account})
 
-    def account_get_object(self, account:str) -> Account:
+    def account_get_object(self, account: str) -> Account:
         result = self.api_request('account.get', {'account': account})
         account_object = Account(account)
         for k, v in result.items():
@@ -256,7 +260,7 @@ class APIClient:
         :param account: the account name to delete
         :return: the response from the mailbox.org Business API
         """
-        return self.api_request('account.del', {'account':account})
+        return self.api_request('account.del', {'account': account})
 
     def account_invoice_list(self, account: str) -> dict:
         """
@@ -264,7 +268,7 @@ class APIClient:
         :param account: the account name to list
         :return: the response from the mailbox.org Business API
         """
-        return self.api_request('account.invoice.list', {'account':account})
+        return self.api_request('account.invoice.list', {'account': account})
 
     def account_invoice_get(self, account: str, token: str) -> dict:
         """
@@ -273,7 +277,7 @@ class APIClient:
         :param token: the token for the invoice
         :return: the response from the mailbox.org Business API - the invoice as a Base64 encoded gzipped string
         """
-        return self.api_request('account.invoice.get', {'account':account, 'token':token})
+        return self.api_request('account.invoice.get', {'account': account, 'token': token})
 
     def account_invoice_get_object(self, account: str, invoice_id: str) -> Invoice:
         """
@@ -300,7 +304,7 @@ class APIClient:
         """
         Function to get a list of all invoice ids for a specific account
         """
-        response = self.api_request('account.invoice.list', {'account':account})
+        response = self.api_request('account.invoice.list', {'account': account})
         invoices = []
 
         for invoice in response:
@@ -313,7 +317,7 @@ class APIClient:
         """
         invoices = self.account_invoice_list(account)
         open_invoices = []
-        
+
         for i in invoices:
             if i['status'] == 'open':
                 open_invoices.append(i)
@@ -332,22 +336,12 @@ class APIClient:
                 return invoice['token']
         raise ValueError('Invoice not found')
 
-    @typing_extensions.deprecated('Use account_invoice_get_file instead')
-    def account_invoice_get_pdf(self, account: str, invoice_id: str) -> bytes:
-        """
-        Function to get a specific invoice as a PDf-file
-        :param account: the account name
-        :param invoice_id: the invoice ID
-        :return: the PDF as bytes
-        """
-        return self.account_invoice_get_file(account, invoice_id, 'pdf')
-
     def account_invoice_get_file(self, account: str, invoice_id: str, file_type: str) -> bytes:
         """
         Function to get a specific invoice as a PDf-file
         :param account: the account name
         :param invoice_id: the invoice ID
-        :param file_type: The file type to return. Valid: csv, pdf and xml
+        :param file_type: The file type to return. Valid: CSV, PDF and XML
         :return: the file as bytes
         """
         if file_type not in ('csv', 'pdf', 'xml'):
@@ -365,17 +359,30 @@ class APIClient:
         # Take the Base64 encoded data (response['bin']), decode the Base 64, decompress the gz and return the bytes
         return zlib.decompress(base64.b64decode(response['bin']))
 
-    def domain_list(self, account: str, search_filter:str = None) -> dict:
+    def domain_list(self, account: str, search_filter: str | None = None) -> dict:
         """
         Function to list all domains
         :param account: the account to list domains for
         :param search_filter: String for optional search filter
         :return: the API response
         """
-        params = {'account':account}
-        if filter:
-            params.update({'filter':search_filter})
-        return self.api_request('domain.list',params)
+        params = {'account': account}
+        if isinstance(search_filter, str):
+            params.update({'filter': str(search_filter)})
+        return self.api_request('domain.list', params)
+
+    def domain_get_list(self, account: str, search_filter: str | None = None) -> list:
+        """
+        Function to get a List object with domain names for a given account
+        :param account: the account to list domains for
+        :param search_filter: String for optional search filter
+        :return: a List object containing the domain names
+        """
+        result = self.domain_list(account, search_filter)
+        domains = []
+        for i in result:
+            domains.append(i['domain'])
+        return domains
 
     def domain_add(self, account: str, domain: str, password: str, **kwargs) -> dict:
         """
@@ -387,7 +394,7 @@ class APIClient:
         See documentation here: https://api.mailbox.org/v1/doc/methods/index.html#domain-add
         :return: the API response
         """
-        params = {'account':account, 'domain':domain, 'password':password}
+        params = {'account': account, 'domain': domain, 'password': password}
         params.update({k: v for k, v in kwargs.items() if v is not None})
         return self.api_request('domain.add', params)
 
@@ -397,7 +404,7 @@ class APIClient:
         :param domain: the domain to get
         :return: the API response
         """
-        return self.api_request('domain.get',{'domain':domain})
+        return self.api_request('domain.get', {'domain': domain})
 
     def domain_capabilities_set(self, domain: str, capabilities: list) -> dict:
         """
@@ -442,7 +449,7 @@ class APIClient:
         :param domain: the domain to delete
         :return: the API response
         """
-        return self.api_request('domain.del', {'account':account, 'domain':domain})
+        return self.api_request('domain.del', {'account': account, 'domain': domain})
 
     def domain_validate_spf(self, domain: str) -> dict:
         """
@@ -450,10 +457,10 @@ class APIClient:
         :param domain: the domain to validate
         :return: the API response - information about the SPF config
         """
-        return self.api_request('domain.validate.spf', {'domain':domain})
+        return self.api_request('domain.validate.spf', {'domain': domain})
 
-    def mail_list(self, domain: str, details: bool = False, page_size: int = None, page: int = None, sort_field: str = None,
-                  sort_order: str = None) -> dict:
+    def mail_list(self, domain: str, details: bool = False, page_size: int | None = None, page: int | None = None,
+                  sort_field: str | None = None, sort_order: str | None = None) -> dict:
         """
         Function to list all mailboxes
         :param domain: the domain to list
@@ -464,8 +471,8 @@ class APIClient:
         :param sort_order: the order to sort by. Possible values: 'asc', 'desc'
         :return: the response from the mailbox.org Business API
         """
-        args = {'domain':domain, 'details':details, 'page_size':page_size, 'page':page, 'sort_field':sort_field,
-                  'sort_order':sort_order}
+        args = {'domain': domain, 'details': details, 'page_size': page_size, 'page': page, 'sort_field': sort_field,
+                'sort_order': sort_order}
 
         # Allowed sort fields as documented here: https://api.mailbox.org/v1/doc/methods/index.html#mail-list
         mail_list_sort_field = ['mail', 'first_name', 'last_name', 'status', 'domain', 'plan', 'type', 'creation_date']
@@ -487,8 +494,20 @@ class APIClient:
 
         return self.api_request('mail.list', params)
 
-    def mail_add(self, mail:str, password: str, plan: str, first_name: str, last_name: str, inboxsave: bool = True,
-                 forwards: list = None, **kwargs) -> dict:
+    def mail_get_list(self, domain: str) -> list:
+        """
+        Function to get a list of all mailboxes of a domain as a List object.
+        :param domain: the domain to list all mailboxes for.
+        :return: a List object containing all mail addresses of the given domain.
+        """
+        result = self.mail_list(domain)
+        mails = []
+        for i in result:
+            mails.append(i['mail'])
+        return mails
+
+    def mail_add(self, mail: str, password: str, plan: str, first_name: str, last_name: str, inboxsave: bool = True,
+                 forwards: list | None = None, **kwargs) -> dict:
         """
         Function to add a mail
         :param mail: the mail to add
@@ -507,10 +526,10 @@ class APIClient:
                               'create_own_context': bool, 'title': str, 'birthday': str, 'position': str,
                               'department': str, 'company': str, 'street': str, 'postal_code': str, 'city': str,
                               'phone': str, 'fax': str, 'cell_phone': str, 'recover': bool, 'skip_welcome_mail': bool,
-                              'uid_extern': str, 'language': str, 'evac_force_activation':bool}
+                              'uid_extern': str, 'language': str, 'evac_force_activation': bool}
 
         if password and 'password_hash' in kwargs:
-          raise KeyError('''Simultaneous usage of 'password' and 'password_hash' not allowed.
+            raise KeyError('''Simultaneous usage of 'password' and 'password_hash' not allowed.
           Use 'password' = None if password_hash is used.''')
 
         if forwards is None:
@@ -523,8 +542,8 @@ class APIClient:
                 kwargs[k] = str(kwargs[k])
 
         # After validation, build parameter list from mail and kwargs
-        params = {'mail':mail, 'password':password, 'plan':plan, 'first_name':first_name, 'last_name':last_name,
-                  'inboxsave':inboxsave, 'forwards':forwards}
+        params = {'mail': mail, 'password': password, 'plan': plan, 'first_name': first_name, 'last_name': last_name,
+                  'inboxsave': inboxsave, 'forwards': forwards}
         params.update({k: v for k, v in kwargs.items() if v is not None})
         return self.api_request('mail.add', params)
 
@@ -535,10 +554,10 @@ class APIClient:
         :param include_quota_usage: True if the quota usage should be included in the request
         :return the response for the request
         """
-        return self.api_request('mail.get', {'mail':mail, 'include_quota_usage':include_quota_usage})
+        return self.api_request('mail.get', {'mail': mail, 'include_quota_usage': include_quota_usage})
 
-    def mail_get_object(self, mail:str) -> Mail:
-        result = self.api_request('mail.get', {'mail':mail, 'include_quota_usage':False})
+    def mail_get_object(self, mail: str) -> Mail:
+        result = self.api_request('mail.get', {'mail': mail, 'include_quota_usage': False})
         mail_object = Mail(mail)
         for k, v in result.items():
             if v is not None:
@@ -555,15 +574,15 @@ class APIClient:
         """
         # Allowed attributes as documented here: https://api.mailbox.org/v1/doc/methods/index.html#mail-set
         allowed_parameters = {'password': str, 'password_hash': str, 'same_password_allowed': bool,
-                               'require_reset_password': bool, 'plan': str, 'additional_mail_quota': int,
-                               'additional_cloud_quota': int, 'first_name': str, 'last_name': str, 'inboxsave': bool,
-                               'forwards': list, 'aliases': list, 'alternate_mail': str, 'memo': str, 'allow_nets': str,
-                               'active': bool, 'title': str, 'birthday': str, 'position': str, 'department': str,
-                               'company': str, 'street': str, 'postal_code': str, 'city': str, 'phone': str, 'fax': str,
-                               'cell_phone': str, 'uid_extern': str, 'language': str, 'deletion_date': str}
+                              'require_reset_password': bool, 'plan': str, 'additional_mail_quota': int,
+                              'additional_cloud_quota': int, 'first_name': str, 'last_name': str, 'inboxsave': bool,
+                              'forwards': list, 'aliases': list, 'alternate_mail': str, 'memo': str, 'allow_nets': str,
+                              'active': bool, 'title': str, 'birthday': str, 'position': str, 'department': str,
+                              'company': str, 'street': str, 'postal_code': str, 'city': str, 'phone': str, 'fax': str,
+                              'cell_phone': str, 'uid_extern': str, 'language': str, 'deletion_date': str}
 
         if 'password' in kwargs and 'password_hash' in kwargs:
-          raise KeyError('''Simultaneous usage of 'password' and 'password_hash' not allowed.''')
+            raise KeyError('''Simultaneous usage of 'password' and 'password_hash' not allowed.''')
 
         if 'additional_mail_quota' in kwargs or 'additional_cloud_quota' in kwargs and 'plan' not in kwargs:
             raise KeyError('''If setting additional quota, 'plan' must be given.''')
@@ -578,9 +597,9 @@ class APIClient:
                 kwargs[k] = str(kwargs[k])
 
         # After validation, build parameter list from mail and kwargs
-        params = {'mail':mail}
+        params = {'mail': mail}
         params.update({k: v for k, v in kwargs.items() if v is not None})
-        
+
         return self.api_request('mail.set', params)
 
     def mail_set_password(self, mail: str, password: str) -> dict:
@@ -590,7 +609,7 @@ class APIClient:
         :param password: the password to set
         :return: the response for the request
         """
-        return self.api_request('mail.set', {'mail':mail, 'password':password})
+        return self.api_request('mail.set', {'mail': mail, 'password': password})
 
     def mail_set_password_require_reset(self, mail: str, password: str) -> dict:
         """
@@ -608,7 +627,7 @@ class APIClient:
         :param plan: the plan to set
         :return: the response for the request
         """
-        return self.api_request('mail.set', {'mail':mail, 'plan':plan})
+        return self.api_request('mail.set', {'mail': mail, 'plan': plan})
 
     def mail_set_forwards(self, mail: str, forwards: list) -> dict:
         """
@@ -617,7 +636,7 @@ class APIClient:
         :param forwards: a list of addresses to forwards mails to
         :return: the response for the request
         """
-        return self.api_request('mail.set', {'mail':mail, 'forwards':forwards})
+        return self.api_request('mail.set', {'mail': mail, 'forwards': forwards})
 
     def mail_set_aliases(self, mail: str, aliases: list) -> dict:
         """
@@ -626,7 +645,7 @@ class APIClient:
         :param aliases: a list of aliases to set
         :return: the response for the request
         """
-        return self.api_request('mail.set', {'mail':mail, 'aliases':aliases})
+        return self.api_request('mail.set', {'mail': mail, 'aliases': aliases})
 
     def mail_set_state(self, mail: str, active: bool) -> dict:
         """
@@ -635,7 +654,7 @@ class APIClient:
         :param active: True if the mail should be active, False if it shall be deactivated
         :return: the response for the request
         """
-        return self.api_request('mail.set', {'mail':mail, 'active':active})
+        return self.api_request('mail.set', {'mail': mail, 'active': active})
 
     def mail_set_additional_mail_quota(self, mail: str, quota: int) -> dict:
         """
@@ -645,7 +664,7 @@ class APIClient:
         :return: the response for the request
         """
         plan = self.mail_get(mail)['plan']
-        return self.api_request('mail.set', {'mail': mail, 'plan':plan, 'additional_mail_quota':quota})
+        return self.api_request('mail.set', {'mail': mail, 'plan': plan, 'additional_mail_quota': quota})
 
     def mail_set_additional_cloud_quota(self, mail: str, quota: int) -> dict:
         """
@@ -667,7 +686,7 @@ class APIClient:
         :return: the response for the request
         """
         return self.api_request('mail.set', {'mail': mail, 'deletion_date': deletion_date,
-                                'active': False})
+                                             'active': False})
 
     def mail_capabilities_set(self, mail: str, capabilities: list) -> dict:
         """
@@ -684,7 +703,7 @@ class APIClient:
         invalid = set(capabilities) - set(mail_capabilities)
         if invalid:
             raise ValueError(f'Invalid capabilities found: {", ".join(invalid)}')
-        params = {'mail':mail, 'capabilities':list(capabilities)}
+        params = {'mail': mail, 'capabilities': list(capabilities)}
         return self.api_request('mail.capabilities.set', params)
 
     def mail_del(self, mail: str) -> dict:
@@ -693,17 +712,17 @@ class APIClient:
         :param mail: the mail to delete
         :return: the response for the request
         """
-        return self.api_request('mail.del', {'mail':mail})
+        return self.api_request('mail.del', {'mail': mail})
 
-    def mail_apppassword_list(self, mail:str) -> dict:
+    def mail_apppassword_list(self, mail: str) -> dict:
         """
         Function to list all app passwords of a given mail
         :param mail: the mail to list app passwords for
         :return: the response for the request
         """
-        return self.api_request('mail.apppassword.list', {'mail':mail})
+        return self.api_request('mail.apppassword.list', {'mail': mail})
 
-    def mail_apppassword_add(self, mail:str, memo:str, imap_allowed:bool = True, smtp_allowed:bool = True) -> dict:
+    def mail_apppassword_add(self, mail: str, memo: str, imap_allowed: bool = True, smtp_allowed: bool = True) -> dict:
         """
         Function to generate a new mail app password for a mail
         :param mail: the mail to generate a new mail app password
@@ -712,8 +731,8 @@ class APIClient:
         :param smtp_allowed: True if the app password should be allowed to use an SMTP server. Default: True
         :return: the response for the request
         """
-        return self.api_request('mail.apppassword.add', {'mail':mail, 'memo':memo,
-                                                         'imap_allowed':imap_allowed, 'smtp_allowed':smtp_allowed})
+        return self.api_request('mail.apppassword.add', {'mail': mail, 'memo': memo,
+                                                         'imap_allowed': imap_allowed, 'smtp_allowed': smtp_allowed})
 
     def mail_apppassword_del(self, apppassword_id: int) -> dict:
         """
@@ -721,7 +740,7 @@ class APIClient:
         :param apppassword_id: the id of the mail app password
         :return: the response for the request
         """
-        return self.api_request('mail.apppassword.del', {'id':apppassword_id})
+        return self.api_request('mail.apppassword.del', {'id': apppassword_id})
 
     def mail_externaluid(self, account: str, uid_extern: str) -> dict:
         """
@@ -730,7 +749,7 @@ class APIClient:
         :param uid_extern: the external UID to get a mail for
         :return: mailbox API response - an array with the mail details
         """
-        return self.api_request('mail.externaluid', {'account':account, 'uid_extern':uid_extern})
+        return self.api_request('mail.externaluid', {'account': account, 'uid_extern': uid_extern})
 
     def mail_backup_list(self, mail: str) -> dict:
         """
@@ -738,7 +757,7 @@ class APIClient:
         :param mail: the mail to list backups for
         :return: mailbox API response - an array with the backup numbers and dates
         """
-        return self.api_request('mail.backup.list', {'mail':mail})
+        return self.api_request('mail.backup.list', {'mail': mail})
 
     def mail_backup_import(self, mail: str, backup_id: str, time: str, backup_filter: str) -> dict:
         """
@@ -750,7 +769,7 @@ class APIClient:
         :return: mailbox API response - an array with the backup numbers and dates
         """
         return self.api_request('mail.backup.import',
-                                {'mail':mail, 'id':backup_id, 'time':time, 'filter':backup_filter})
+                                {'mail': mail, 'id': backup_id, 'time': time, 'filter': backup_filter})
 
     def mail_spamprotect_get(self, mail: str) -> dict:
         """
@@ -758,7 +777,7 @@ class APIClient:
         :param mail: the mail to get the spam settings for
         :return: mailbox API response - an array with the spam settings
         """
-        return self.api_request('mail.spamprotect.get', {'mail':mail})
+        return self.api_request('mail.spamprotect.get', {'mail': mail})
 
     def mail_spamprotect_set(self, mail: str, greylist: bool, smtp_plausibility: bool, rbl: bool,
                              bypass_banned_checks: bool, tag2level: float, killlevel: str, route_to: str) -> dict:
@@ -778,27 +797,28 @@ class APIClient:
             raise ValueError('''Invalid value for killlevel. Only 'reject' or 'route' are allowed''')
 
         return self.api_request('mail.spamprotect.set',
-                                {'mail':mail, 'greylist': bool2str(greylist),
-                                 'smtp_plausibility':bool2str(smtp_plausibility), 'rbl':bool2str(rbl),
-                                 'bypass_banned_checks':bool2str(bypass_banned_checks), 'tag2level':round(tag2level, 1),
-                                 'killevel':killlevel, 'route_to':route_to})
+                                {'mail': mail, 'greylist': bool2str(greylist),
+                                 'smtp_plausibility': bool2str(smtp_plausibility), 'rbl': bool2str(rbl),
+                                 'bypass_banned_checks': bool2str(bypass_banned_checks),
+                                 'tag2level': round(tag2level, 1),
+                                 'killevel': killlevel, 'route_to': route_to})
 
     def mail_blacklist_list(self, mail: str) -> dict:
         """
-        Function to list the mail blacklist for a given mail address
-        :param mail: the mail to list the blacklist for
-        :return: mailbox API response - an array with the complete blacklist of the mail
+        Function to list the mail blacklist for a given mail address.
+        :param mail: the mail to list the blacklist for.
+        :return: mailbox API response - an array with the complete blacklist of the mail.
         """
-        return self.api_request('mail.blacklist.list', {'mail':mail})
+        return self.api_request('mail.blacklist.list', {'mail': mail})
 
     def mail_blacklist_add(self, mail: str, add_address: str) -> dict:
         """
-        Function to add a mail to a blacklist of a mail address
-        :param mail: the mail of the owner of the blacklist
-        :param add_address: the address to add to the blacklist
-        :return: mailbox API response - an array with the complete blacklist of the mail
+        Function to add a mail to a blacklist of a mail address.
+        :param mail: the mail of the owner of the blacklist.
+        :param add_address: the address to add to the blacklist.
+        :return: mailbox API response - an array with the complete blacklist of the mail.
         """
-        return self.api_request('mail.blacklist.add', {'mail':mail, 'add_address':add_address})
+        return self.api_request('mail.blacklist.add', {'mail': mail, 'add_address': add_address})
 
     def mail_blacklist_del(self, mail: str, delete_address: str) -> dict:
         """
@@ -807,7 +827,7 @@ class APIClient:
         :param delete_address: the address to delete from the blacklist
         :return: mailbox API response - an array with the complete blacklist of the mail
         """
-        return self.api_request('mail.blacklist.del', {'mail':mail, 'delete_address':delete_address})
+        return self.api_request('mail.blacklist.del', {'mail': mail, 'delete_address': delete_address})
 
     def mail_vacation_get(self, mail: str) -> dict:
         """
@@ -815,10 +835,10 @@ class APIClient:
         :param mail: the mail to get the vacation notice for
         :return: mailbox API response - the vacation notice of the mail
         """
-        return self.api_request('mail.vacation.get', {'mail':mail})
+        return self.api_request('mail.vacation.get', {'mail': mail})
 
     def mail_vacation_set(self, mail: str, subject: str, body: str, start_date: str, end_date: str,
-                          additional_mail_addresses: list = None) -> dict:
+                          additional_mail_addresses: list | None = None) -> dict:
         """
         Function to set the vacation notice for a given mail
         :param mail: the mail to get the vacation notice for
@@ -829,8 +849,8 @@ class APIClient:
         :param additional_mail_addresses: list of addresses to add to the vacation notice (optional)
         :return: mailbox API response - array with result 'true' of the request, code and message in case of an error
         """
-        params = {'mail':mail, 'subject':subject, 'body':body,'start_date':start_date, 'end_date':end_date,
-                  'additional_mail_addresses':additional_mail_addresses}
+        params = {'mail': mail, 'subject': subject, 'body': body, 'start_date': start_date, 'end_date': end_date,
+                  'additional_mail_addresses': additional_mail_addresses}
 
         # If no additional_mail_addresses are given, remove the parameter from the request
         if not additional_mail_addresses:
@@ -838,57 +858,75 @@ class APIClient:
 
         return self.api_request('mail.vacation.set', params)
 
-    def group_list(self) -> dict:
+    def group_list(self, account: str | None = None) -> dict:
         """
         Function to list all groups for an account
+        :param account: optional parameter for the account to list the groups for
         :return: mailbox API response - the list of groups
         """
-        return self.api_request('group.list', {})
+        params = {}
+        if account:
+            params['account'] = account
+        return self.api_request('group.list', params)
 
-    def group_get(self, group_id: int) -> dict:
+    def group_get(self, group_id: int, account: str | None = None) -> dict:
         """
         Function to get a group from the account by the group id
         :param group_id: the id of the group to get
+        :param account: optional parameter for the account to get the group for
         :return: mailbox API response - the list of groups of the account
         """
-        return self.api_request('group.get', {'group_id':group_id})
+        params = {'group_id': group_id}
+        if account:
+            params['account'] = account
+        return self.api_request('group.get', params)
 
-    def group_del(self, group_id: int) -> dict:
+    def group_del(self, group_id: int, account: str | None = None) -> dict:
         """
         Function to delete a group
         :param group_id: the group's id of the group to delete
+        :param account: optional parameter for the account to delete the group for
         :return: mailbox API response - True if the group was deleted, False otherwise
         """
-        return self.api_request('group.del', {'group_id':group_id})
+        params = {'group_id': group_id}
+        if account:
+            params['account'] = account
+        return self.api_request('group.del', params)
 
-    def group_add(self, name: str, display_name: str, mail_addresses_to_add: list) -> dict:
+    def group_add(self, name: str, display_name: str, mail_addresses_to_add: list, account: str | None = None) -> dict:
         """
         Function to add a group
         :param name: the group name
         :param display_name: the group's display name
         :param mail_addresses_to_add: a list of mail addresses to add
+        :param account: optional parameter for the account to add the group for
         :return: mailbox API response - True if the group was added, False otherwise
         """
-        return self.api_request('group.add', {'name':name, 'display_name':display_name,
-                                              'mail_addresses_to_add':mail_addresses_to_add})
+        params = {'name': name, 'display_name': display_name, 'mail_addresses_to_add': mail_addresses_to_add}
+        if account:
+            params['account'] = account
+        return self.api_request('group.add', params)
 
-    def group_set(self, group_id: int, display_name: str, mail_addresses_to_add: list = None,
-                  mail_addresses_to_remove: list = None) -> dict:
+    def group_set(self, group_id: int, display_name: str, mail_addresses_to_add: list | None = None,
+                  mail_addresses_to_remove: list | None = None, account: str | None = None) -> dict:
         """
         Function to modify a group. Either mail_addresses_to_add or mail_addresses_to_remove have to be specified.
         :param group_id: the group's id of the group to modify
         :param display_name: the group's display name
         :param mail_addresses_to_add: a list of mail addresses to add. Defaults to None
         :param mail_addresses_to_remove: a list of mail addresses to remove. Defaults to None
+        :param account: optional parameter for the account to set the group for
         :return: mailbox API response - True if the group was edited, False otherwise
         """
         # If mail_addresses_to_add and mail_addresses_to_remove are both empty, raise error
         if mail_addresses_to_add is None and mail_addresses_to_remove is None:
             raise ValueError('mail_addresses_to_add or mail_addresses_to_remove are required')
 
-        return self.api_request('group.set', {'group_id':group_id, 'display_name':display_name,
-                                              'mail_addresses_to_add':mail_addresses_to_add,
-                                              'mail_addresses_to_remove':mail_addresses_to_remove})
+        params = {'group_id': group_id, 'display_name': display_name, 'mail_addresses_to_add': mail_addresses_to_add,
+                  'mail_addresses_to_remove': mail_addresses_to_remove}
+        if account:
+            params['account'] = account
+        return self.api_request('group.set', params)
 
     def mail_passwordreset_listmethods(self, mail: str) -> dict:
         """
@@ -896,16 +934,16 @@ class APIClient:
         :param mail: the mail to query
         :return: mailbox API response - a list of available password reset methods
         """
-        return self.api_request('mail.passwordreset.listmethods', {'mail':mail})
+        return self.api_request('mail.passwordreset.listmethods', {'mail': mail})
 
     def mail_passwordreset_sendsms(self, mail: str, cell_phone: str) -> dict:
         """
         Function to send a password reset for a mail via SMS
         :param mail: the mail to send the SMS for
         :param cell_phone: the cell phone number of the mailbox
-        :return: mailbox API response - True if the SMS was sent, False otherwise
+        :return: API response from mailbox - True if the SMS was sent, False otherwise
         """
-        return self.api_request('mail.passwordreset.sendsms',{'mail':mail, 'cell_phone':cell_phone})
+        return self.api_request('mail.passwordreset.sendsms', {'mail': mail, 'cell_phone': cell_phone})
 
     def mail_passwordreset_setpassword(self, mail: str, token: str, password: str) -> dict:
         """
@@ -916,7 +954,7 @@ class APIClient:
         :return: mailbox API response - True if the password was set, False otherwise
         """
         return self.api_request('mail.passwordreset.setpassword',
-                                {'mail':mail, 'token':token, 'password':password})
+                                {'mail': mail, 'token': token, 'password': password})
 
     def context_list(self, account: str) -> dict:
         """
@@ -924,7 +962,7 @@ class APIClient:
         :param account: the account to list all contexts for
         :return: mailbox API response - an array with key 'context id' and value 'associated domains'
         """
-        return self.api_request('context.list', {'account':account})
+        return self.api_request('context.list', {'account': account})
 
     def search(self, query: str, get_account_summary: bool = False, get_extended_mail_result: bool = False) -> dict:
         """
@@ -934,8 +972,8 @@ class APIClient:
         :param get_extended_mail_result: whether to return more information about mailboxes found
         :return: the mailbox API response for the request - an array with results for accounts, domains and mailboxes
         """
-        return self.api_request('search', {'query':query, 'get_account_summary':get_account_summary,
-                                           'get_extended_mail_result':get_extended_mail_result})
+        return self.api_request('search', {'query': query, 'get_account_summary': get_account_summary,
+                                           'get_extended_mail_result': get_extended_mail_result})
 
     def mailinglist_list(self, account: str) -> dict:
         """
@@ -943,9 +981,9 @@ class APIClient:
         :param account: the account to list all mailing lists for
         :return: a dict containing the list of mailing lists
         """
-        return self.api_request('mailinglist.list', {'account':account})
+        return self.api_request('mailinglist.list', {'account': account})
 
-    def mailinglist_add(self, mailinglist: str, password: str, account: str, adminmail: str = None) -> dict:
+    def mailinglist_add(self, mailinglist: str, password: str, account: str, adminmail: str | None = None) -> dict:
         """
         Function to add a mailing list
         :param mailinglist: the mailing list to add
@@ -954,8 +992,8 @@ class APIClient:
         :param adminmail: admin email address of the mailing list (optional)
         :return: True if the mailing list was added, error code otherwise
         """
-        return self.api_request('mailinglist.add', {'mailinglist':mailinglist, 'password':password,
-                                                'account':account, 'adminmail':adminmail})
+        return self.api_request('mailinglist.add', {'mailinglist': mailinglist, 'password': password,
+                                                    'account': account, 'adminmail': adminmail})
 
     def mailinglist_get(self, mailinglist: str, account: str) -> dict:
         """
@@ -964,19 +1002,20 @@ class APIClient:
         :param account: the account of the mailing list
         :return: the mailbox API response for the request - a dict of the mailing list
         """
-        return self.api_request('mailinglist.get', {'mailinglist':mailinglist, 'account':account})
+        return self.api_request('mailinglist.get', {'mailinglist': mailinglist, 'account': account})
 
-    def mailinglist_set(self, mailinglist: str, account: str, password: str = None, adminmail: str = None) -> dict:
+    def mailinglist_set(self, mailinglist: str, account: str, password: str | None = None,
+                        adminmail: str | None = None) -> dict:
         """
-        Function to change a mailing list
-        :param mailinglist: the mailing list to change
-        :param password: the password of the mailing list
-        :param account: the account of the mailing list (optional)
-        :param adminmail: admin email address of the mailing list (optional)
-        :return: the mailbox API response for the request - True if the mailing list was changed, error code otherwise
+        Function to change a mailing list.
+        :param mailinglist: the mailing list to change.
+        :param password: the password of the mailing list.
+        :param account: the account of the mailing list (optional).
+        :param adminmail: admin email address of the mailing list (optional).
+        :return: the mailbox API response for the request - True if the mailing list was changed, error code otherwise.
         """
-        return self.api_request('mailinglist.set', {'mailinglist':mailinglist, 'account':account,
-                                                'password':password, 'adminmail':adminmail})
+        return self.api_request('mailinglist.set', {'mailinglist': mailinglist, 'account': account,
+                                                    'password': password, 'adminmail': adminmail})
 
     def mailinglist_del(self, mailinglist: str, account: str) -> dict:
         """
@@ -985,7 +1024,7 @@ class APIClient:
         :param account: the account of the mailing list
         :return: the mailbox API response for the request - True if the mailing list was deleted, error code otherwise
         """
-        return self.api_request('mailinglist.del', {'mailinglist':mailinglist, 'account':account})
+        return self.api_request('mailinglist.del', {'mailinglist': mailinglist, 'account': account})
 
     def additionalmailaccount_list(self, parent_mail: str) -> dict:
         """
@@ -993,10 +1032,10 @@ class APIClient:
         :param parent_mail: the parent mail to list additional mail accounts for
         :return: a dict containing the parent mail account and a list of additional mail accounts
         """
-        return self.api_request('additionalmailaccount.list', {'parent_mail':parent_mail})
+        return self.api_request('additionalmailaccount.list', {'parent_mail': parent_mail})
 
     def additionalmailaccount_add(self, parent_mail: str, new_account_mail: str, new_account_password: str,
-                                  primary_address: str = None, mail_server: str = 'imap.mailbox.org',
+                                  primary_address: str | None = None, mail_server: str = 'imap.mailbox.org',
                                   mail_port: int = 993, mail_secure: bool = True, mail_starttls: bool = False,
                                   transport_server: str = 'smtp.mailbox.org', transport_port: int = 465,
                                   transport_secure: bool = True, transport_starttls: bool = False,
@@ -1009,23 +1048,23 @@ class APIClient:
         2. mail server settings are grouped
         3. transport server settings are grouped
         4. Ports are integers
-        :param new_account_mail: the additional mail address to add
-        :param new_account_password: the password of the additional mail address
-        :param parent_mail: the mail address to add the additional mail account to
-        :param primary_address: the primary 'address from' for the additional mail address
-        :param mail_server: the IMAP server to use
-        :param mail_port: the port of the IMAP server
-        :param transport_server: the SMTP server to use
-        :param transport_port: the port of the SMTP server
-        :param mail_secure: whether to use SSL for IMAP
-        :param mail_starttls: whether to use STARTTLS for IMAP
-        :param transport_secure: whether to use SSL for SMTP
-        :param transport_starttls: whether to use STARTTLS for SMTP
-        :param trash_folder: name of the trash folder
-        :param sent_folder: name of the sent folder
-        :param drafts_folder: name of the drafts folder
-        :param spam_folder: name of the spam folder
-        :return: the response for the request - True if adding was successful, error code otherwise
+        :param new_account_mail: the additional mail address to add.
+        :param new_account_password: the password of the additional mail address.
+        :param parent_mail: the mail address to add the additional mail account to.
+        :param primary_address: the primary 'address from' for the additional mail address.
+        :param mail_server: the IMAP server to use.
+        :param mail_port: the port of the IMAP server.
+        :param transport_server: the SMTP server to use.
+        :param transport_port: the port of the SMTP server.
+        :param mail_secure: whether to use SSL for IMAP.
+        :param mail_starttls: whether to use STARTTLS for IMAP.
+        :param transport_secure: whether to use SSL for SMTP.
+        :param transport_starttls: whether to use STARTTLS for SMTP.
+        :param trash_folder: name of the trash folder.
+        :param sent_folder: name of the sent folder.
+        :param drafts_folder: name of the drafts folder.
+        :param spam_folder: name of the spam folder.
+        :return: the response for the request - True if adding was successful, error code otherwise.
         """
         return self.api_request('additionalmailaccount.add', {'new_account_mail': new_account_mail,
                                                               'new_account_password': new_account_password,
@@ -1051,7 +1090,7 @@ class APIClient:
         :return: True if the account was deleted, error code otherwise
         """
         return self.api_request('additionalmailaccount.delete',
-                                {'parent_mail':parent_mail, 'account_mail':account_mail})
+                                {'parent_mail': parent_mail, 'account_mail': account_mail})
 
     def evac_activate(self):
         """
@@ -1061,7 +1100,7 @@ class APIClient:
         """
         return self.api_request('evac_activate', {})
 
-    def evac_resetaccount(self, delete_mail_accounts_and_domains:bool = False) -> dict:
+    def evac_resetaccount(self, delete_mail_accounts_and_domains: bool = False) -> dict:
         """
         Function to reset a mailbox EVAC account.
         Note: this needs a special permission from mailbox.
@@ -1071,6 +1110,7 @@ class APIClient:
         return self.api_request('evac_resetaccount',
                                 {'delete_mail_accounts_and_domains': delete_mail_accounts_and_domains})
 
+
 def validate_params(allowed: dict, actual: dict) -> bool | None:
     for arg in actual:
         if arg not in allowed:
@@ -1082,6 +1122,7 @@ def validate_params(allowed: dict, actual: dict) -> bool | None:
             return True
     return None
 
+
 def bool2str(state: bool) -> str:
     """
     Converts a boolean value to '1' if True, and '0' if False...
@@ -1089,4 +1130,4 @@ def bool2str(state: bool) -> str:
     """
     if state:
         return '1'
-    return '0'
+    return '0'

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/mailbox_org_api/APIError.py

@@ -1,4 +1,5 @@
 class APIError(Exception):
     """Custom exception for API errors."""
+
     def __init__(self, message, code=None):
-        super().__init__(f'Error {code} - {message}')
+        super().__init__(f'Error {code} - {message}')

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/mailbox_org_api/Invoice.py

@@ -80,4 +80,4 @@ class Invoice:
             # Add each attribute to the String.
             # As the attribute name is '_attribute', remove the leading character
             print_string += f'{k[1:]}: {v}\n'
-        return print_string
+        return print_string

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/mailbox_org_api.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mailbox-org-api
-Version: 2.2
-Summary: A library to access the mailbox.org Business API.
+Version: 2.4
+Summary: A library to access the mailbox Business API.
 Author: Hendrik Schlange
 Author-email: Hendrik Schlange <mail@heshsum.de>
 Project-URL: Homepage, https://github.com/heshsum/mailbox-org-api
@@ -36,11 +36,15 @@ pip install mailbox-org-api
 pip install git+https://github.com/heshsum/mailbox-org-api
 ```
 
-## Usage
+## Usage and documentation
 Basic usage is fairly straightforward. The naming scheme of the functions is similar to the naming at mailbox.org,
-but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).  
+but instead of points, it uses underscores (e.g. instead of `mail.add` it's `mail_add`).
+
+Therefore, the functions mirror the functions as provided and documented at mailbox: 
+[api.mailbox.org](https://api.mailbox.org)
+
 Additionally, some helper functions for common or more complicated tasks are included to make life a bit easier, 
-e.g. for changing plans, password and to retrieve invoices.  
+e.g. for changing plans, password and to retrieving invoices.
 
 ```python
 from mailbox_org_api import APIClient
@@ -87,6 +91,8 @@ api.mail_set_forwards('foo@bar.com', ['forward1@bar.com', 'forward2@bar.com'])
 api.deauth()
 ```
 
+More information can be found in the [Wiki](https://github.com/heshsum/mailbox-org-api/wiki)
+
 ## Common tasks
 mailbox_org_api includes a number of helper functions to make common tasks simpler. These include:
 
@@ -163,21 +169,21 @@ Usage:
 api.account_invoice_get_token('BMBO-1234-24')
 ```
 
-### account_invoice_get_pdf
+### account_invoice_get_file
 Invoices are provided as Based64 encoded gz Strings. This function
 1. takes the invoice ID
 2. retrieves the token for the invoice
 3. gets the binary data
 4. decodes the Base64
 5. decompresses it
-6. returns the bytes of the actual PDF
+6. returns the bytes of the actual invoice file
 
 Usage
 ```python
 invoice_id = 'BMBO-1234-24'
-account_name = 'some_user'
+account_name = 'foo'
 with open(invoice_id + '.pdf', 'w') as file:
-    file.write(api.account_invoice_get_pdf(account_name, invoice_id))
+    file.write(api.account_invoice_get_file(account_name, invoice_id, 'PDF'))
 ```
 
 ## Here be dragons

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "mailbox-org-api"
-version = "2.2"
+version = "2.4"
 authors = [
   { name="Hendrik Schlange", email="mail@heshsum.de" },
 ]
-description = "A library to access the mailbox.org Business API."
+description = "A library to access the mailbox Business API."
 readme = "README.md"
 requires-python = ">=3.11"
 classifiers = [

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/setup.py

@@ -3,8 +3,8 @@ from setuptools import find_packages, setup
 setup(
     name='mailbox_org_api',
     packages=find_packages(),
-    version='2.2',
-    description='A library to access the mailbox.org Business API',
+    version='2.4',
+    description='A library to access the mailbox Business API',
     author='Hendrik Schlange',
     install_requires=['requests'],
     tests_require=['pytest'],

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/tests/TestAPIClient.py

@@ -1,19 +1,23 @@
-from mailbox_org_api import APIClient
-from mailbox_org_api.APIError import APIError
-import pytest
 import os
-import time
 import secrets
 import string
+import time
+
+import pytest
+
+from mailbox_org_api import APIClient
+from mailbox_org_api.APIError import APIError
 
 api_test_user = os.environ['API_TEST_USER']
 api_test_pass = os.environ['API_TEST_PASS']
 
+
 # Create a unique ID String by using the Unix time,
 # converted to int (to get rid of the decimal) and then to String
 def generate_id():
     return str(int(time.time()))
 
+
 def generate_pw():
     # Length of password
     length = 42
@@ -36,6 +40,7 @@ def generate_pw():
                 any(c in special for c in pw)):
             return pw
 
+
 def get_domain():
     api = APIClient.APIClient()
     api.auth(api_test_user, api_test_pass)
@@ -43,16 +48,18 @@ def get_domain():
     api.deauth()
     return domain
 
+
 test_id = generate_id()
 domain = get_domain()
 
+
 class TestAPIClient:
     def test_validate_params(self):
         allowed = {'string': str}
         with pytest.raises(ValueError):
-            APIClient.validate_params(allowed, {'integer':123})
+            APIClient.validate_params(allowed, {'integer': 123})
         with pytest.raises(TypeError):
-            APIClient.validate_params(allowed, {'string':123})
+            APIClient.validate_params(allowed, {'string': 123})
 
     def test_headers(self):
         api = APIClient.APIClient()
@@ -195,7 +202,7 @@ class TestAPIClient:
         api.auth(api_test_user, api_test_pass)
         invoice = api.account_invoice_get_list(api_test_user)[0]
         token = api.account_invoice_get_token(api_test_user, invoice_id=invoice)
-        assert len(token) >0
+        assert len(token) > 0
         assert isinstance(token, str)
         api.deauth()
 
@@ -210,6 +217,16 @@ class TestAPIClient:
             assert isinstance(d['count_mails'], int)
         api.deauth()
 
+    def test_domain_get_list(self):
+        api = APIClient.APIClient()
+        api.auth(api_test_user, api_test_pass)
+        domain_names = api.domain_get_list(api_test_user)
+        domains = api.domain_list(api_test_user)
+        assert len(domain_names) == len(domains)
+        for d in domains:
+            assert d['domain'] in domain_names
+        api.deauth()
+
     def test_domain_get(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -257,13 +274,24 @@ class TestAPIClient:
         assert paginated_mails['totalPages'] is not None
         assert paginated_mails['results'] is not None
         with pytest.raises(APIError):
-            api.mail_list(domain, page = 2)
+            api.mail_list(domain, page=2)
         with pytest.raises(APIError):
             api.mail_list(domain, page_size=-1)
         with pytest.raises(ValueError):
             api.mail_list(domain, sort_order='wröng')
         api.deauth()
 
+    def test_mail_get_list(self):
+        api = APIClient.APIClient()
+        api.auth(api_test_user, api_test_pass)
+        mails = api.mail_list(domain)
+        mail_addresses = api.mail_get_list(domain)
+        assert len(mail_addresses) == len(mails)
+        for i in mails:
+            assert i['mail'] is not None
+            assert i['mail'] in mail_addresses
+        api.deauth()
+
     def test_mail_get(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -318,8 +346,8 @@ class TestAPIClient:
                           'aliases': [test_id + '_alias@' + domain], 'alternate_mail': test_id + '_alternate@' + domain,
                           'memo': 'memo_string', 'active': True, 'title': 'Title', 'position': 'Job Position',
                           'department': 'Department', 'company': 'Company', 'street': 'Street 1',
-                          'postal_code': '12345', 'city': 'City', 'phone':'+492345678', 'fax':'+492345678',
-                          'cell_phone':'+492345678', 'uid_extern': 'external_uid_value', 'language': 'de_DE'}
+                          'postal_code': '12345', 'city': 'City', 'phone': '+492345678', 'fax': '+492345678',
+                          'cell_phone': '+492345678', 'uid_extern': 'external_uid_value', 'language': 'de_DE'}
 
         # Adding parameters to call
         params = {}
@@ -340,7 +368,7 @@ class TestAPIClient:
             api.mail_set(mail, additional_cloud_quota=5)
 
         with pytest.raises(KeyError):
-            api.mail_set(mail, additional_mail_quota = 5, additional_cloud_quota=5)
+            api.mail_set(mail, additional_mail_quota=5, additional_cloud_quota=5)
 
         api.deauth()
 

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/tests/TestAccount.py

@@ -2,6 +2,7 @@ from mailbox_org_api import Account
 
 account_name = 'heiner.hansen'
 
+
 class TestAccount:
     def test_account(self):
         account = Account.Account(account_name)
@@ -80,8 +81,8 @@ class TestAccount:
     def test_account_contact(self):
         account = Account.Account(account_name)
         assert account.contact == {}
-        contact = {'mail':'contact@tests.internal', 'first_name': 'Test', 'last_name': 'Contact', 'birthday': '',
-                   'street':'Teststr. 1', 'zipcode':'12345', 'town':'Testtown', 'country':'DE'}
+        contact = {'mail': 'contact@tests.internal', 'first_name': 'Test', 'last_name': 'Contact', 'birthday': '',
+                   'street': 'Teststr. 1', 'zipcode': '12345', 'town': 'Testtown', 'country': 'DE'}
         account.contact = contact
         assert account.contact == contact
 

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/tests/TestInvoice.py

@@ -3,6 +3,7 @@ from mailbox_org_api import Invoice
 test_account = 'test_account'
 test_id = 'BMBO-1234-2025'
 
+
 class TestMail:
 
     def test_invoice_create(self):
@@ -43,4 +44,4 @@ class TestMail:
         assert invoice.token is None
         token = '123456789'
         invoice.token = token
-        assert invoice.token == token
+        assert invoice.token == token

{mailbox_org_api-2.2 → mailbox_org_api-2.4}/tests/TestMail.py

@@ -1,8 +1,10 @@
-from mailbox_org_api import Mail
 import unittest
 
+from mailbox_org_api import Mail
+
 mail_address = 'tests@tests.tests'
 
+
 class TestMail(unittest.TestCase):
 
     def test_init(self):