Office365-REST-Python-Client 3.0.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

office365/onedrive/contenttypes/content_type.py

@@ -18,6 +18,7 @@ from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.function import FunctionQuery
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.runtime.types.collections import StringCollection
+from office365.runtime.types.odata_property import odata
 
 
 class ContentType(BaseItem):
@@ -72,6 +73,7 @@ class ContentType(BaseItem):
         self.context.add_query(qry)
         return self
 
+    @odata(name="associatedHubsUrls")
     @property
     def associated_hubs_urls(self) -> StringCollection:
         """
@@ -81,11 +83,13 @@ class ContentType(BaseItem):
         """
         return self.properties.get("associatedHubsUrls", StringCollection())
 
+    @odata(name="documentSet")
     @property
     def document_set(self) -> DocumentSet:
         """Document Set metadata."""
         return self.properties.get("documentSet", DocumentSet())
 
+    @odata(name="documentTemplate")
     @property
     def document_template(self) -> DocumentSetContent:
         """
@@ -129,6 +133,7 @@ class ContentType(BaseItem):
         """If true, the content type cannot be modified unless this value is first set to false."""
         return self.properties.get("readOnly", None)
 
+    @odata(name="inheritedFrom")
     @property
     def inherited_from(self) -> ItemReference:
         """
@@ -137,6 +142,7 @@ class ContentType(BaseItem):
         """
         return self.properties.get("inheritedFrom", ItemReference())
 
+    @odata(name="columnLinks")
     @property
     def column_links(self) -> EntityCollection[ColumnLink]:
         """The collection of columns that are required by this content type"""
@@ -157,6 +163,7 @@ class ContentType(BaseItem):
             ContentType(self.context, ResourcePath("base", self.resource_path)),
         )
 
+    @odata(name="baseTypes")
     @property
     def base_types(self) -> EntityCollection[ContentType]:
         """The collection of content types that are ancestors of this content type."""
@@ -177,6 +184,7 @@ class ContentType(BaseItem):
             ),
         )
 
+    @odata(name="columnPositions")
     @property
     def column_positions(self) -> EntityCollection[ColumnDefinition]:
         """Column order information in a content type."""
@@ -193,16 +201,3 @@ class ContentType(BaseItem):
     def order(self) -> ContentTypeOrder:
         """Specifies the order in which the content type appears in the selection UI."""
         return self.properties.get("order", ContentTypeOrder())
-
-    def get_property(self, name, default_value=None):
-        if default_value is None:
-            property_mapping = {
-                "columnLinks": self.column_links,
-                "documentSet": self.document_set,
-                "documentTemplate": self.document_template,
-                "columnPositions": self.column_positions,
-                "baseTypes": self.base_types,
-                "inheritedFrom": self.inherited_from,
-            }
-            default_value = property_mapping.get(name, None)
-        return super().get_property(name, default_value)

office365/onedrive/documentsets/version.py

@@ -5,6 +5,7 @@ from office365.directory.permissions.identity_set import IdentitySet
 from office365.onedrive.documentsets.version_item import DocumentSetVersionItem
 from office365.onedrive.versions.list_item import ListItemVersion
 from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.types.odata_property import odata
 
 
 class DocumentSetVersion(ListItemVersion):
@@ -15,6 +16,7 @@ class DocumentSetVersion(ListItemVersion):
         """Comment about the captured version."""
         return self.properties.get("comment", None)
 
+    @odata(name="createdBy")
     @property
     def created_by(self) -> IdentitySet:
         """User who captured the version."""
@@ -38,17 +40,12 @@ class DocumentSetVersion(ListItemVersion):
         """
         return self.properties.get("shouldCaptureMinorVersion", None)
 
+    @odata(name="createdDateTime")
     @property
     def created_date_time(self) -> datetime:
         """Gets the createdDateTime property"""
         return self.properties.get("createdDateTime", datetime.min)
 
-    def get_property(self, name, default_value=None):
-        if default_value is None:
-            property_mapping = {"createdBy": self.created_by, "createdDateTime": self.created_datetime}
-            default_value = property_mapping.get(name, None)
-        return super().get_property(name, default_value)
-
     @property
     def entity_type_name(self) -> str:
         return "microsoft.graph.DocumentSetVersion"

