Merge pull request #250 from microsoftgraph/beta/pipelinebuild/127655

Generated beta models and request builders

Author: samwelkanda

.github/workflows/build_publish.yml

@@ -25,7 +25,7 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r requirements-dev.txt
     - name: Lint with Pylint
-      run: pylint msgraph --disable=W --rcfile=.pylintrc
+      run: pylint msgraph_beta --disable=W --rcfile=.pylintrc
 
   deploy:
     name: Publish distribution to PyPI

.pylintrc

@@ -81,6 +81,7 @@ disable=long-suffix,
         R0801,
         R0904,
         line-too-long,
+        import-outside-toplevel,
 
 
 # Enable the message, report, category or checker with the given id(s). You can

CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0rc0] - 2023-10-27
+
+### Added
+- Added request translation method to native request object
+- Added opentelemetry to support observability.
+- Added support for continous access evaluation.
+- Added backing store support and enabled backing store by default.
+
+
+### Changed
+- Refactored request headers from dictionary to HeaderCollection class.
+- Fix issue with using raw url in request builder due to incorrect parameter order.
+- Switched from uritemplate to std-uritemplate for URI templating.
+- Simplified the creation of a graph client.
+
+
+## [1.0.0a8] - 2023-04-25
+
+### Added
+
+### Changed
+
+- Changed the request builders api to include indexers as part of the path. [#2528](https://github.com/microsoft/kiota/issues/2528)
+
 ## [1.0.0a8] - 2023-04-25
 
 ### Added

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())