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

office365/admin/admin.py

@@ -0,0 +1,69 @@
+from office365.admin.microsoft365_apps import AdminMicrosoft365Apps
+from office365.admin.people_settings import PeopleAdminSettings
+from office365.admin.report_settings import AdminReportSettings
+from office365.admin.sharepoint import Sharepoint
+from office365.entity import Entity
+from office365.intune.servicecommunications.announcement import ServiceAnnouncement
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class Admin(Entity):
+    """Entity that acts as a container for administrator functionality."""
+
+    @property
+    def microsoft365_apps(self):
+        """A container for the Microsoft 365 apps admin functionality."""
+        return self.properties.get(
+            "microsoft365Apps",
+            AdminMicrosoft365Apps(
+                self.context, ResourcePath("microsoft365Apps", self.resource_path)
+            ),
+        )
+
+    @property
+    def sharepoint(self):
+        """A container for administrative resources to manage tenant-level settings for SharePoint and OneDrive."""
+        return self.properties.get(
+            "sharepoint",
+            Sharepoint(self.context, ResourcePath("sharepoint", self.resource_path)),
+        )
+
+    @property
+    def service_announcement(self):
+        """A container for service communications resources. Read-only."""
+        return self.properties.get(
+            "serviceAnnouncement",
+            ServiceAnnouncement(
+                self.context, ResourcePath("serviceAnnouncement", self.resource_path)
+            ),
+        )
+
+    @property
+    def report_settings(self):
+        """A container for administrative resources to manage reports."""
+        return self.properties.get(
+            "reportSettings",
+            AdminReportSettings(
+                self.context, ResourcePath("reportSettings", self.resource_path)
+            ),
+        )
+
+    @property
+    def people(self):
+        """Represents a setting to control people-related admin settings in the tenant."""
+        return self.properties.get(
+            "people",
+            PeopleAdminSettings(
+                self.context, ResourcePath("people", self.resource_path)
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "microsoft365Apps": self.microsoft365_apps,
+                "serviceAnnouncement": self.service_announcement,
+                "reportSettings": self.report_settings,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(Admin, self).get_property(name, default_value)

office365/admin/microsoft365_apps.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class AdminMicrosoft365Apps(Entity):
+    """Represents an entity that acts as a container for administrator functionality for Microsoft 365 applications."""

office365/admin/people_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class PeopleAdminSettings(Entity):
+    """Represents a setting to control people-related admin settings in the tenant."""

office365/admin/report_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class AdminReportSettings(Entity):
+    """Represents the tenant-level settings for Microsoft 365 reports."""

office365/{onedrive → admin}/sharepoint.py

@@ -1,5 +1,5 @@
+from office365.admin.sharepoint_settings import SharepointSettings
 from office365.entity import Entity
-from office365.onedrive.sharepoint_settings import SharepointSettings
 from office365.runtime.paths.resource_path import ResourcePath
 
 

office365/azure_env.py

@@ -0,0 +1,60 @@
+class AzureEnvironment(object):
+
+    Global = "Global"
+    """Referred to as Azure or Azure Global."""
+
+    USGovernment = "GCC"
+    """Government Community Cloud"""
+
+    USGovernmentHigh = "GCC High"
+    """Government Community Cloud High."""
+
+    China = "CN"
+    """Operated by 21Vianet under Chinese regulations."""
+
+    Germany = "Azure DE"
+    """Legacy; for data sovereignty in Germany."""
+
+    USGovernmentDoD = "DoD"
+    """Azure for U.S. Department of Defense (DoD)"""
+
+    _authority_endpoints = {
+        Global: {
+            "graph": "https://graph.microsoft.com",
+            "login": "https://login.microsoftonline.com",
+        },
+        USGovernment: {
+            "graph": "https://graph.microsoft.com",
+            "login": "https://login.microsoftonline.com",
+        },
+        USGovernmentHigh: {
+            "graph": "https://graph.microsoft.us",
+            "login": "https://login.microsoftonline.us",
+        },
+        USGovernmentDoD: {
+            "graph": "https://dod-graph.microsoft.us",
+            "login": "https://login.microsoftonline.us",
+        },
+        Germany: {
+            "graph": "https://graph.microsoft.de",
+            "login": "https://login.microsoftonline.de",
+        },
+        China: {
+            "graph": "https://microsoftgraph.chinacloudapi.cn",
+            "login": "https://login.chinacloudapi.cn",
+        },
+    }
+
+    @classmethod
+    def get_graph_authority(cls, env):
+        # type: (str) -> str
+        return cls._authority_endpoints.get(env, cls._authority_endpoints["Global"])[
+            "graph"
+        ]
+
+    @classmethod
+    def get_login_authority(cls, env):
+        # type: (str) -> str
+        return cls._authority_endpoints.get(env, cls._authority_endpoints["Global"])[
+            "login"
+        ]

office365/directory/applications/app_ids.py

@@ -0,0 +1,6 @@
+class MsAppIds:
+    """Enum for commonly used Microsoft application IDs."""
+
+    Office_365_SharePoint_Online = "00000003-0000-0ff1-ce00-000000000000"
+
+    Office_365_Exchange_Online = "00000002-0000-0ff1-ce00-000000000000"

office365/directory/authentication/authentication.py

@@ -42,6 +42,21 @@ class Authentication(Entity):
             ),
         )
 
