Office365-REST-Python-Client 2.5.14__py3-none-any.whl → 2.6.1__py3-none-any.whl

office365/directory/rolemanagement/role_permission.py

@@ -4,7 +4,7 @@ from office365.runtime.client_value_collection import ClientValueCollection
 
 
 class RolePermission(ClientValue):
-    """ """
+    """Contains the set of ResourceActions determining the allowed and not allowed permissions for each role."""
 
-    def __init__(self, resourceActions=None):
-        self.resourceActions = ClientValueCollection(ResourceAction, resourceActions)
+    def __init__(self, resource_actions=None):
+        self.resourceActions = ClientValueCollection(ResourceAction, resource_actions)

office365/directory/security/alerts/collection.py

@@ -0,0 +1,49 @@
+from office365.directory.security.alerts.alert import Alert
+from office365.entity_collection import EntityCollection
+from office365.runtime.http.request_options import RequestOptions
+
+
+class AlertCollection(EntityCollection[Alert]):
+    """Service Principal's collection"""
+
+    def __init__(self, context, resource_path=None):
+        super(AlertCollection, self).__init__(context, Alert, resource_path)
+
+    def add(
+        self,
+        title,
+        description=None,
+        severity=None,
+        category=None,
+        status=None,
+        source=None,
+        vendor_information=None,
+    ):
+        """
+        Creates an alert object.
+        :param str title:
+        :param str description:
+        :param str severity:
+        :param str category:
+        :param str status:
+        :param str source:
+        :param str vendor_information:
+        """
+
+        def _construct_request(request):
+            # type: (RequestOptions) -> None
+            request.set_header("Content-Type", "application/json")
+
+        return (
+            super(AlertCollection, self)
+            .add(
+                title=title,
+                description=description,
+                severity=severity,
+                category=category,
+                status=status,
+                source=source,
+                vendorInformation=vendor_information,
+            )
+            .before_execute(_construct_request)
+        )

office365/directory/security/scorecontrol/profile.py

@@ -0,0 +1,6 @@
+from office365.entity import Entity
+
+
+class SecureScoreControlProfile(Entity):
+    """Represents a tenant's secure score per control data. By default, it returns all controls
+    for a tenant and can explicitly pull individual controls."""

office365/directory/security/security.py

@@ -1,8 +1,10 @@
 from office365.directory.security.alerts.alert import Alert
+from office365.directory.security.alerts.collection import AlertCollection
 from office365.directory.security.attacksimulations.root import AttackSimulationRoot
 from office365.directory.security.cases.root import CasesRoot
 from office365.directory.security.hunting_query_results import HuntingQueryResults
 from office365.directory.security.incidents.incident import Incident
+from office365.directory.security.scorecontrol.profile import SecureScoreControlProfile
 from office365.directory.security.threatintelligence.threat_intelligence import (
     ThreatIntelligence,
 )
@@ -35,12 +37,10 @@ class Security(Entity):
 
     @property
     def alerts(self):
-        # type: () -> EntityCollection[Alert]
+        # type: () -> AlertCollection
         return self.properties.get(
             "alerts",
-            EntityCollection(
-                self.context, Alert, ResourcePath("alerts", self.resource_path)
-            ),
+            AlertCollection(self.context, ResourcePath("alerts", self.resource_path)),
         )
 
     @property
@@ -83,6 +83,18 @@ class Security(Entity):
             ),
         )
 
+    @property
+    def secure_score_control_profiles(self):
+        """"""
+        return self.properties.get(
+            "secureScoreControlProfiles",
+            EntityCollection(
+                self.context,
+                SecureScoreControlProfile,
+                ResourcePath("secureScoreControlProfiles", self.resource_path),
+            ),
+        )
+
     @property
     def triggers(self):
         """"""
@@ -106,6 +118,7 @@ class Security(Entity):
             property_mapping = {
                 "alerts_v2": self.alerts_v2,
                 "attackSimulation": self.attack_simulation,
+                "secureScoreControlProfiles": self.secure_score_control_profiles,
                 "threatIntelligence": self.threat_intelligence,
             }
             default_value = property_mapping.get(name, None)

