Merge pull request #8 from hadpro24/dev

remove python3.6 support

Author: hadpro24

.github/workflows/pylint.yml

@@ -0,0 +1,26 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint flake8 pytest coverage
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Analysing the code with pylint and flake8
+      run: |
+        pylint $(git ls-files '*.py')
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

examples/code_usage.py

@@ -1,3 +1,10 @@
+"""
+Module example code usage:
+
+Ce module fournit les fonctions nécessaires
+pour envoyer des SMS via l'api Nimba SMS avec le SDK python.
+"""
+
 import os
 import logging
 
@@ -6,84 +13,96 @@
 ACCOUNT_SID = os.environ.get('NIMBA_ACCOUNT_SID')
 AUTH_TOKEN = os.environ.get('NIMBA_AUTH_TOKEN')
 
+client = Client(ACCOUNT_SID, AUTH_TOKEN)
+logging.basicConfig()
+logging.basicConfig(filename='./log.txt') # or loging in file
+client.http_client.logger.setLevel(logging.INFO)
 
-def example():
+def check_balance():
     """
-    Some example usage of NIMBA SMS API with python client
+    Check balance sms
     """
-    client = Client(ACCOUNT_SID, AUTH_TOKEN)
-    logging.basicConfig()
-    logging.basicConfig(filename='./log.txt') # or loging in file
-    client.http_client.logger.setLevel(logging.INFO)
-
-    # Get your account balance
     response = client.accounts.get()
     if response.ok:
         my_account = response.data
-        print('My Account balance : {}'.format(my_account['balance']))
+        print(f"My Account balance : {my_account['balance']}")
 
 
-    # Get groups
+def get_groups():
+    """
+    get groups list
+    """
     response = client.groups.list()
     if response.ok:
         all_groups = response.data
-        print('There are {} groupes'.format(len(all_messages)))
+        print(f'There are {len(all_groups)} groupes')
 
 
-    # Get Sendernames
+def get_sendernames():
+    """
+    Get sendername validated
+    """
     response = client.sendernames.list()
     if response.ok:
         all_sendernames = response.data
         for item in all_sendernames:
             print(item)
 
 
-    # Get Contact
+def add_contact():
+    """
+    process contact added
+    """
     response = client.contacts.list()
     if response.ok:
         all_contacts = response.data
         for item in all_contacts:
             print(item)
 
-
-    # Create Contact
     # This contact will be added to the default contact list
     response = client.contacts.create(numero='224XXXXXXXXX')
     if response.ok:
-        contact = response.data
+        print(response.data)
     # Create with groups and name - name and groups are optional.
-    response = client.contacts.create(numero='224XXXXXXXXX', name='Foo', groups=['API', 'Facebook Client'])
+    response = client.contacts.create(
+        numero='224XXXXXXXXX', name='Foo', groups=['API', 'Facebook Client'])
     if response.ok:
-        contact = response.data
+        print(response.data)
 
 
-    # Get All messages
+def send_message():
+    """
+    Send message
+    """
     response = client.messages.list()
     if response.ok:
         all_messages = response.data
-        print('There are {} messages in your account.'.format(len(all_messages)))
+        print(f'There are {len(all_messages)} messages in your account.')
 
     # Get only last 10 messages
     response = client.messages.list(limit=10)
     if response.ok:
         some_messages = some_messages.data
         print('Here are the last 10 messages in your account:')
-        for m in some_messages:
-            print(m)
+        for message in some_messages:
+            print(message)
 
     # send message...
     print('Sending a message...')
     response = client.messages.create(to=['XXXX'],
                 sender_name='YYYY', message='Hi Nimba!')
     if response.ok:
-        print('message response : {}'.format(response.data))
-
+        print(f'message response : {response.data}')
 
     # Retrieve message
     response = client.messages.retrieve(messageid='XXXXXXXXXXXXXXXXXXXXX')
     if response.ok:
-        print("Message retrieve : {}".format(response.data))
+        print(f"Message retrieve : {response.data}")
 
 
-def __name__ == '__main__':
-    exemple()
+if __name__ == '__main__':
+    check_balance()
+    get_groups()
+    get_sendernames()
+    add_contact()
+    send_message()

nimbasms/__init__.py

@@ -1,17 +1,39 @@
+"""
+A Nimba SMS Client API.
+
+This module contains Class Client manager services available in API : developers.nimbasms.com
+
+Dependencies
+-----------
+requests : A library for HTTP Request
+
+class
+---------
+HTTPClient : Abstract class representing HTTP Client
+Response: Response representing data output.
+Client : Manager all services APIs.
+"""
+
 import logging
 import platform
 import json
 
+from urllib.parse import urlencode
 from requests import Request, Session, hooks
 from requests.adapters import HTTPAdapter
-from urllib.parse import urlencode
-from nimbasms.execptions import NimbaException
+from nimbasms.execptions import NimbaSMSException
+
+from nimbasms.rest import Accounts
+from nimbasms.rest import Contacts
+from nimbasms.rest import Groups
+from nimbasms.rest import Messages
+from nimbasms.rest import SenderNames
 
 __version__ = '1.0.0'
 
 _logger = logging.getLogger('nimbasms')
 
-class HttpClient(object):
+class HttpClient:
     """
     An Abstract class representing an HTTP client.
     """