+    @property
+    def microsoft_authenticator_methods(self):
+        from office365.directory.authentication.methods.microsoft_authenticator import (
+            MicrosoftAuthenticatorAuthenticationMethod,
+        )
+
+        return self.properties.get(
+            "microsoftAuthenticatorMethods",
+            EntityCollection(
+                self.context,
+                MicrosoftAuthenticatorAuthenticationMethod,
+                ResourcePath("microsoftAuthenticatorMethods", self.resource_path),
+            ),
+        )
+
     @property
     def phone_methods(self):
         """The phone numbers registered to a user for authentication."""
@@ -94,6 +109,7 @@ class Authentication(Entity):
             property_mapping = {
                 "emailMethods": self.email_methods,
                 "fido2Methods": self.fido2_methods,
+                "microsoftAuthenticatorMethods": self.microsoft_authenticator_methods,
                 "passwordMethods": self.password_methods,
                 "phoneMethods": self.phone_methods,
             }

office365/directory/authentication/method_target.py

@@ -2,4 +2,5 @@ from office365.entity import Entity
 
 
 class AuthenticationMethodTarget(Entity):
-    """"""
+    """A collection of groups that are enabled to use an authentication method as part of an authentication
+    method policy in Microsoft Entra ID."""

office365/directory/authentication/methods/microsoft_authenticator.py

@@ -0,0 +1,6 @@
+from office365.directory.authentication.methods.method import AuthenticationMethod
+
+
+class MicrosoftAuthenticatorAuthenticationMethod(AuthenticationMethod):
+    """A representation of the Microsoft Authenticator app registered to a user. Microsoft Authenticator
+    is an authentication method."""

office365/directory/authentication/methods/root.py

@@ -1,6 +1,9 @@
 from office365.directory.authentication.methods.details import UserRegistrationDetails
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
+from office365.reports.userregistration.feature_summary import (
+    UserRegistrationFeatureSummary,
+)
 from office365.reports.userregistration.method_summary import (
     UserRegistrationMethodSummary,
 )
@@ -12,6 +15,14 @@ from office365.runtime.queries.function import FunctionQuery
 class AuthenticationMethodsRoot(Entity):
     """Container for navigation properties for Azure AD authentication methods resources."""
 
