Office365-REST-Python-Client 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

office365/onedrive/driveitems/driveItem.py

@@ -12,30 +12,34 @@ from office365.onedrive.driveitems.image import Image
 from office365.onedrive.driveitems.item_preview_info import ItemPreviewInfo
 from office365.onedrive.driveitems.photo import Photo
 from office365.onedrive.driveitems.publication_facet import PublicationFacet
+from office365.onedrive.driveitems.remote_item import RemoteItem
 from office365.onedrive.driveitems.special_folder import SpecialFolder
 from office365.onedrive.driveitems.thumbnail_set import ThumbnailSet
+from office365.onedrive.drives.recipient import DriveRecipient
 from office365.onedrive.files.file import File
 from office365.onedrive.files.system_info import FileSystemInfo
 from office365.onedrive.folders.folder import Folder
 from office365.onedrive.internal.paths.children import ChildrenPath
 from office365.onedrive.internal.paths.url import UrlPath
 from office365.onedrive.internal.queries.resumable_file_upload import create_resumable_file_upload_query
-from office365.onedrive.internal.queries.upload_content import create_upload_content_query
 from office365.onedrive.listitems.item_reference import ItemReference
 from office365.onedrive.listitems.list_item import ListItem
+from office365.onedrive.operations.pending import PendingOperations
 from office365.onedrive.permissions.collection import PermissionCollection
 from office365.onedrive.permissions.permission import Permission
+from office365.onedrive.sensitivitylabels.extract_result import ExtractSensitivityLabelsResult
 from office365.onedrive.shares.shared import Shared
 from office365.onedrive.versions.drive_item import DriveItemVersion
 from office365.onedrive.workbooks.workbook import Workbook
 from office365.runtime.client_result import ClientResult
+from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.create_entity import CreateEntityQuery
 from office365.runtime.queries.function import FunctionQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.runtime.queries.upload_session import UploadSessionQuery
-from office365.subscriptions.subscription import Subscription
+from office365.subscriptions.collection import SubscriptionCollection
 
 
 class DriveItem(BaseItem):
@@ -54,11 +58,12 @@ class DriveItem(BaseItem):
         """
         Creates a PowerPoint file
 
-        :param str name:
+        :param str name: File name
         """
         return self.upload(name, None)
 
-    def create_link(self, link_type, scope="", expiration_datetime=None, password=None, message=None):
+    def create_link(self, link_type, scope="", expiration_datetime=None, password=None, message=None,
+                    retain_inherited_permissions=None):
         """
         The createLink action will create a new sharing link if the specified link type doesn't already exist
         for the calling application. If a sharing link of the specified type already exists for the app,
@@ -66,18 +71,22 @@ class DriveItem(BaseItem):
 
         :param str link_type: The type of sharing link to create. Either view, edit, or embed.
         :param str scope:  The scope of link to create. Either anonymous or organization.
-        :param str expiration_datetime: A String with format of yyyy-MM-ddTHH:mm:ssZ of DateTime indicates
+        :param str or datetime.datetime expiration_datetime: A String with format of yyyy-MM-ddTHH:mm:ssZ of DateTime indicates
             the expiration time of the permission.
         :param str password: The password of the sharing link that is set by the creator. Optional
             and OneDrive Personal only.
         :param str message:
+        :param bool retain_inherited_permissions: Optional. If true (default), any existing inherited permissions
+            are retained on the shared item when sharing this item for the first time.
+            If false, all existing permissions are removed when sharing for the first time.
         """
         payload = {
             "type": link_type,
             "scope": scope,
             "message": message,
             "expirationDateTime": expiration_datetime,
-            "password": password
+            "password": password,
+            "retainInheritedPermissions": retain_inherited_permissions
         }
         return_type = Permission(self.context)
         self.permissions.add_child(return_type)
@@ -85,6 +94,17 @@ class DriveItem(BaseItem):
         self.context.add_query(qry)
         return return_type
 