office365/directory/serviceprincipals/service_principal.py

@@ -1,4 +1,3 @@
-from collections.abc import Callable
 from typing import Optional
 
 from typing_extensions import Self
@@ -103,31 +102,20 @@ class ServicePrincipal(DirectoryObject):
         self.context.add_query(qry)
         return return_type
 
-    def _get_service_principal_by_app(self, app, action):
-        # type: (Application|str, Callable[[Application], None]) -> None
-        if isinstance(app, Application):
-
-            def _after():
-                action(app)
-
-            app.ensure_property("id", _after)
-        else:
-            self.context.service_principals.get_by_app(app).get().after_execute(action)
-
     def get_delegated_permissions(self, app, principal=None):
         # type: (Application|str, User|str) -> ClientResult[StringCollection]
         """Gets a delegated API permission"""
 
+        consent_type = "Principal" if principal else "AllPrincipals"
+
         return_type = ClientResult(self.context, StringCollection())
 
         def _get_delegated_permissions(client_id, principal_id=None):
             # type: (str, str) -> None
 
             if principal_id is None:
-                query_text = (
-                    "clientId eq '{0}'  and consentType eq 'AllPrincipals'".format(
-                        client_id
-                    )
+                query_text = "clientId eq '{0}'  and consentType eq '{1}'".format(
+                    client_id, consent_type
                 )
             else:
                 query_text = "principalId eq '{0}' and clientId eq '{1}'".format(
@@ -171,14 +159,16 @@ class ServicePrincipal(DirectoryObject):
         return return_type
 
     def grant_delegated_permissions(self, app, principal, scope):
-        # type: (Application|str, User|str, AppRole|str) -> Self
+        # type: (Application|str, User|str|None, AppRole|str) -> Self
         """Grants a delegated permission to the client service principal on behalf of a user"""
 
+        consent_type = "Principal" if principal else "AllPrincipals"
+
         def _grant_delegated(principal_id, client_id):
             # type: (str, str) -> None
             self.context.oauth2_permission_grants.add(
                 clientId=client_id,
-                consentType="Principal",
+                consentType=consent_type,
                 resourceId=self.id,
                 principalId=principal_id,
                 scope=scope,
@@ -206,34 +196,51 @@ class ServicePrincipal(DirectoryObject):
         self.ensure_property("id", _resource_resolved)
         return self
 
-    def revoke_delegated_permissions(self, app, principal, scope):
+    def revoke_delegated_permissions(self, app, principal=None, scope=None):
         # type: (Application|str, User|str, AppRole|str) -> Self
         """"""
 
-        def _revoke_delegated_permissions(app_id, principal_id):
+        def _revoke_delegated_permissions(principal_id, client_id):
             # type: (str, str) -> None
 
             def _after(return_type):
-                pass
+                if len(return_type) > 0:
+                    return_type[0].delete_object()
+
+            if principal:
+                query_text = "clientId eq '{0}' and principalId eq '{1}' and resourceId eq '{2}'".format(
+                    client_id, principal_id, self.id
+                )
+            else:
+                query_text = "clientId eq '{0}' and consentType eq 'AllPrincipals' and resourceId eq '{1}'".format(
+                    client_id, self.id
+                )
 
-            query_text = "clientId eq '{0}' and principalId eq '{1}'".format(
-                app_id, principal_id
-            )
             self.context.oauth2_permission_grants.filter(
                 query_text
             ).get().after_execute(_after)
 
-        def _ensure_principal(return_type):
+        def _principal_resolved(principal_id):
+            # type: (str) -> None
+            def _client_loaded(return_type):
+                # type: (ServicePrincipal) -> None
+                _revoke_delegated_permissions(principal_id, return_type.id)
+
+            self.context.service_principals.get_by_app(app).get().after_execute(
+                _client_loaded
+            )
+
+        def _resource_resolved():
             if isinstance(principal, User):
 
                 def _after():
-                    _revoke_delegated_permissions(principal.id, return_type.id)
+                    _principal_resolved(principal.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _revoke_delegated_permissions(principal, return_type.id)
+                _principal_resolved(principal)
 
-        self._get_service_principal_by_app(app, _ensure_principal)
+        self.ensure_property("id", _resource_resolved)
         return self
 
     def get_application_permissions(self, app):
@@ -241,6 +248,7 @@ class ServicePrincipal(DirectoryObject):
         return_type = ClientResult(self.context, AppRoleCollection())
 
         def _get_application_permissions(app_id):
+            # type: (str) -> None
             app_role_ids = [
                 app_role.app_role_id
                 for app_role in self.app_role_assigned_to

office365/directory/tenantinformation/multi_organization.py

@@ -0,0 +1,11 @@
+from office365.entity import Entity
+
+
+class MultiTenantOrganization(Entity):
+    """
+    Defines an organization with more than one instance of Microsoft Entra ID. A multitenant organization enables
+    multiple tenants to collaborate like a single entity.
+
+    There can only be one multitenant organization per active tenant. It is not possible to be part of multiple
+    multitenant organizations.
+    """

office365/directory/tenantinformation/relationship.py

@@ -0,0 +1,61 @@
+from office365.directory.tenantinformation.information import TenantInformation
+from office365.directory.tenantinformation.multi_organization import (
+    MultiTenantOrganization,
+)
+from office365.entity import Entity
+from office365.runtime.client_result import ClientResult
+from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.queries.function import FunctionQuery
+
+
+class TenantRelationship(Entity):
+    """Represent the various type of tenant relationships."""
+
+    def find_tenant_information_by_domain_name(self, domain_name):
+        """Given a domain name, search for a tenant and read its tenantInformation. You can use this API to
+        validate tenant information and use their tenantId to configure cross-tenant access settings between you
+        and the tenant.
+
+        :param str domain_name: Primary domain name of an Azure AD tenant.
+        """
+        return_type = ClientResult(self.context, TenantInformation())
+        params = {"domainName": domain_name}
+        qry = FunctionQuery(
+            self, "findTenantInformationByDomainName", params, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    def find_tenant_information_by_tenant_id(self, tenant_id):
+        """Given a tenant ID, search for a tenant and read its tenantInformation. You can use this API to validate
+        tenant information and use the tenantId to configure cross-tenant cross-tenant access settings between you
+        and the tenant.
+
+        :param str tenant_id: Unique tenant identifier of a Microsoft Entra tenant.
+        """
+        return_type = ClientResult(self.context, TenantInformation())
+        params = {"tenantId": tenant_id}
+        qry = FunctionQuery(
+            self, "findTenantInformationByTenantId", params, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    @property
+    def multi_tenant_organization(self):
+        """Represents a setting to control people-related admin settings in the tenant."""
+        return self.properties.get(
+            "multiTenantOrganization",
+            MultiTenantOrganization(
+                self.context,
+                ResourcePath("multiTenantOrganization", self.resource_path),
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "multiTenantOrganization": self.multi_tenant_organization,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(TenantRelationship, self).get_property(name, default_value)

office365/directory/users/insights_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class UserInsightsSettings(Entity):
+    """"""

office365/graph_client.py

@@ -1,5 +1,7 @@
 from typing import Any, Callable, List, Optional
 
+from office365.admin.admin import Admin
+from office365.azure_env import AzureEnvironment
 from office365.booking.solutions.root import SolutionsRoot
 from office365.communications.cloud_communications import CloudCommunications
 from office365.delta_collection import DeltaCollection
@@ -36,7 +38,7 @@ from office365.directory.rolemanagement.management import RoleManagement
 from office365.directory.rolemanagement.role import DirectoryRole
 from office365.directory.security.security import Security
 from office365.directory.serviceprincipals.collection import ServicePrincipalCollection
-from office365.directory.tenant_relationship import TenantRelationship
+from office365.directory.tenantinformation.relationship import TenantRelationship
 from office365.directory.users.collection import UserCollection
 from office365.directory.users.user import User
 from office365.education.root import EducationRoot
@@ -47,15 +49,14 @@ from office365.intune.devices.collection import DeviceCollection
 from office365.intune.devices.management.management import DeviceManagement
 from office365.intune.organizations.contact import OrgContact
 from office365.intune.organizations.organization import Organization
-from office365.onedrive.admin import Admin
 from office365.onedrive.drives.drive import Drive
 from office365.onedrive.shares.collection import SharesCollection
 from office365.onedrive.sites.sites_with_root import SitesWithRoot
+from office365.onedrive.storage.storage import Storage
 from office365.outlook.calendar.place import Place
 from office365.outlook.calendar.rooms.list import RoomList
 from office365.planner.planner import Planner
 from office365.reports.root import ReportRoot
-from office365.runtime.auth.token_response import TokenResponse
 from office365.runtime.client_runtime_context import ClientRuntimeContext
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.http.request_options import RequestOptions
@@ -77,157 +78,73 @@ from office365.teams.viva.employee_experience import EmployeeExperience
 class GraphClient(ClientRuntimeContext):
     """Graph Service client"""
 
-    def __init__(self, acquire_token_callback):
-        # type: (Callable[[], dict]) -> None
+    def __init__(
+        self,
+        token_callback=None,
+        tenant=None,
+        scopes=None,
+        token_cache=None,
+        environment=AzureEnvironment.Global,
+    ):
+        # type: (Callable[[], dict], str, list[str], Any, str) -> None
+        """
+        :param list[str] or None scopes: Scopes requested to access an API
+        :param Any token_cache: Default cache is in memory only,
+             Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
+        """
         super(GraphClient, self).__init__()
         self._pending_request = None
-        self._acquire_token_callback = acquire_token_callback
+        self._token_callback = token_callback
+        self._tenant = tenant
+        self._token_cache = token_cache
+        self._environment = environment
+        self._scopes = scopes
 
-    @staticmethod
-    def with_certificate(
-        tenant, client_id, thumbprint, private_key, scopes=None, token_cache=None
-    ):
+    def with_certificate(self, client_id, thumbprint, private_key):
         """
         Initializes the confidential client with client certificate
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str thumbprint: Thumbprint
         :param str private_key: Private key
-        :param list[str] or None scopes: Scopes requested to access an API
-        :param Any token_cache: Default cache is in memory only,
-        Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.ConfidentialClientApplication(
-            client_id,
-            authority=authority_url,
-            client_credential={
-                "thumbprint": thumbprint,
-                "private_key": private_key,
-            },
-            token_cache=token_cache,  # Default cache is in memory only.
-            # You can learn how to use SerializableTokenCache from
-            # https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
-        )
-
-        def _acquire_token():
-            return app.acquire_token_for_client(scopes=scopes)
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_certificate(client_id, thumbprint, private_key)
+        return self
 
-    @staticmethod
-    def with_client_secret(
-        tenant, client_id, client_secret, scopes=None, token_cache=None
-    ):
-        # type: (str, str, str, List[str], Any) -> "GraphClient"
+    def with_client_secret(self, client_id, client_secret):
+        # type: (str, str) -> "GraphClient"
         """
         Initializes the confidential client with client secret
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str client_secret: Client secret
-        :param list[str] or None scopes: Scopes requested to access an API
-        :param Any token_cache: Default cache is in memory only,
-             Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.ConfidentialClientApplication(
-            client_id,
-            authority=authority_url,
-            client_credential=client_secret,
-            token_cache=token_cache,
-        )
-
-        def _acquire_token():
-            return app.acquire_token_for_client(scopes=scopes)
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_client_secret(client_id, client_secret)
+        return self
 
-    @staticmethod
-    def with_token_interactive(tenant, client_id, username=None, scopes=None):
-        # type: (str, str, Optional[str], List[str]) -> "GraphClient"
+    def with_token_interactive(self, client_id, username=None):
+        # type: (str, Optional[str]) -> "GraphClient"
         """
         Initializes the client via user credentials
         Note: only works if your app is registered with redirect_uri as http://localhost
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str username: Typically a UPN in the form of an email address.
-        :param list[str] or None scopes: Scopes requested to access an API
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.PublicClientApplication(client_id, authority=authority_url)
-
-        def _acquire_token():
-            # The pattern to acquire a token looks like this.
-            result = None
-
-            # Firstly, check the cache to see if this end user has signed in before
-            accounts = app.get_accounts(username=username)
-            if accounts:
-                chosen = accounts[0]  # Assuming the end user chose this one to proceed
-                # Now let's try to find a token in cache for this account
-                result = app.acquire_token_silent(scopes, account=chosen)
-
-            if not result:
-                result = app.acquire_token_interactive(
-                    scopes,
-                    login_hint=username,
-                )
-            return result
-
-        return GraphClient(_acquire_token)
-
-    @staticmethod
-    def with_username_and_password(tenant, client_id, username, password, scopes=None):
-        # type: (str, str, str, str, List[str]) -> "GraphClient"
+        self.pending_request().with_token_interactive(client_id, username)
+        return self
+
+    def with_username_and_password(self, client_id, username, password):
+        # type: (str, str, str) -> "GraphClient"
         """
         Initializes the client via user credentials
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str username: Typically a UPN in the form of an email address.
         :param str password: The password.
-        :param list[str] or None scopes: Scopes requested to access an API
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.PublicClientApplication(
-            authority=authority_url,
-            client_id=client_id,
-        )
-
-        def _acquire_token():
-            result = None
-            accounts = app.get_accounts(username=username)
-            if accounts:
-                result = app.acquire_token_silent(scopes, account=accounts[0])
-
-            if not result:
-                result = app.acquire_token_by_username_password(
-                    username=username,
-                    password=password,
-                    scopes=scopes,
-                )
-            return result
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_username_and_password(client_id, username, password)
+        return self
 
     def execute_batch(self, items_per_batch=20, success_callback=None):
         """Constructs and submit a batch request
@@ -238,7 +155,7 @@ class GraphClient(ClientRuntimeContext):
         :param (List[ClientObject|ClientResult])-> None success_callback: A success callback
         """
         batch_request = ODataV4BatchRequest(V4JsonFormat())
-        batch_request.beforeExecute += self._authenticate_request
+        batch_request.beforeExecute += self.pending_request().authenticate_request
         while self.has_pending_request:
             qry = self._get_next_query(items_per_batch)
             batch_request.execute_query(qry)
@@ -249,8 +166,11 @@ class GraphClient(ClientRuntimeContext):
     def pending_request(self):
         # type: () -> GraphRequest
         if self._pending_request is None:
-            self._pending_request = GraphRequest()
-            self._pending_request.beforeExecute += self._authenticate_request
+            self._pending_request = GraphRequest(
+                tenant=self._tenant, environment=self._environment
+            )
+            if callable(self._token_callback):
+                self._pending_request.with_access_token(self._token_callback)
             self._pending_request.beforeExecute += self._build_specific_query
         return self._pending_request
 
@@ -266,13 +186,6 @@ class GraphClient(ClientRuntimeContext):
         elif isinstance(self.current_query, DeleteEntityQuery):
             request.method = HttpMethod.Delete
 
-    def _authenticate_request(self, request):
-        # type: (RequestOptions) -> None
-        """Authenticate request."""
-        token_json = self._acquire_token_callback()
-        token = TokenResponse.from_json(token_json)
-        request.ensure_header("Authorization", "Bearer {0}".format(token.accessToken))
-
     @property
     def admin(self):
         """A container for administrator functionality for SharePoint and OneDrive."""
@@ -475,6 +388,13 @@ class GraphClient(ClientRuntimeContext):
         """
         return InformationProtection(self, ResourcePath("informationProtection"))
 
+    @property
+    def storage(self):
+        """
+        Facilitates the structures of fileStorageContainers.
+        """
+        return Storage(self, ResourcePath("storage"))
+
     @property
     def subscriptions(self):
         """