+    def users_registered_by_feature(self):
+        """Get the number of users capable of multi-factor authentication, self-service password reset,
+        and passwordless authentication."""
+        return_type = ClientResult(self.context, UserRegistrationFeatureSummary())
+        qry = FunctionQuery(self, "usersRegisteredByFeature", None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def users_registered_by_method(self):
         """Get the number of users registered for each authentication method."""
         return_type = ClientResult(self.context, UserRegistrationMethodSummary())

office365/directory/authentication/methods/sms.py

@@ -0,0 +1,9 @@
+from office365.directory.authentication.method_configuration import (
+    AuthenticationMethodConfiguration,
+)
+
+
+class SmsAuthenticationMethodConfiguration(AuthenticationMethodConfiguration):
+    """Represents a text message authentication methods policy. Authentication methods policies define
+    configuration settings and users or groups that are enabled to use the authentication method.
+    """

office365/directory/certificates/self_signed.py

@@ -4,8 +4,37 @@ from office365.runtime.client_value import ClientValue
 class SelfSignedCertificate(ClientValue):
     """Contains the public part of a signing certificate."""
 
-    def __init__(self, display_name=None):
+    def __init__(
+        self,
+        custom_key_identifier=None,
+        display_name=None,
+        end_datetime=None,
+        key=None,
+        key_id=None,
+        start_datetime=None,
+        thumbprint=None,
+        type_=None,
+        usage=None,
+    ):
         """
-        :param str display_name:
+        :param custom_key_identifier: 	Custom key identifier.
+        :param str display_name: The friendly name for the key.
+        :param end_datetime: The date and time at which the credential expires. The timestamp type represents date
+             and time information using ISO 8601 format and is always in UTC time
+        :param key: The value for the key credential. Should be a Base-64 encoded value.
+        :param key_id: 	The unique identifier (GUID) for the key.
+        :param start_datetime: The date and time at which the credential becomes valid. The timestamp type represents
+             date and time information using ISO 8601 format and is always in UTC time
+        :param thumbprint: 	The thumbprint value for the key.
+        :param type_: 	The type of key credential. AsymmetricX509Cert.
+        :param usage: A string that describes the purpose for which the key can be used. The possible value is Verify.
         """
+        self.customKeyIdentifier = custom_key_identifier
         self.displayName = display_name
+        self.endDateTime = end_datetime
+        self.key = key
+        self.keyId = key_id
+        self.startDateTime = start_datetime
+        self.thumbprint = thumbprint
+        self.type = type_
+        self.usage = usage

office365/directory/identities/conditional_access_root.py

@@ -1,4 +1,6 @@
+from office365.directory.policies.conditional_access import ConditionalAccessPolicy
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
 from office365.runtime.paths.resource_path import ResourcePath
 
 
@@ -15,3 +17,15 @@ class ConditionalAccessRoot(Entity):
                 self.context, ResourcePath("authenticationStrength", self.resource_path)
             ),
         )
+
+    @property
+    def policies(self):
+        """Returns a collection of the specified Conditional Access (CA) policies."""
+        return self.properties.get(
+            "policies",
+            EntityCollection(
+                self.context,
+                ConditionalAccessPolicy,
+                ResourcePath("policies", self.resource_path),
+            ),
+        )

office365/directory/identitygovernance/privilegedaccess/approval.py

@@ -0,0 +1,8 @@
+from office365.entity import Entity
+
+
+class Approval(Entity):
+    """Represents the approval object for decisions associated with a request.
+
+    In PIM for groups, the approval object for decisions to approve or deny requests to activate
+    group membership or ownership."""

office365/directory/identitygovernance/privilegedaccess/group.py

@@ -1,5 +1,35 @@
+from office365.directory.identitygovernance.privilegedaccess.approval import Approval
+from office365.directory.identitygovernance.privilegedaccess.group_assignment_schedule_instance import (
+    PrivilegedAccessGroupAssignmentScheduleInstance,
+)
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class PrivilegedAccessGroup(Entity):
     """The entry point for all resources related to Privileged Identity Management (PIM) for groups."""
+
+    @property
+    def assignment_approvals(self):
+        """ """
+        return self.properties.get(
+            "assignmentApprovals",
+            EntityCollection(
+                self.context,
+                Approval,
+                ResourcePath("assignmentApprovals", self.resource_path),
+            ),
+        )
+
+    @property
+    def assignment_schedule_instances(self):
+        """The instances of assignment schedules to activate a just-in-time access."""
+        return self.properties.get(
+            "assignmentScheduleInstances",
+            EntityCollection(
+                self.context,
+                PrivilegedAccessGroupAssignmentScheduleInstance,
+                ResourcePath("assignmentScheduleInstances", self.resource_path),
+            ),
+        )

office365/directory/identitygovernance/privilegedaccess/group_assignment_schedule_instance.py

@@ -0,0 +1,7 @@
+from office365.directory.identitygovernance.privilegedaccess.schedule_instance import (
+    PrivilegedAccessScheduleInstance,
+)
+
+
+class PrivilegedAccessGroupAssignmentScheduleInstance(PrivilegedAccessScheduleInstance):
+    """Represents an instance of a provisioned membership or ownership assignment in PIM for groups."""

office365/directory/identitygovernance/privilegedaccess/unified_role_assignment_schedule_request.py

@@ -0,0 +1,7 @@
+from office365.entity import Entity
+
+
+class UnifiedRoleAssignmentScheduleRequest(Entity):
+    """In PIM, represents a request for an active role assignment to a principal. The role assignment can be
+    permanently active with or without an expiry date, or temporarily active after activation of an eligible
+    assignment. Inherits from request."""

office365/directory/identitygovernance/userconsent/request_collection.py

@@ -2,6 +2,7 @@ from office365.directory.identitygovernance.userconsent.request import (
     UserConsentRequest,
 )
 from office365.entity_collection import EntityCollection
+from office365.runtime.queries.function import FunctionQuery
 
 
 class UserConsentRequestCollection(EntityCollection[UserConsentRequest]):
