Update docs to latest changes

Author: samwelkanda

README.md

@@ -18,52 +18,22 @@ pip install msgraph-beta-sdk
 
 Register your application by following the steps at [Register your app with the Microsoft Identity Platform](https://docs.microsoft.com/graph/auth-register-app-v2).
 
-### 2.2 Create an AuthenticationProvider object
+### 2.3 Get a GraphServiceClient object
+
+You must get a **GraphServiceClient** object to make requests against the service.
 
-An instance of the **GraphServiceClient** class handles building client. To create a new instance of this class, you need to provide an instance of **AuthenticationProvider**, which can authenticate requests to Microsoft Graph.
+An instance of the **GraphServiceClient** class handles building client. To create a new instance of this class, you need to provide an instance of **Credential**, which can authenticate requests to Microsoft Graph.
 
 > **Note**: For authentication we support both `sync` and `async` credential classes from `azure.identity`. Please see the azure identity [docs](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity?view=azure-python) for more information.
 
 ```py
 # Example using async credentials.
 from azure.identity.aio import EnvironmentCredential
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
+from msgraph_beta import GraphServiceClient
 
 scopes = ['User.Read', 'Mail.Read']
 credential=EnvironmentCredential()
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-```
-
-### 2.3 Initialise a GraphRequestAdapter object
-
-The SDK uses an adapter object that handles the HTTP concerns. This HTTP adapter object is used to build the Graph client for making requests.
-
-To initialise one using the authentication provider created in the previous step:
-
-```py
-from msgraph import GraphRequestAdapter
-
-adapter = GraphRequestAdapter(auth_provider)
-```
-
-We currently use [HTTPX](https://www.python-httpx.org/) as our HTTP client. You can pass your custom configured `httpx.AsyncClient` using:
-
-```py
-from msgraph import GraphRequestAdapter
-from msgraph_core import GraphClientFactory
-
-http_Client = GraphClientFactory.create_with_default_middleware(client=httpx.AsyncClient())
-request_adapter = GraphRequestAdapter(auth_Provider, http_client)
-```
-
-### 2.3 Get a GraphServiceClient object
-
-You must get a **GraphServiceClient** object to make requests against the service.
-
-```py
-from msgraph import GraphServiceClient
-
-client = GraphServiceClient(request_adapter)
+client = GraphServiceClient(credentials, scopes=scopes)
 ```
 
 ## 3. Make requests against the service
@@ -77,25 +47,20 @@ The following is a complete example that shows how to fetch a user from Microsof
 ```py
 import asyncio
 from azure.identity.aio import ClientSecretCredential
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter
-from msgraph import GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 credential = ClientSecretCredential(
     'tenant_id',
     'client_id',
     'client_secret'
 )
 scopes = ['https://graph.microsoft.com/.default']
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-request_adapter = GraphRequestAdapter(auth_provider)
-client = GraphServiceClient(request_adapter)
+client = GraphServiceClient(credential, scopes=scopes)
 
 async def get_user():
     user = await client.users.by_user_id('userPrincipalName').get()
     if user:
       print(user.display_name)
-
 asyncio.run(get_user())
 ```
 
@@ -104,21 +69,16 @@ Note that to calling `me` requires a signed-in user and therefore delegated perm
 ```py
 import asyncio
 from azure.identity import InteractiveBrowserCredential
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter
-from msgraph import GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 credential = InteractiveBrowserCredential()
 scopes=['User.Read']
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-request_adapter = GraphRequestAdapter(auth_provider)
-client = GraphServiceClient(request_adapter)
+client = GraphServiceClient(credential, scopes=scopes)
 
 async def me():
     me = await client.me.get()
     if me:
         print(me.display_name)
-
 asyncio.run(me())
 ```
 
@@ -133,11 +93,8 @@ async def get_user():
         print(user.user_principal_name, user.display_name, user.id)
     except APIError as e:
         print(f'Error: {e.error.message}')
-
 asyncio.run(get_user())
 ```
-
-
 ## Documentation and resources
 
 * [Overview](https://docs.microsoft.com/graph/overview)

docs/applications_samples.md

@@ -4,35 +4,25 @@
 import asyncio
 
 from azure.identity import EnvironmentCredential
-from kiota_abstractions.api_error import APIError
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter
-from msgraph import GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 # Set the event loop policy for Windows
 asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # Create authentication provider object. Used to authenticate request
 credential=EnvironmentCredential()
-auth_provider = AzureIdentityAuthenticationProvider(credential)
-
-# Initialize a request adapter. Handles the HTTP concerns.
-request_adapter = GraphRequestAdapter(auth_provider)
 
 # Get a service client.
-client = GraphServiceClient(request_adapter)
+client = GraphServiceClient(credentials=credential)
 ```
 
 ## 1. LIST ALL APPLICATIONS IN THE TENANT (GET /applications)
 
 ```py
 async def get_applications():
-    try:
-        apps = await client.applications.get()
-        if apps and apps.value:
-            for app in apps.value:
-                print(app.id)
-    except APIError as e:
-        print(e.error.message)
+    apps = await client.applications.get()
+    if apps and apps.value:
+        for app in apps.value:
+            print(app.id)
 asyncio.run(get_applications())
 ```

docs/authentication_samples.md

@@ -6,9 +6,7 @@
 import asyncio
 
 from azure.identity import DeviceCodeCredential
-from kiota_abstractions.api_error import APIError
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter, GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 # Set the event loop policy for Windows
 asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
@@ -20,23 +18,15 @@ credential = DeviceCodeCredential(
     )
 
 scopes = ["User.Read"]
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
 
-# Initialize a request adapter with the auth provider.
-request_adapter = GraphRequestAdapter(auth_provider)
-
-# Create an API client with the request adapter.
-client = GraphServiceClient(request_adapter)
+# Create an API client with the credentials and scopes.
+client = GraphServiceClient(credential, scopes=scopes)
 
 # GET A USER USING THE USER ID (GET /users/{id})
 async def get_user():
-    try:
-        user = await client.users_by_id('USER_ID').get()
-        if user:
-            print(user.user_principal_name, user.display_name, user.id)
-    except APIError as e:
-        print(f'Error: {e.error.message}')
-
+    user = await client.users_by_id('USER_ID').get()
+    if user:
+        print(user.user_principal_name, user.display_name, user.id)
 asyncio.run(get_user())
 ```
 
@@ -45,32 +35,22 @@ asyncio.run(get_user())
 ```py
 import asyncio
 from azure.identity import InteractiveBrowserCredential
-from kiota_abstractions.api_error import APIError
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter, GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 # Set the event loop policy for Windows
 asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # Create authentication provider object. Used to authenticate requests
 credential = InteractiveBrowserCredential()
 scopes = ["User.Read"]
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-
-# Initialize a request adapter with the auth provider.
-request_adapter = GraphRequestAdapter(auth_provider)
-
-# Create an API client with the request adapter.
-client = GraphServiceClient(request_adapter)
+# Create an API client with the credentials and scopes.
+client = GraphServiceClient(credential, scopes=scopes)
 
 # GET A USER USING THE USER ID (GET /users/{id})
 async def get_user():
-    try:
-        user = await client.users_by_id('USER_ID').get()
-        if user:
-            print(user.user_principal_name, user.display_name, user.id)
-    except APIError as e:
-        print(f'Error: {e.error.message}')
+    user = await client.users_by_id('USER_ID').get()
+    if user:
+        print(user.user_principal_name, user.display_name, user.id)
 asyncio.run(get_user())
 ```
 
@@ -82,9 +62,7 @@ asyncio.run(get_user())
 import asyncio
 
 from azure.identity import ClientSecretCredential
-from kiota_abstractions.api_error import APIError
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter, GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 # Set the event loop policy for Windows
 asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) 
@@ -96,22 +74,15 @@ credential = ClientSecretCredential(
     client_secret='CLIENT_SECRET'
 )
 scopes = ['https://graph.microsoft.com/.default']
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-
-# Initialize a request adapter with the auth provider.
-request_adapter = GraphRequestAdapter(auth_provider)
 
-# Create an API client with the request adapter.
-client = GraphServiceClient(request_adapter)
+# Create an API client with the credentials and scopes.
+client = GraphServiceClient(credential, scopes=scopes)
 
 # GET A USER USING THE USER ID (GET /users/{id})
 async def get_user():
-    try:
-        user = await client.users.by_user_id('USER_ID').get()
-        if user:
-            print(user.user_principal_name, user.display_name, user.id)
-    except APIError as e:
-        print(f'Error: {e.error.message}')
+    user = await client.users.by_user_id('USER_ID').get()
+    if user:
+        print(user.user_principal_name, user.display_name, user.id)
 asyncio.run(get_user())
 ```
 
@@ -121,31 +92,22 @@ asyncio.run(get_user())
 import asyncio
 
 from azure.identity.aio import EnvironmentCredential
-from kiota_abstractions.api_error import APIError
-from kiota_authentication_azure.azure_identity_authentication_provider import AzureIdentityAuthenticationProvider
-from msgraph import GraphRequestAdapter, GraphServiceClient
+from msgraph_beta import GraphServiceClient
 
 # Set the event loop policy for Windows
 asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 # Create authentication provider object. Used to authenticate request
 credential = EnvironmentCredential()
 scopes = ['https://graph.microsoft.com/.default']
-auth_provider = AzureIdentityAuthenticationProvider(credential, scopes=scopes)
-
-# Initialize a request adapter with the auth provider.
-request_adapter = GraphRequestAdapter(auth_provider)
 
-# Create an API client with the request adapter.
-client = GraphServiceClient(request_adapter)
+# Create an API client with the credentials and scopes.
+client = GraphServiceClient(credential, scopes=scopes)
 
 # GET A USER USING THE USER ID (GET /users/{id})
 async def get_user():
-    try:
-        user = await client.users.by_user_id('USER_ID').get()
-        if user:
-            print(user.user_principal_name, user.display_name, user.id)
-    except APIError as e:
-        print(f'Error: {e.error.message}')
+    user = await client.users.by_user_id('USER_ID').get()
+    if user:
+        print(user.user_principal_name, user.display_name, user.id)
 
 asyncio.run(get_user())