Fix/post requests

dev_requirements.txt

@@ -1,4 +1,5 @@
 coverage==5.0.3
 pylint==2.4.4
 responses==0.10.12
-flit==2.2.0
+flit==2.2.0
+azure-identity==1.3.1

msgraphcore/constants.py

@@ -6,5 +6,5 @@
 BASE_URL = 'https://graph.microsoft.com/v1.0'
 SDK_VERSION = '0.0.1-0'
 
-# MiddlewareOptions
+# Used as the key for AuthMiddlewareOption in MiddlewareControl
 AUTH_MIDDLEWARE_OPTIONS = 'AUTH_MIDDLEWARE_OPTIONS'

msgraphcore/graph_session.py

@@ -1,17 +1,22 @@
 """
 Graph Session
 """
-from requests import Session, Request, Response
+
+from requests import Session
 
 from msgraphcore.constants import BASE_URL, SDK_VERSION
 from msgraphcore.middleware._middleware import MiddlewarePipeline, BaseMiddleware
 from msgraphcore.middleware._base_auth import AuthProviderBase
 from msgraphcore.middleware.authorization import AuthorizationHandler
+from msgraphcore.middleware.options.middleware_control import middleware_control
 
 
 class GraphSession(Session):
-    """
-    Extends session object with graph functionality
+    """Extends Session with Graph functionality
+
+    Extends Session by adding support for middleware options and middleware pipeline
+
+
     """
     def __init__(self, auth_provider: AuthProviderBase, middleware: list = []):
         super().__init__()
@@ -20,47 +25,84 @@ def __init__(self, auth_provider: AuthProviderBase, middleware: list = []):
 
         auth_handler = AuthorizationHandler(auth_provider)
 
+        # The authorization handler should be the first middleware in the pipeline.
         middleware.insert(0, auth_handler)
         self._register(middleware)
 
-    def get(self, url: str, **kwargs) -> Response:
-        return self._prepare_and_send_request('GET', url, **kwargs)
-
-    def post(self, url: str, **kwargs) -> Response:
-        return self._prepare_and_send_request('POST', url, **kwargs)
-
-    def put(self, url: str, **kwargs) -> Response:
-        return self._prepare_and_send_request('PUT', url, **kwargs)
-
-    def patch(self, url: str, **kwargs) -> Response:
-        return self._prepare_and_send_request('PATCH', url, **kwargs)
-
-    def delete(self, url: str, **kwargs) -> Response:
-        return self._prepare_and_send_request('DELETE', url, **kwargs)
-
-    def _get_url(self, url: str) -> Response:
+    @middleware_control.get_middleware_options
+    def get(self, url: str, **kwargs):
+        r"""Sends a GET request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+        return super().get(self._graph_url(url))
+
+    @middleware_control.get_middleware_options
+    def post(self, url, data=None, json=None, **kwargs):
+        r"""Sends a POST request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param json: (optional) json to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+        return super().post(self._graph_url(url), data, json, **kwargs)
+
+    @middleware_control.get_middleware_options
+    def put(self, url, data=None, **kwargs):
+        r"""Sends a PUT request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+        return super().put(self._graph_url(url), data, **kwargs)
+
+    @middleware_control.get_middleware_options
+    def patch(self, url, data=None, **kwargs):
+        r"""Sends a PATCH request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+        return super().patch(self._graph_url(url), data, **kwargs)
+
+    @middleware_control.get_middleware_options
+    def delete(self, url, **kwargs):
+        r"""Sends a DELETE request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        :rtype: requests.Response
+        """
+        return super().delete(url, **kwargs)
+
+    def _graph_url(self, url: str) -> str:
+        """Appends BASE_URL to user provided path
+
+        :param url: user provided path
+        :return: graph_url
+        """
         return self._base_url+url if (url[0] == '/') else url
 
     def _register(self, middleware: [BaseMiddleware]) -> None:
+        """Adds middleware to middleware_pipeline
+
+        :param middleware: list of middleware
+        """
         if middleware:
-            middleware_adapter = MiddlewarePipeline()
+            middleware_pipeline = MiddlewarePipeline()
 
             for ware in middleware:
-                middleware_adapter.add_middleware(ware)
-
-            self.mount('https://', middleware_adapter)
-
-    def _prepare_and_send_request(self, method: str = '', url: str = '', **kwargs) -> Response:
-        # Retrieve middleware options
-        list_of_scopes = kwargs.pop('scopes', None)
-
-        # Prepare request
-        request_url = self._get_url(url)
-        request = Request(method, request_url, kwargs)
-        prepared_request = self.prepare_request(request)
-
-        if list_of_scopes is not None:
-            # Append middleware options to the request object, will be used by MiddlewareController
-            prepared_request.scopes = list_of_scopes
+                middleware_pipeline.add_middleware(ware)
 
-        return self.send(prepared_request, **kwargs)
+            self.mount('https://', middleware_pipeline)

msgraphcore/middleware/_middleware.py

@@ -3,12 +3,13 @@
 from requests.adapters import HTTPAdapter
 from urllib3 import PoolManager
 
-from .options.auth_middleware_options import AuthMiddlewareOptions
-from .options.middleware_control import MiddlewareControl
-from ..constants import AUTH_MIDDLEWARE_OPTIONS
-
 
 class MiddlewarePipeline(HTTPAdapter):
+    """MiddlewarePipeline, entry point of middleware
+
+    The pipeline is implemented as a linked-list, read more about
+    it here https://buffered.dev/middleware-python-requests/
+    """
     def __init__(self):
         super().__init__()
         self._middleware = None
@@ -21,31 +22,22 @@ def add_middleware(self, middleware):
             self._middleware = middleware
 
     def send(self, request, **kwargs):
-        args = self._attach_middleware_control(request, **kwargs)
-
         if self._middleware_present():
-            return self._middleware.send(request, **args)
+            return self._middleware.send(request, **kwargs)
         # No middleware in pipeline, call superclass' send
-        return super().send(request, **args)
-
-    def _attach_middleware_control(self, request, **kwargs):
-        request.middleware_control = MiddlewareControl()
-
-        try:
-            scopes = request.scopes
-            auth_middleware_options = AuthMiddlewareOptions(scopes)
-            request.middleware_control.set(AUTH_MIDDLEWARE_OPTIONS, auth_middleware_options)
-        except KeyError:
-            # do nothing for now
-            pass
-        finally:
-            return kwargs
+        return super().send(request, **kwargs)
 
     def _middleware_present(self):
         return self._middleware
 
 
 class BaseMiddleware(HTTPAdapter):
+    """Base class for middleware
+
+    Handles moving a Request to the next middleware in the pipeline.
+    If the current middleware is the last one in the pipeline, it
+    makes a network request
+    """
     def __init__(self):
         super().__init__()
         self.next = None

msgraphcore/middleware/authorization.py

@@ -1,6 +1,7 @@
 from ._base_auth import AuthProviderBase, TokenCredential
 from ..constants import AUTH_MIDDLEWARE_OPTIONS
 from ._middleware import BaseMiddleware
+from .options.middleware_control import middleware_control
 
 
 class AuthorizationHandler(BaseMiddleware):
@@ -10,22 +11,25 @@ def __init__(self, auth_provider: AuthProviderBase):
         self.retry_count = 0
 
     def send(self, request, **kwargs):
-        options = self._get_middleware_options(request)
+        # Checks if there are any options for this middleware
+        options = self._get_middleware_options()
+        # If there is, get the scopes from the options
         if options:
             self.auth_provider.scopes = options.scopes
 
         token = self.auth_provider.get_access_token()
         request.headers.update({'Authorization': 'Bearer {}'.format(token)})
         response = super().send(request, **kwargs)
 
+        # Token might have expired just before transmission, retry the request
         if response.status_code == 401 and self.retry_count < 2:
             self.retry_count += 1
             return self.send(request, **kwargs)
 
         return response
 
-    def _get_middleware_options(self, request):
-        return request.middleware_control.get(AUTH_MIDDLEWARE_OPTIONS)
+    def _get_middleware_options(self):
+        return middleware_control.get(AUTH_MIDDLEWARE_OPTIONS)
 
 
 class TokenCredentialAuthProvider(AuthProviderBase):

msgraphcore/middleware/options/auth_middleware_options.py

@@ -1,5 +1,4 @@
 
 class AuthMiddlewareOptions:
-    def __init__(self, scopes: str):
+    def __init__(self, scopes: [str]):
         self.scopes = scopes
-

msgraphcore/middleware/options/middleware_control.py

@@ -1,3 +1,7 @@
+from msgraphcore.constants import AUTH_MIDDLEWARE_OPTIONS
+from ..options.auth_middleware_options import AuthMiddlewareOptions
+
+
 class MiddlewareControl:
     def __init__(self):
         self.middleware_options = {}
@@ -7,3 +11,22 @@ def set(self, middleware_option_name, middleware_option):
 
     def get(self, middleware_option_name):
         return self.middleware_options.get(middleware_option_name, None)
+
+    def get_middleware_options(self, func):
+        self._reset_middleware_options()
+
+        def wrapper(*args, **kwargs):
+            # Get middleware options from **kwargs
+            scopes = kwargs.pop('scopes', None)
+            if scopes:
+                # Set middleware options, for use by middleware in the middleware pipeline
+                self.set(AUTH_MIDDLEWARE_OPTIONS, AuthMiddlewareOptions(scopes))
+            return func(*args, **kwargs)
+        return wrapper
+
+    def _reset_middleware_options(self):
+        # Reset middleware, so that they are not persisted across requests
+        self.middleware_options = {}
+
+
+middleware_control = MiddlewareControl()

samples/samples.py

@@ -0,0 +1,48 @@
+import json
+from pprint import pprint
+
+from azure.identity import InteractiveBrowserCredential
+from msgraphcore.middleware.authorization import TokenCredentialAuthProvider
+
+from msgraphcore import GraphSession
+
+browser_credential = InteractiveBrowserCredential(client_id='ENTER_YOUR_CLIENT_ID')
+auth_provider = TokenCredentialAuthProvider(browser_credential)
+graph_session = GraphSession(auth_provider)
+
+
+def post_sample():
+    body = {
+        'message': {
+            'subject': 'Python SDK Meet for lunch?',
+            'body': {
+                'contentType': 'Text',
+                'content': 'The new cafeteria is open.'
+            },
+            'toRecipients': [
+                {
+                    'emailAddress': {
+                        'address': 'ENTER_RECEPIENT_EMAIL_ADDRESS'
+                    }
+                }
+            ]}
+    }
+
+    result = graph_session \
+        .post('/me/sendMail',
+              data=json.dumps(body),
+              scopes=['mail.send'],
+              headers={'Content-Type': 'application/json'}
+              )
+    pprint(result.status_code)
+
+
+def get_sample():
+    result = graph_session.get('/me/messages', scopes=['mail.read'])
+    pprint(result.json())
+
+
+if __name__ == '__main__':
+    post_sample()
+    get_sample()
+