@@ -11,3 +12,12 @@ class UserConsentRequestCollection(EntityCollection[UserConsentRequest]):
         super(UserConsentRequestCollection, self).__init__(
             context, UserConsentRequest, resource_path
         )
+
+    def filter_by_current_user(self, on):
+        """Retrieve a collection of userConsentRequest objects for accessing a specified app, for which the current
+        user is the reviewer."""
+        return_type = UserConsentRequestCollection(self.context, self.resource_path)
+        params = {"on": on}
+        qry = FunctionQuery(self, "filterByCurrentUser", params, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/directory/identitygovernance/workflow/base.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class WorkflowBase(Entity):
+    """An abstract type that exposes the properties for configuring a custom lifecycle workflow."""

office365/directory/policies/cross_tenant_access.py

@@ -1,4 +1,6 @@
 from office365.directory.policies.base import PolicyBase
+from office365.directory.policies.template import PolicyTemplate
+from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.collections import StringCollection
 
 
@@ -13,3 +15,14 @@ class CrossTenantAccessPolicy(PolicyBase):
         and partner.microsoftonline.cn.
         """
         return self.properties.get("allowedCloudEndpoints", StringCollection())
+
+    def templates(self):
+        # type: () -> PolicyTemplate
+        """Represents the base policy in the directory for multitenant organization settings."""
+        return self.properties.get(
+            "templates",
+            PolicyTemplate(
+                self.context,
+                ResourcePath("templates", self.resource_path),
+            ),
+        )

office365/directory/policies/feature_rollout.py

@@ -0,0 +1,16 @@
+from office365.entity import Entity
+
+
+class FeatureRolloutPolicy(Entity):
+    """
+    Represents a feature rollout policy associated with a directory object. Creating a feature rollout policy
+    helps tenant administrators to pilot features of Microsoft Entra ID with a specific group before enabling
+    features for entire organization. This minimizes the impact and helps administrators to test and rollout
+    authentication related features gradually.
+
+    The following are limitations of feature rollout:
+
+     - Each feature supports a maximum of 10 groups.
+     - The appliesTo field only supports groups.
+     - Dynamic groups and nested groups are not supported.
+    """

office365/directory/policies/root.py

@@ -11,6 +11,7 @@ from office365.directory.policies.authorization import AuthorizationPolicy
 from office365.directory.policies.conditional_access import ConditionalAccessPolicy
 from office365.directory.policies.cross_tenant_access import CrossTenantAccessPolicy
 from office365.directory.policies.device_registration import DeviceRegistrationPolicy
+from office365.directory.policies.feature_rollout import FeatureRolloutPolicy
 from office365.directory.policies.permission_grant import PermissionGrantPolicy
 from office365.directory.policies.tenant_app_management import TenantAppManagementPolicy
 from office365.directory.policies.unified_role_management import (
@@ -52,16 +53,6 @@ class PolicyRoot(Entity):
         )
 
     @property
-    def device_registration_policy(self):
-        """ """
-        return self.properties.get(
-            "deviceRegistrationPolicy",
-            DeviceRegistrationPolicy(
-                self.context,
-                ResourcePath("deviceRegistrationPolicy", self.resource_path),
-            ),
-        )
-
     def authentication_strength_policies(self):
         # type: () -> EntityCollection[AuthenticationStrengthPolicy]
         """
@@ -111,6 +102,19 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def conditional_access_policies(self):
+        # type: () -> EntityCollection[ConditionalAccessPolicy]
+        """The custom rules that define an access scenario"""
+        return self.properties.get(
+            "conditionalAccessPolicies",
+            EntityCollection(
+                self.context,
+                ConditionalAccessPolicy,
+                ResourcePath("conditionalAccessPolicies", self.resource_path),
+            ),
+        )
+
     @property
     def cross_tenant_access_policy(self):
         """
@@ -124,6 +128,17 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def device_registration_policy(self):
+        """ """
+        return self.properties.get(
+            "deviceRegistrationPolicy",
+            DeviceRegistrationPolicy(
+                self.context,
+                ResourcePath("deviceRegistrationPolicy", self.resource_path),
+            ),
+        )
+
     @property
     def default_app_management_policy(self):
         """
@@ -137,6 +152,19 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def feature_rollout_policies(self):
+        # type: () -> EntityCollection[FeatureRolloutPolicy]
+        """The feature rollout policy associated with a directory object."""
+        return self.properties.get(
+            "featureRolloutPolicies",
+            EntityCollection(
+                self.context,
+                FeatureRolloutPolicy,
+                ResourcePath("featureRolloutPolicies", self.resource_path),
+            ),
+        )
+
     @property
     def permission_grant_policies(self):
         # type: () -> EntityCollection[PermissionGrantPolicy]
@@ -152,19 +180,6 @@ class PolicyRoot(Entity):
             ),
         )
 