+    def extract_sensitivity_labels(self):
+        """
+        Extract one or more sensitivity labels assigned to a drive item and update the metadata of a drive
+        item with the latest details of the assigned label. In case of failure to extract the sensitivity labels
+        of a file, an extraction error will be thrown with the applicable error code and message.
+        """
+        return_type = ClientResult(self.context, ExtractSensitivityLabelsResult())
+        qry = ServiceOperationQuery(self, "extractSensitivityLabels", return_type=return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def follow(self):
         """
         Follow a driveItem.
@@ -161,26 +181,57 @@ class DriveItem(BaseItem):
 
     def upload(self, name, content):
         """The simple upload API allows you to provide the contents of a new file or update the contents of an
-        existing file in a single API call. This method only supports files up to 4MB in size.
+        existing file in a single API call.
+
+        Note: This method only supports files up to 4MB in size.
 
         :param name: The contents of the request body should be the binary stream of the file to be uploaded.
         :type name: str
         :param content: The contents of the request body should be the binary stream of the file to be uploaded.
         :type content: str or bytes or None
-        :rtype: DriveItem
         """
-        qry = create_upload_content_query(self, name, content)
+        return_type = DriveItem(self.context, UrlPath(name, self.resource_path))
+        qry = ServiceOperationQuery(return_type, "content", None, content, None, return_type)
         self.children.add_child(qry.return_type)
-        self.context.add_query(qry)
-        return qry.return_type
 
-    def get_content(self):
-        """Download the contents of the primary stream (file) of a DriveItem. Only driveItems with the file property
-        can be downloaded. """
-        from office365.onedrive.internal.queries.download_content import create_download_content_query
-        qry = create_download_content_query(self)
+        def _modify_query(request):
+            """
+            :type request: office365.runtime.http.request_options.RequestOptions
+            """
+            request.method = HttpMethod.Put
+
+        self.context.add_query(qry).before_query_execute(_modify_query)
+        return return_type
+
+    def upload_file(self, path_or_file):
+        """Uploads a file
+
+        :param str or typing.IO path_or_file:
+        """
+        if hasattr(path_or_file, 'read'):
+            content = path_or_file.read()
+            name = os.path.basename(path_or_file.name)
+            return self.upload(name, content)
+        else:
+            with open(path_or_file, 'rb') as f:
+                content = f.read()
+            name = os.path.basename(path_or_file)
+            return self.upload(name, content)
+
+    def get_content(self, format_name=None):
+        """
+        Download the contents of the primary stream (file) of a DriveItem. O
+        nly driveItems with the file property can be downloaded.
+
+        :type format_name: str or None
+        """
+        return_type = ClientResult(self.context)
+        action_name = "content"
+        if format_name is not None:
+            action_name = action_name + r"?format={0}".format(format_name)
+        qry = FunctionQuery(self, action_name, None, return_type)
         self.context.add_query(qry)
-        return qry.return_type
+        return return_type
 
     def download(self, file_object):
         """
@@ -189,31 +240,38 @@ class DriveItem(BaseItem):
 
         :type file_object: typing.IO
         """
+
         def _save_content(return_type):
             """
             :type return_type: ClientResult
             """
             file_object.write(return_type.value)
+
         self.get_content().after_execute(_save_content)
         return self
 
     def download_session(self, file_object, chunk_downloaded=None, chunk_size=1024 * 1024):
         """
+        By default, file gets downloaded immediately.
+        For a large files reading the whole content of a file at once into memory should be avoided.
+
+        This method allows to stream content into the file
+
         :type file_object: typing.IO
-        :type chunk_downloaded: (int)->None or None
-        :type chunk_size: int
+        :param (int)->None or None chunk_downloaded: A callback
+        :param int chunk_size: The number of bytes it should read into memory.
         """
-        from office365.onedrive.internal.queries.download_content import create_download_session_content_query
-        qry = create_download_session_content_query(self)
 
-        def _construct_download_request(request):
+        def _construct_request(request):
             """
             :type request: office365.runtime.http.request_options.RequestOptions
             """
             request.stream = True
-            request.method = HttpMethod.Get
 
-        def _process_download_response(response):
+        def _process_response(response):
+            """
+            :type response: requests.Response
+            """
             bytes_read = 0
             for chunk in response.iter_content(chunk_size=chunk_size):
                 bytes_read += len(chunk)
@@ -221,9 +279,8 @@ class DriveItem(BaseItem):
                     chunk_downloaded(bytes_read)
                 file_object.write(chunk)
 
-        self.context.before_execute(_construct_download_request)
-        self.context.after_execute(_process_download_response)
-        self.context.add_query(qry)
+        self.get_content().before_execute(_construct_request)
+        self.context.after_execute(_process_response)
         return self
 
     def create_folder(self, name, conflict_behavior=ConflictBehavior.Rename):
@@ -248,12 +305,8 @@ class DriveItem(BaseItem):
 
         :param format_name: Specify the format the item's content should be downloaded as.
         :type format_name: str
-        :rtype: ClientResult
         """
-        from office365.onedrive.internal.queries.download_content import create_download_content_query
-        qry = create_download_content_query(self, format_name)
-        self.context.add_query(qry)
-        return qry.return_type
+        return self.get_content(format_name)
 
     def copy(self, name=None, parent=None, conflict_behavior=ConflictBehavior.Fail):
         """Asynchronously creates a copy of an driveItem (including any children), under a new parent item or with a
@@ -285,7 +338,7 @@ class DriveItem(BaseItem):
                 return
             return_type.set_property("__value", location)
 
-        def _create_query(parent_reference):
+        def _create_and_add_query(parent_reference):
             """
             :param office365.onedrive.listitems.item_reference.ItemReference or None parent_reference:  Reference to the
              parent item the copy will be created in.
@@ -296,18 +349,17 @@ class DriveItem(BaseItem):
             }
             self.context.before_execute(_create_request)
             self.context.after_execute(_process_response)