@@ -23,7 +45,10 @@ def request(self, method, url, params=None, data=None, headers=None,
         raise NimbaSMSException('HttpClient is a an abstract class')
 
 
-class Response(object):
+class Response:
+    """
+    Representing data output API calls.
+    """
     def __init__(self, status_code, text, headers=None):
         self.content = text
         self.headers = headers
@@ -33,14 +58,20 @@ def __init__(self, status_code, text, headers=None):
 
     @property
     def text(self):
+        """
+        Content output byte
+        """
         return self.content
 
     @property
     def data(self):
+        """
+        Output data response APIs
+        """
         return json.loads(self.content)
 
     def __repr__(self):
-        return 'HTTP {} {}'.format(self.status_code, self.content)
+        return f'HTTP {self.status_code} {self.content}'
 
 
 class NimbaHttpClient(HttpClient):
@@ -120,31 +151,33 @@ def request(self, method, url, params=None, data=None, headers=None,
         return self.last_response
 
     def _log_request(self, kwargs):
+        """
+        Logger request APIs
+        """
         self.logger.info('-- BEGIN Nimba SMS API Request --')
 
         if kwargs['params']:
-            self.logger.info('{} Request: {}?{}'.format(kwargs['method'],
-                                kwargs['url'], urlencode(kwargs['params'])))
-            self.logger.info('Query Params: {}'.format(kwargs['params']))
+            self.logger.info(
+                f"{kwargs['method']} Request: {kwargs['url']}?{urlencode(kwargs['params'])}")
+            self.logger.info(f"Query Params: {kwargs['params']}")
         else:
-            self.logger.info('{} Request: {}'.format(kwargs['method'],
-                                kwargs['url']))
+            self.logger.info(f"{kwargs['method']} Request: {kwargs['url']}")
 
         if kwargs['headers']:
             self.logger.info('Headers:')
             for key, value in kwargs['headers'].items():
                 #Do not log authorization headers
                 if 'authorization' not in key.lower():
-                    self.logger.info('{} : {}'.format(key, value))
+                    self.logger.info(f'{key} : {value}')
 
         self.logger.info('-- END Nimba SMS API Request --')
 
     def _log_response(self, response):
-        self.logger.info('Response Status Code: {}'.format(response.status_code))
-        self.logger.info('Response Headers: {}'.format(response.headers))
+        self.logger.info(f'Response Status Code: {response.status_code}')
+        self.logger.info(f'Response Headers: {response.headers}')
 
 
-class Client(object):
+class Client:
     """A client for accessing the Nimba SMS API."""
 
     def __init__(self, account_sid=None, access_token=None):
@@ -154,13 +187,10 @@ def __init__(self, account_sid=None, access_token=None):
         :param str account_sid: Account SID
         :param str access_token: Token authenticate
         """
-        self.account_sid = account_sid
-        self.access_token = access_token
-
-        if not self.account_sid or not self.access_token:
-            raise NimbaException("Credentials are required"
+        if not account_sid or not access_token:
+            raise NimbaSMSException("Credentials are required"
                     " to create a NimbaClient")
-        self.auth = (self.account_sid, self.access_token)
+        self.auth = (account_sid, access_token)
 
         self.http_client = NimbaHttpClient()
 
@@ -193,12 +223,8 @@ def request(self, method, uri, params=None, data=None,
         os_name = platform.system()
         os_arch = platform.machine()
         python_version = platform.python_version()
-        headers['User-Agent'] = 'nimba-python/{} ({} {}) Python/{}'.format(
-            pkg_version,
-            os_name,
-            os_arch,
-            python_version
-        )
+        headers['User-Agent'] = (
+            f'nimba-python/{pkg_version} ({os_name} {os_arch}) Python/{python_version}')
         headers['X-Nimba-Client'] = 'utf-8'
 
         if method == 'POST' and 'Content-Type' not in headers:
@@ -225,7 +251,6 @@ def accounts(self):
         :returns Accounts
         """
         if self._accounts is None:
-            from nimbasms.rest import Accounts
             self._accounts = Accounts(self)
         return self._accounts
 
@@ -237,7 +262,6 @@ def messages(self):
         :returns Messages NimbaAPI
         """
         if self._messages is None:
-            from nimbasms.rest import Messages
             self._messages = Messages(self)
         return self._messages
 
@@ -249,30 +273,27 @@ def contacts(self):
         :returns Contacts NimbaAPI
         """
         if self._contacts is None:
-            from nimbasms.rest import Contacts
             self._contacts = Contacts(self)
         return self._contacts
 
     @property
     def groups(self):
         """
-        Group Accounts
-        
+        Group Accounts.
+
         :returns Groups NimbaAPI
         """
         if self._groups is None:
-            from nimbasms.rest import Groups
             self._groups = Groups(self)
         return self._groups
 
     @property
     def sendernames(self):
         """
-        Sendername Accounts
-        
+        Sendername Accounts.
+
         :returns Sendername NimbaAPI
         """
         if self._sendernames is None:
-            from nimbasms.rest import SenderNames
             self._sendernames = SenderNames(self)
         return self._sendernames

nimbasms/execptions.py

@@ -1,2 +1,8 @@
-class NimbaException(Exception):
-    pass
+"""
+Exception module for this project.
+"""
+
+class NimbaSMSException(Exception):
+    """
+    Module exception for project
+    """