-    @property
-    def conditional_access_policies(self):
-        # type: () -> EntityCollection[ConditionalAccessPolicy]
-        """The custom rules that define an access scenario"""
-        return self.properties.get(
-            "conditionalAccessPolicies",
-            EntityCollection(
-                self.context,
-                ConditionalAccessPolicy,
-                ResourcePath("conditionalAccessPolicies", self.resource_path),
-            ),
-        )
-
     @property
     def role_management_policies(self):
         # type: () -> EntityCollection[UnifiedRoleManagementPolicy]
@@ -191,6 +206,7 @@ class PolicyRoot(Entity):
                 "crossTenantAccessPolicy": self.cross_tenant_access_policy,
                 "defaultAppManagementPolicy": self.default_app_management_policy,
                 "deviceRegistrationPolicy": self.device_registration_policy,
+                "featureRolloutPolicies": self.feature_rollout_policies,
                 "permissionGrantPolicies": self.permission_grant_policies,
                 "roleManagementPolicies": self.role_management_policies,
             }

office365/directory/policies/template.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class PolicyTemplate(Entity):
+    """Represents the base policy in the directory for multitenant organization settings."""

office365/directory/protection/threatassessment/email_file_request.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from office365.directory.protection.threatassessment.request import (
+    ThreatAssessmentRequest,
+)
+
+
+class EmailFileAssessmentRequest(ThreatAssessmentRequest):
+    """
+    Represents a resource that creates and retrieves an email file threat assessment.
+    The email file can be an .eml file type.
+    """
+
+    @property
+    def content_data(self):
+        # type: () -> Optional[str]
+        """
+        Base64 encoded .eml email file content. The file content can't fetch back because it isn't stored.
+        """
+        return self.properties.get("contentData", None)

office365/directory/protection/threatassessment/request.py

@@ -1,5 +1,30 @@
+from datetime import datetime
+
+from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 
 
 class ThreatAssessmentRequest(Entity):
     """An abstract resource type used to represent a threat assessment request item."""
+
+    @property
+    def created_by(self):
+        """The threat assessment request creator."""
+        return self.properties.get("createdBy", IdentitySet())
+
+    @property
+    def created_datetime(self):
+        """
+        The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time.
+        For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
+        """
+        return self.properties.get("createdDateTime", datetime.min)
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "createdDateTime": self.created_datetime,
+                "createdBy": self.created_by,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(ThreatAssessmentRequest, self).get_property(name, default_value)

office365/directory/rolemanagement/application.py

@@ -1,3 +1,6 @@
+from office365.directory.identitygovernance.privilegedaccess.unified_role_assignment_schedule_request import (
+    UnifiedRoleAssignmentScheduleRequest,
+)
 from office365.directory.rolemanagement.unified_role_assignment import (
     UnifiedRoleAssignment,
 )
@@ -40,6 +43,18 @@ class RbacApplication(Entity):
             ),
         )
 
+    def role_assignment_schedule_requests(self):
+        # type: () -> EntityCollection[UnifiedRoleAssignmentScheduleRequest]
+        """Resource representing the roles allowed by RBAC providers and the permissions assigned to the roles."""
+        return self.properties.get(
+            "roleAssignmentScheduleRequests",
+            EntityCollection(
+                self.context,
+                UnifiedRoleAssignmentScheduleRequest,
+                ResourcePath("roleAssignmentScheduleRequests", self.resource_path),
+            ),
+        )
+
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {

office365/directory/rolemanagement/resource_action.py

@@ -3,8 +3,12 @@ from office365.runtime.types.collections import StringCollection
 
 
 class ResourceAction(ClientValue):
-    """ """
+    """Set of allowed and not allowed actions for a resource."""
 
-    def __init__(self):
-        self.allowedResourceActions = StringCollection()
-        self.notAllowedResourceActions = StringCollection()
+    def __init__(self, allowed=None, not_allowed=None):
+        """
+        :param list[str] allowed: Allowed Actions
+        :param list[str] not_allowed: Not Allowed Actions.
+        """
+        self.allowedResourceActions = StringCollection(allowed)
+        self.notAllowedResourceActions = StringCollection(not_allowed)