office365/onedrive/driveitems/audio.py

@@ -18,3 +18,19 @@ class Audio(ClientValue):
     albumArtist: str | None = None
     artist: str | None = None
     bitrate: int | None = None
+    composers: str | None = None
+    copyright: str | None = None
+    duration: int | None = None
+    genre: str | None = None
+    hasDrm: bool | None = None
+    isVariableBitrate: bool | None = None
+    title: str | None = None
+    track: int | None = None
+    trackCount: int | None = None
+    year: int | None = None
+    disc: int | None = None
+    discCount: int | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Audio"

office365/onedrive/driveitems/bundle.py

@@ -13,3 +13,7 @@ class Bundle(ClientValue):
 
     album: str | None = None
     childCount: int | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Bundle"

office365/onedrive/driveitems/driveItem.py

@@ -6,12 +6,13 @@ from functools import partial
 from io import IOBase
 from os import PathLike
 from os.path import isfile, join
-from typing import IO, AnyStr, Callable
+from typing import IO, AnyStr, Callable, Optional
 
 import requests
 from requests import Response
 from typing_extensions import Self
 
+from office365.delta_collection import DeltaCollection
 from office365.delta_path import DeltaPath
 from office365.directory.permissions.require_permission import require_permission
 from office365.entity_collection import EntityCollection
@@ -58,6 +59,7 @@ from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.http.request_options import RequestOptions
 from office365.runtime.odata.v4.upload_session import UploadSession
 from office365.runtime.odata.v4.upload_session_request import UploadSessionRequest
+from office365.runtime.operations import Progress
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.create_entity import CreateEntityQuery
 from office365.runtime.queries.function import FunctionQuery
@@ -120,13 +122,25 @@ class DriveItem(BaseItem):
         self.retention_label.update()
         return self
 
-    def get_files(self, recursive: bool = False, page_size: int | None = None) -> EntityCollection[DriveItem]:
+    def get_files(
+        self,
+        recursive: bool = False,
+        page_size: int | None = None,
+        progress: Optional[Callable[[Progress[DriveItem]], None]] = None,
+    ) -> EntityCollection[DriveItem]:
         """Retrieves files
 
         Args:
             recursive (bool): Determines whether to enumerate folders recursively
             page_size (int): Page size
+            progress: Optional hook invoked per page with a ``Progress[DriveItem]``
+              snapshot (``done`` = files discovered so far; ``items`` = the page's items).
+
+        The fluent ``.select([...])`` / ``.expand([...])`` applied to the returned
+        collection is honored on every ``children`` page the scan loads.
         """
+        from office365.runtime.queries.deferred import DeferredOperationQuery
+
         return_type = EntityCollection(self.context, DriveItem, self.resource_path)
 
         def _get_files(parent_drive_item: DriveItem) -> None:
@@ -140,19 +154,39 @@ class DriveItem(BaseItem):
                             _get_files(drive_item)
                     else:
                         return_type.add_child(drive_item)
-
-            parent_drive_item.children.get_all(page_size=page_size, page_loaded=_after_loaded)
-
-        _get_files(self)
+                if callable(progress):
+                    progress(Progress(done=len(return_type), stage="scanning", items=list(col)))
+
+            children = parent_drive_item.children
+            return_type.query_options.apply_to(children)
+            if return_type.query_options.select:
+                fields = sorted({"folder", "id"} | set(return_type.query_options.select))
+                children.select(fields)
+            children.get_all(page_size=page_size, page_loaded=_after_loaded)
+
+        placeholder = DeferredOperationQuery(self.context)
+        self.context.add_query(placeholder).after_execute(lambda _: _get_files(self))
         return return_type
 
-    def get_folders(self, recursive: bool = False, page_size: int | None = None) -> EntityCollection[DriveItem]:
+    def get_folders(
+        self,
+        recursive: bool = False,
+        page_size: int | None = None,
+        progress: Optional[Callable[[Progress[DriveItem]], None]] = None,
+    ) -> EntityCollection[DriveItem]:
         """Retrieves folders
 
         Args:
             recursive (bool): Determines whether to enumerate folders recursively
             page_size (int): Page size
+            progress: Optional hook invoked per page with a ``Progress[DriveItem]``
+              snapshot (``done`` = folders discovered so far; ``items`` = the page's items).
+
+        The fluent ``.select([...])`` / ``.expand([...])`` applied to the returned
+        collection is honored on every ``children`` page the scan loads.
         """