-            return ServiceOperationQuery(self, "copy", None, payload, None, return_type)
+            qry = ServiceOperationQuery(self, "copy", None, payload, None, return_type)
+            self.context.add_query(qry)
 
         if isinstance(parent, DriveItem):
             def _drive_item_loaded():
                 parent_reference = ItemReference(drive_id=parent.parent_reference.driveId, _id=parent.id)
-                next_qry = _create_query(parent_reference)
-                self.context.add_query(next_qry)
+                _create_and_add_query(parent_reference)
 
             parent.ensure_property("parentReference", _drive_item_loaded)
         else:
-            qry = _create_query(parent)
-            self.context.add_query(qry)
+            _create_and_add_query(parent)
         return return_type
 
     def move(self, name=None, parent=None):
@@ -322,7 +374,7 @@ class DriveItem(BaseItem):
 
         return_type = ClientResult(self.context, str())
 
-        def _create_query(parent_reference):
+        def _create_and_add_query(parent_reference):
             payload = {
                 "name": name,
                 "parentReference": parent_reference
@@ -332,18 +384,16 @@ class DriveItem(BaseItem):
                 request.method = HttpMethod.Patch
 
             self.context.before_execute(_construct_request)
-            return ServiceOperationQuery(self, "move", None, payload, None, return_type)
+            qry = ServiceOperationQuery(self, "move", None, payload, None, return_type)
+            self.context.add_query(qry)
 
         if isinstance(parent, DriveItem):
             def _drive_item_loaded():
-                parent_reference = ItemReference(_id=parent.id)
-                next_qry = _create_query(parent_reference)
-                self.context.add_query(next_qry)
+                _create_and_add_query(ItemReference(_id=parent.id))
 
             parent.ensure_property("parentReference", _drive_item_loaded)
         else:
-            qry = _create_query(parent)
-            self.context.add_query(qry)
+            _create_and_add_query(parent)
         return return_type
 
     def rename(self, new_name):
@@ -363,31 +413,43 @@ class DriveItem(BaseItem):
         self.context.add_query(qry)
         return return_type
 
-    def invite(self, recipients, message, require_sign_in=True, send_invitation=True, roles=None):
-        """Sends a sharing invitation for a driveItem. A sharing invitation provides permissions to the recipients
+    def invite(self, recipients, message, require_sign_in=True, send_invitation=True, roles=None,
+               expiration_datetime=None, password=None, retain_inherited_permissions=None):
+        """
+        Sends a sharing invitation for a driveItem. A sharing invitation provides permissions to the recipients
         and optionally sends them an email with a sharing link.
 
-        :param list[DriveRecipient] recipients: A collection of recipients who will receive access and the sharing
-        invitation.
+        :param list[str] recipients: A collection of recipients who will receive access and the sharing
+            invitation.
         :param str message: A plain text formatted message that is included in the sharing invitation.
-        Maximum length 2000 characters.
+            Maximum length 2000 characters.
         :param bool require_sign_in: Specifies whether the recipient of the invitation is required to sign-in to view
-        the shared item.
+            the shared item.
         :param bool send_invitation: If true, a sharing link is sent to the recipient. Otherwise, a permission is
-        granted directly without sending a notification.
+            granted directly without sending a notification.
         :param list[str] roles: Specify the roles that are to be granted to the recipients of the sharing invitation.
+        :param datetime.datetime expiration_datetime: Specifies the dateTime after which the permission expires.
+            For OneDrive for Business and SharePoint, expirationDateTime is only applicable for sharingLink permissions.
+            Available on OneDrive for Business, SharePoint, and premium personal OneDrive accounts.
+        :param str password: The password set on the invite by the creator. Optional and OneDrive Personal only.
+        :param bool retain_inherited_permissions: Optional. If true (default), any existing inherited permissions
+            are retained on the shared item when sharing this item for the first time. If false, all existing
+            permissions are removed when sharing for the first time.
         """
         if roles is None:
             roles = ["read"]
-        return_type = EntityCollection(self.context, Permission)
+        return_type = PermissionCollection(self.context)
         payload = {
             "requireSignIn": require_sign_in,
             "sendInvitation": send_invitation,
             "roles": roles,
-            "recipients": recipients,
-            "message": message
+            "recipients": ClientValueCollection(DriveRecipient, [DriveRecipient.from_email(r) for r in recipients]),
+            "message": message,
+            "expirationDateTime": expiration_datetime.isoformat() + "Z" if expiration_datetime else None,
+            "password": password,
+            "retainInheritedPermissions": retain_inherited_permissions
         }
-        qry = ServiceOperationQuery(self, "invite", payload, None, None, return_type)
+        qry = ServiceOperationQuery(self, "invite", None, payload, None, return_type)
         self.context.add_query(qry)
         return return_type
 
@@ -402,26 +464,29 @@ class DriveItem(BaseItem):
         """
         return_type = EntityCollection(self.context, ItemActivityStat, self.resource_path)
 
-        def _create_query(binding_type):
+        def _create_query():
             params = {
                 "startDateTime": start_dt.strftime('%m-%d-%Y') if start_dt else None,
                 "endDateTime": end_dt.strftime('%m-%d-%Y') if end_dt else None,
                 "interval": interval
             }
-            return FunctionQuery(binding_type, "getActivitiesByInterval", params, return_type)
-
-        # if isinstance(self.resource_path, RootPath):
-        #    def _loaded():
-        #        drive_item = self.context.drives[self.parent_reference.driveId].items[self.id]
-        #        next_qry = _create_query(drive_item)
-        #        self.context.add_query(next_qry)
-        #    self.ensure_property("parentReference", _loaded)
-        # else:
-        qry = _create_query(self)
+            return FunctionQuery(self, "getActivitiesByInterval", params, return_type)
+
+        qry = _create_query()
         self.context.add_query(qry)
 
         return return_type
 
+    def permanent_delete(self):
+        """
+        Permanently delete a driveItem.
+        Note that if you delete items using this method, they will be permanently removed and won't be sent to the
+        recycle bin. Therefore, they cannot be restored afterward.
+        """
+        qry = ServiceOperationQuery(self, "permanentDelete")
+        self.context.add_query(qry)
+        return self
+
     def restore(self, parent_reference=None, name=None):
         """
         Restore a driveItem that has been deleted and is currently in the recycle bin.
@@ -560,6 +625,12 @@ class DriveItem(BaseItem):
         """For files that are Excel spreadsheets, accesses the workbook API to work with the spreadsheet's contents. """
         return self.properties.get('workbook', Workbook(self.context, ResourcePath("workbook", self.resource_path)))
 
+    @property
+    def pending_operations(self):
+        """If present, indicates that one or more operations that might affect the state of the driveItem are pending
+        completion. Read-only."""
+        return self.properties.get('pendingOperations', PendingOperations())
+
     @property
     def permissions(self):
         """The set of permissions for the item. Read-only. Nullable."""
@@ -572,6 +643,11 @@ class DriveItem(BaseItem):
         in locations that support such actions. This property is not returned by default. Read-only."""
         return self.properties.get('publication', PublicationFacet())
 
+    @property
+    def remote_item(self):
+        """Remote item data, if the item is shared from a drive other than the one being accessed. Read-only."""
+        return self.properties.get('remoteItem', RemoteItem())
+
     @property
     def special_folder(self):
         """If the current item is also available as a special folder, this facet is returned. Read-only."""
@@ -610,13 +686,15 @@ class DriveItem(BaseItem):
         """The set of subscriptions on the driveItem.
         """
         return self.properties.get('subscriptions',
-                                   EntityCollection(self.context, Subscription,
-                                                    ResourcePath("subscriptions", self.resource_path)))
+                                   SubscriptionCollection(self.context,
+                                                          ResourcePath("subscriptions", self.resource_path)))
 
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
                 "fileSystemInfo": self.file_system_info,
+                "remoteItem": self.remote_item,
+                "specialFolder": self.special_folder
             }
             default_value = property_mapping.get(name, None)
         return super(DriveItem, self).get_property(name, default_value)

office365/onedrive/driveitems/image.py

@@ -8,4 +8,11 @@ class Image(ClientValue):
 
     Note: If the service is unable to determine the width and height of the image, the Image resource may be empty.
     """
-    pass
+
+    def __init__(self, height=None, width=None):
+        """
+        :param int height:
+        :param int width:
+        """
+        self.height = height
+        self.width = width

office365/onedrive/driveitems/item_preview_info.py

@@ -2,8 +2,26 @@ from office365.runtime.client_value import ClientValue
 
 
 class ItemPreviewInfo(ClientValue):
-    """Contains information about how to embed a preview of a driveItem."""
+    """Contains information about how to embed a preview of a driveItem.
 
-    def __init__(self, post_url=None):
+    Either getUrl, postUrl, or both may be returned depending on the current state of support for the specified options.
+
+    postParameters is a string formatted as application/x-www-form-urlencoded,
+    and if performing a POST to the postUrl the content-type should be set accordingly. For example:
+
+    POST https://www.onedrive.com/embed_by_post
+    Content-Type: application/x-www-form-urlencoded
+
+    param1=value&param2=another%20value
+    """
+
+    def __init__(self, get_url=None, post_parameters=None, post_url=None):
+        """
+        :param str get_url: URL suitable for embedding using HTTP GET (iframes, etc.)
+        :param str post_parameters: POST parameters to include if using postUrl
+        :param str post_url: URL suitable for embedding using HTTP POST (form post, JS, etc.)
+        """
+        self.getUrl = get_url
+        self.postParameters = post_parameters
         self.postUrl = post_url
 

office365/onedrive/driveitems/remote_item.py

@@ -1,4 +1,8 @@
 from office365.directory.permissions.identity_set import IdentitySet
+from office365.onedrive.driveitems.image import Image
+from office365.onedrive.files.file import File
+from office365.onedrive.files.system_info import FileSystemInfo
+from office365.onedrive.folders.folder import Folder
 from office365.runtime.client_value import ClientValue
 
 
@@ -8,13 +12,24 @@ class RemoteItem(ClientValue):
     This resource provides the unique IDs of the source drive and target item.
 
     DriveItems with a non-null remoteItem facet are resources that are shared, added to the user's OneDrive,
-    or on items returned from hetrogenous collections of items (like search results).
+    or on items returned from heterogeneous collections of items (like search results).
     """
 
-    def __init__(self, created_by=IdentitySet(), created_datetime=None):
+    def __init__(self, _id=None, created_by=IdentitySet(), created_datetime=None,
+                 file=File(), file_system_info=FileSystemInfo(), folder=Folder(), image=Image()):
         """
-        :param IdentitySet created_by:
-        :param datetime.datetime created_datetime:
+        :param str _id: Unique identifier for the remote item in its drive. Read-only.
+        :param IdentitySet created_by: Identity of the user, device, and application which created the item. Read-only.
+        :param datetime.datetime created_datetime: Date and time of item creation. Read-only.
+        :param File file: Indicates that the remote item is a file. Read-only.
+        :param FileSystemInfo file_system_info: Information about the remote item from the local file system. Read-only.
+        :param Folder folder: Indicates that the remote item is a folder. Read-only.
+        :param Image image: Image metadata, if the item is an image. Read-only.
         """
+        self.id = _id
         self.createdBy = created_by
         self.createdDateTime = created_datetime
+        self.file = file
+        self.fileSystemInfo = file_system_info
+        self.folder = folder
+        self.image = image

office365/onedrive/drives/drive.py

@@ -4,6 +4,7 @@ from office365.entity_collection import EntityCollection
 from office365.onedrive.driveitems.conflict_behavior import ConflictBehavior
 from office365.onedrive.driveitems.driveItem import DriveItem
 from office365.onedrive.driveitems.system_facet import SystemFacet
+from office365.onedrive.drives.quota import Quota
 from office365.onedrive.internal.paths.root import RootPath
 from office365.onedrive.lists.list import List
 from office365.onedrive.sharepoint_ids import SharePointIds
@@ -125,9 +126,14 @@ class Drive(BaseItem):
                                    EntityCollection(self.context, DriveItem,
                                                     ResourcePath("following", self.resource_path)))
 
+    @property
+    def quota(self):
+        """Optional. Information about the drive's storage space quota. Read-only."""
+        return self.properties.get("quota", Quota())
+
     @property
     def special(self):
-        """Collection of common folders available in OneDrive. Read-only. Nullable."""
+        """Collection of auth folders available in OneDrive. Read-only. Nullable."""
         return self.properties.get('special',
                                    EntityCollection(self.context, DriveItem,
                                                     ResourcePath("special", self.resource_path)))

office365/onedrive/drives/quota.py

@@ -0,0 +1,18 @@
+from office365.runtime.client_value import ClientValue
+
+
+class Quota(ClientValue):
+    """
+    The quota resource provides details about space constraints on a drive resource.
+    In OneDrive Personal, the values reflect the total/used unified storage quota across multiple Microsoft services.
+    """
+
+    def __init__(self, deleted=None, remaining=None, state=None):
+        """
+        :param int deleted: Total space consumed by files in the recycle bin, in bytes. Read-only.
+        :param int remaining: Total space remaining before reaching the quota limit, in bytes. Read-only.
+        :param str state: Enumeration value that indicates the state of the storage space. Read-only.
+        """
+        self.deleted = deleted
+        self.remaining = remaining
+        self.state = state

office365/onedrive/drives/recipient.py

@@ -21,4 +21,8 @@ class DriveRecipient(ClientValue):
 
     @staticmethod
     def from_email(value):
+        """
+        Creates Drive recipient from email address
+        :type value: str
+        """
         return DriveRecipient(email=value)

office365/onedrive/files/system_info.py

@@ -5,12 +5,14 @@ class FileSystemInfo(ClientValue):
     """The FileSystemInfo resource contains properties that are reported by the device's local file system for the
     local version of an item. """
 
-    def __init__(self, created_date_time=None):
+    def __init__(self, created_datetime=None, last_accessed_datetime=None, last_modified_datetime=None):
         """
-        :param str created_date_time: The UTC date and time the file was created on a client.
-
+        :param datetime.datetime created_datetime: The UTC date and time the file was created on a client.
+        :param datetime.datetime last_accessed_datetime: The UTC date and time the file was last accessed.
+            Available for the recent file list only.
+        :param datetime.datetime last_modified_datetime: The UTC date and time the file was last modified on a client.
         """
         super(FileSystemInfo, self).__init__()
-        self.createdDateTime = created_date_time
-        self.lastAccessedDateTime = None
-        self.lastModifiedDateTime = None
+        self.createdDateTime = created_datetime
+        self.lastAccessedDateTime = last_accessed_datetime
+        self.lastModifiedDateTime = last_modified_datetime

office365/onedrive/folders/folder.py

@@ -1,3 +1,4 @@
+from office365.onedrive.folders.view import FolderView
 from office365.runtime.client_value import ClientValue
 
 
@@ -7,11 +8,10 @@ class Folder(ClientValue):
     DriveItems with a non-null folder facet are containers for other DriveItems.
     """
 
-    def __init__(self, child_count=None, view=None):
+    def __init__(self, child_count=None, view=FolderView()):
         """
         :param int child_count: Number of children contained immediately within this container.
-        :param office365.onedrive.folderView.FolderView view: A collection of properties defining the recommended
-             view for the folder.
+        :param FolderView view: A collection of properties defining the recommended view for the folder.
         """
         super(Folder, self).__init__()
         self.childCount = child_count

office365/onedrive/internal/paths/children.py

@@ -10,8 +10,5 @@ class ChildrenPath(EntityPath):
     @property
     def collection(self):
         if self._collection is None:
-            if isinstance(self.parent, EntityPath):
-                self._collection = self.parent.collection
-            else:
-                self._collection = self.parent.parent
+            self._collection = self.parent.collection
         return self._collection

office365/onedrive/internal/paths/shared.py

@@ -4,6 +4,10 @@ from office365.runtime.paths.resource_path import ResourcePath
 
 
 def _url_to_shared_token(url):
+    """
+    Converts url into shared token
+    :param str url:
+    """
     value = base64.b64encode(url.encode("ascii")).decode("ascii")
     if value.endswith("="):
         value = value[:-1]
@@ -13,5 +17,6 @@ def _url_to_shared_token(url):
 class SharedPath(ResourcePath):
     """Shared token path"""
 
-    def __init__(self, url, parent=None):
-        super(SharedPath, self).__init__(_url_to_shared_token(url), parent)
+    @property
+    def segment(self):
+        return _url_to_shared_token(self.key)