+        from office365.runtime.queries.deferred import DeferredOperationQuery
+
         return_type = EntityCollection(self.context, DriveItem, self.resource_path)
 
         def _get_folders(parent: DriveItem) -> None:
@@ -164,10 +198,18 @@ class DriveItem(BaseItem):
                     if recursive and drive_item.folder.childCount is not None and drive_item.folder.childCount > 0:
                         _get_folders(drive_item)
                     return_type.add_child(drive_item)
-
-            parent.children.filter("folder ne null").get_all(page_size=page_size, page_loaded=_after_loaded)
-
-        _get_folders(self)
+                if callable(progress):
+                    progress(Progress(done=len(return_type), stage="scanning", items=list(col)))
+
+            children = parent.children.filter("folder ne null")
+            return_type.query_options.apply_to(children)
+            if return_type.query_options.select:
+                fields = sorted({"folder", "id"} | set(return_type.query_options.select))
+                children.select(fields)
+            children.get_all(page_size=page_size, page_loaded=_after_loaded)
+
+        placeholder = DeferredOperationQuery(self.context)
+        self.context.add_query(placeholder).after_execute(lambda _: _get_folders(self))
         return return_type
 
     @require_permission(
@@ -186,6 +228,138 @@ class DriveItem(BaseItem):
         """Retrieve DriveItem by server relative path"""
         return DriveItem(self.context, UrlPath(url_path, self.resource_path), self.children)
 
+    @require_permission(
+        delegated=["Files.ReadWrite", "Files.ReadWrite.All", "Sites.ReadWrite.All"],
+        application=["Files.ReadWrite.All", "Sites.ReadWrite.All"],
+        notes="Ensure a nested folder exists in a drive",
+    )
+    def ensure_folder(self, url_path: str) -> DriveItem:
+        """Ensure a folder exists at the given path, creating missing levels.
+
+        Walks the path segment by segment (e.g. ``"2024/Q1/Reports"``) and, per
+        level, reuses the existing folder when present or creates it otherwise.
+        Fully deferred — run the chain with ``execute_query()`` and the returned
+        item addresses the target folder:
+
+            >>> folder = drive_item.ensure_folder("2024/Q1/Reports").execute_query()
+
+        Args:
+            url_path (str): Path to the folder, relative to this item.
+
+        Returns:
+            DriveItem: The target folder (existing or newly created).
+        """
+        names = self._split_path(url_path)
+        if not names:
+            raise ValueError("Path is empty")
+        return_type = DriveItem(self.context)
+
+        def _on_resolved(folder: DriveItem) -> None:
+            return_type._resource_path = folder._resource_path
+            return_type.copy_from(folder)
+
+        self._resolve_path(names, _on_resolved)
+        return return_type
+
+    @staticmethod
+    def _split_path(path: str) -> list[str]:
+        """Split a (server-relative) path into non-empty segments."""
+        return [name for name in path.replace("\\", "/").split("/") if name]
+
+    def _resolve_path(self, names: list[str], on_resolved: Callable[[DriveItem], None]) -> None:
+        """Walk and create the folders in ``names``, then call ``on_resolved`` with the resolved folder.
+
+        Reuses an existing folder per level or creates the missing one. The
+        callback receives a query-bound parent entity, so callers can queue
+        further work (e.g. a file upload) that depends on the parent id. With no
+        names the callback runs synchronously against ``self``.
+
+        Args:
+            names (list[str]): Folder names, relative to this item.
+            on_resolved (Callable[[DriveItem], None]): Invoked with the resolved folder.
+        """
+        from office365.runtime.exceptions import ObjectNotFoundException
+
+        def _walk(parent: DriveItem, idx: int) -> None:
+            if idx == len(names):
+                on_resolved(parent)
+                return
+
+            child = parent.get_by_path(names[idx])
+
+            def _on_found(_) -> None:
+                _walk(child, idx + 1)
+
+            def _on_missing(error) -> None:
+                if not isinstance(error, ObjectNotFoundException):
+                    raise error
+                created = parent.create_folder(names[idx])
+                created.after_execute(lambda _: _reload(idx))
+
+            child.get().after_execute(_on_found).on_error(_on_missing)
+
+        def _reload(idx: int) -> None:
+            # Re-resolve the freshly created folder by path so the next level has
+            # a stable, addressable parent entity.
+            prefix = "/".join(names[: idx + 1])
+            self.get_by_path(prefix).get().after_execute(lambda resolved: _walk(resolved, idx + 1))
+
+        _walk(self, 0)
+
+    @require_permission(
+        delegated=["Files.ReadWrite", "Files.ReadWrite.All", "Sites.ReadWrite.All"],
+        application=["Files.ReadWrite.All", "Sites.ReadWrite.All"],
+        notes="Ensure a file exists in a drive, uploading its content when missing",
+    )
+    def ensure_file(self, relative_path: str, content: bytes | str = b"", *, on_conflict: str = "skip") -> DriveItem:
+        """Ensure a file exists at the given path, uploading content when needed.
+
+        The file counterpart of :meth:`ensure_folder`: missing parent folders are
+        created (via :meth:`ensure_folder`), then the leaf file is resolved —
+        reusing the existing file or uploading ``content`` when absent. Fully
+        deferred — run the chain with ``execute_query()`` and the returned item
+        addresses the target file:
+
+            >>> file = drive_item.ensure_file("2024/Q1/placeholder.txt").execute_query()
+
+        Args:
+            relative_path (str): File name or path relative to this item, e.g.
+                ``"report.txt"`` or ``"2024/Q1/report.txt"``.
+            content (bytes or str): File content; ``str`` is encoded as UTF-8.
+            on_conflict (str): Behaviour when the file already exists.
+                ``"skip"`` (default) leaves it untouched, so a re-run is a no-op
+                and ``content`` is never sent; ``"replace"`` overwrites it with
+                ``content`` in a single request.
+
+        Returns:
+            DriveItem: The target file (existing or newly uploaded).
+        """
+        from office365.runtime.queries.get_or_create import get_or_create
+
+        if on_conflict not in ("skip", "replace"):
+            raise ValueError(f"on_conflict must be 'skip' or 'replace', got {on_conflict!r}")
+        names = self._split_path(relative_path)
+        if not names:
+            raise ValueError("Path is empty")
+        name = names[-1]
+        data = content.encode("utf-8") if isinstance(content, str) else content
+        return_type = DriveItem(self.context)
+
+        def _on_resolved(parent_item: DriveItem) -> None:
+            return_type._resource_path = parent_item.get_by_path(name)._resource_path
+            if on_conflict == "replace":
+                parent_item.context.add_query(parent_item._build_upload_query(return_type, data))
+                return
+            get_or_create(
+                find=lambda: parent_item.get_by_path(name).get(),
+                create_query=lambda: parent_item._build_upload_query(return_type, data),
+                return_type=return_type,
+                on_conflict="skip",
+            )
+
+        self._resolve_path(names[:-1], _on_resolved)
+        return return_type
+
     def create_powerpoint(self, name: str) -> DriveItem:
         """Creates a PowerPoint file
 
@@ -253,6 +427,22 @@ class DriveItem(BaseItem):
         self.context.add_query(qry)
         return self
 
+    def delete_object(self, bypass_shared_lock: bool = False) -> Self:
+        """Deletes the driveItem.
+
+        Args:
+            bypass_shared_lock: Send ``Prefer: bypass-shared-lock`` so the delete
+                succeeds even when the item is open for editing. Without it the
+                server rejects the request with
+                :class:`~office365.runtime.exceptions.FileLockedException` (HTTP 423).
+        """
+        super().delete_object()
+        if bypass_shared_lock:
+            from office365.runtime.http.prefer import prefer_bypass_shared_lock
+
+            self.context.before_execute(prefer_bypass_shared_lock, once=True)
+        return self
+
     def extract_sensitivity_labels(
         self,
     ) -> ClientResult[ExtractSensitivityLabelsResult]:
@@ -366,6 +556,24 @@ class DriveItem(BaseItem):
         self.context.add_query(qry)
         return qry.return_type
 
+    def _build_upload_query(self, item: DriveItem, content: bytes | None) -> ServiceOperationQuery[DriveItem]:
+        """Build (but do not queue) the ``PUT .../content`` query for ``item``.
+
+        Shared by :meth:`upload` and :meth:`ensure_file` — the latter needs a
+        query it can hand to ``get_or_create``'s deferred create slot.
+
+        Args:
+            item (DriveItem): The file that receives the content.
+            content (bytes or None): The binary content to upload.
+        """
+        qry = ServiceOperationQuery(item, "content", None, content, None, item)
+
+        def _modify_query(request: RequestOptions) -> None:
+            request.method = HttpMethod.Put
+
+        qry.before_execute(_modify_query)
+        return qry
+
     @require_permission(
         delegated=["Files.ReadWrite", "Files.ReadWrite.All", "Sites.ReadWrite.All"],
         application=["Files.ReadWrite.All", "Sites.ReadWrite.All"],
@@ -376,13 +584,7 @@ class DriveItem(BaseItem):
 
         return_type = DriveItem(self.context, UrlPath(name, self.resource_path))
         self.children.add_child(return_type)
-
-        qry = ServiceOperationQuery(return_type, "content", None, content, None, return_type)
-
-        def _modify_query(request: RequestOptions) -> None:
-            request.method = HttpMethod.Put
-
-        self.context.add_query(qry).before_execute(_modify_query)
+        self.context.add_query(self._build_upload_query(return_type, content))
         return return_type
 
     def upload_file(self, path_or_file: str | PathLike | IOBase) -> DriveItem:
@@ -427,7 +629,7 @@ class DriveItem(BaseItem):
         action_name = "content"
         if format_name is not None:
             action_name = action_name + rf"?format={format_name}"
-        qry = FunctionQuery(self, action_name, None, return_type)
+        qry = FunctionQuery(self, action_name, None, return_type, return_raw_content=True)
         self.context.add_query(qry)
         return return_type
 
@@ -473,21 +675,25 @@ class DriveItem(BaseItem):
                 if callable(after_file_downloaded):
                     after_file_downloaded(drive_item)
 
-        def _after_folder_downloaded(parent_item: DriveItem, base_path: str | None = None) -> None:
-            for drive_item in parent_item.children:
+        def _after_folder_downloaded(children, base_path: str | None = None) -> None:
+            for drive_item in children:
                 if drive_item.is_file:
                     drive_item.get_content().after_execute(partial(_after_file_downloaded, drive_item, base_path))
                 elif recursive:
-                    if base_path is None:
-                        next_base_path = str(drive_item.name)
-                    else:
-                        next_base_path = "/".join([base_path, drive_item.name or ""])
+                    next_base_path = "/".join(filter(None, (base_path, drive_item.name)))
                     _download_folder(drive_item, next_base_path)
 
-        def _download_folder(drive_item: "DriveItem", prev_result: str | None = None) -> None:
-            drive_item.ensure_properties(
-                ["children", "name"],
-            ).after_execute(lambda _: _after_folder_downloaded(drive_item, prev_result))
+        def _download_folder(drive_item: "DriveItem", base_path: str | None = None) -> None:
+            children = drive_item.children
+            processed = {"count": 0}
+
+            def _page_loaded(col) -> None:
+                # pages arrive incrementally — process only the new items
+                new_items = list(col)[processed["count"] :]
+                processed["count"] = len(col)
+                _after_folder_downloaded(new_items, base_path)
+
+            children.get_all(page_loaded=_page_loaded)
 
         _download_folder(self)
         return self
@@ -1033,11 +1239,11 @@ class DriveItem(BaseItem):
         application=["Files.Read.All", "Files.ReadWrite.All", "Sites.Read.All", "Sites.ReadWrite.All"],
         notes="Track changes to a drive item and its children over time",
     )
-    def delta(self) -> EntityCollection["DriveItem"]:
+    def delta(self) -> DeltaCollection["DriveItem"]:
         """Tracks changes to a drive item and its children over time."""
         return self.properties.get(
             "delta",
-            EntityCollection(self.context, DriveItem, DeltaPath(self.resource_path)),
+            DeltaCollection(self.context, DriveItem, DeltaPath(self.resource_path)),
         )
 
     @property

office365/onedrive/driveitems/image.py

@@ -16,3 +16,7 @@ class Image(ClientValue):
 
     height: int | None = None
     width: int | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Image"

office365/onedrive/driveitems/malware.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class Malware(ClientValue):
+    description: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Malware"

office365/onedrive/driveitems/package.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class Package(ClientValue):
+    type: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Package"

office365/onedrive/driveitems/photo.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from datetime import datetime
 
 from office365.runtime.client_value import ClientValue
 
@@ -11,3 +12,14 @@ class Photo(ClientValue):
 
     cameraMake: str | None = None
     cameraModel: str | None = None
+    exposureDenominator: float | None = None
+    exposureNumerator: float | None = None
+    fNumber: float | None = None
+    focalLength: float | None = None
+    iso: int | None = None
+    orientation: int | None = None
+    takenDateTime: datetime | None = field(default_factory=lambda: datetime.min)
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Photo"

office365/onedrive/driveitems/publication_facet.py

@@ -14,3 +14,7 @@ class PublicationFacet(ClientValue):
     checkedOutBy: IdentitySet | None = field(default_factory=IdentitySet)
     level: str | None = None
     versionId: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.PublicationFacet"

office365/onedrive/driveitems/remote_item.py

@@ -5,9 +5,13 @@ from datetime import datetime
 
 from office365.directory.permissions.identity_set import IdentitySet
 from office365.onedrive.driveitems.image import Image
+from office365.onedrive.driveitems.package import Package
+from office365.onedrive.driveitems.special_folder import SpecialFolder
+from office365.onedrive.driveitems.video import Video
 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.listitems.item_reference import ItemReference
 from office365.onedrive.shares.shared import Shared
 from office365.runtime.client_value import ClientValue
 
@@ -30,3 +34,17 @@ class RemoteItem(ClientValue):
     folder: Folder | None = field(default_factory=Folder)
     image: Image | None = field(default_factory=Image)
     shared: Shared | None = field(default_factory=Shared)
+    lastModifiedBy: IdentitySet = field(default_factory=IdentitySet)
+    lastModifiedDateTime: datetime | None = field(default_factory=lambda: datetime.min)
+    name: str | None = None
+    package: Package = field(default_factory=Package)
+    parentReference: ItemReference = field(default_factory=ItemReference)
+    size: int | None = None
+    specialFolder: SpecialFolder = field(default_factory=SpecialFolder)
+    video: Video = field(default_factory=Video)
+    webDavUrl: str | None = None
+    webUrl: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.RemoteItem"

office365/onedrive/driveitems/special_folder.py

@@ -10,3 +10,7 @@ class SpecialFolder(ClientValue):
     """The SpecialFolder resource groups special folder-related data items into a single structure."""
 
     name: str | None = None
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.SpecialFolder"

office365/onedrive/driveitems/uploadable_properties.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, cast
 
 from office365.onedrive.driveitems.source import DriveItemSource
 from office365.onedrive.files.system_info import FileSystemInfo
@@ -28,7 +28,7 @@ class DriveItemUploadableProperties(ClientValue):
         return self._fileSize
 
     def to_json(self, json_format: Optional[ODataJsonFormat] = None) -> Dict[str, Any]:
-        payload = super().to_json(json_format)
+        payload = cast(Dict[str, Any], super().to_json(json_format))
         payload.pop("driveItemSource", None)
         payload.pop("mediaSource", None)
         return payload

office365/onedrive/driveitems/video.py

@@ -7,4 +7,18 @@ from office365.runtime.client_value import ClientValue
 
 @dataclass
 class Video(ClientValue):
-    """The Video resource groups video-related data items into a single structure."""
+    audioBitsPerSample: int | None = None
+    audioChannels: int | None = None
+    audioFormat: str | None = None
+    audioSamplesPerSecond: int | None = None
+    bitrate: int | None = None
+    duration: int | None = None
+    fourCC: str | None = None
+    frameRate: float | None = None
+    height: int | None = None
+    width: int | None = None
+    "The Video resource groups video-related data items into a single structure."
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.Video"