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

office365/migration/sharepoint/scanners/locked_sites.py

@@ -0,0 +1,38 @@
+"""Locked Sites scan — the SMAT ``LockedSites`` report.
+
+Sites configured as **No Access** (locked) in SharePoint can't be migrated — the
+tooling can't read their contents — so the migration scans skip them. This scan
+lists every locked site collection (``URL`` + ``ScanID``), driven by the tenant
+walker over ``SPO.Tenant.SiteProperties.LockState``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.summary import SiteScanSummary
+
+_LOCKED_STATES = {"NoAccess", "Locked"}
+
+
+@dataclass
+class LockedSitesRecord:
+    """One row of the SMAT ``LockedSites-detail`` report."""
+
+    URL: str | None = None
+    ScanID: str | None = None
+
+
+class SiteLockedScanner(BaseScanner[LockedSitesRecord]):
+    """SITE-container scan: reports site collections configured as No Access (locked)."""
+
+    category = "site"
+    scan_name = "LockedSites"
+    record_type = LockedSitesRecord
+
+    def run(self, target: ScanTarget[SiteScanSummary], report: AssessmentReport) -> None:
+        summary = target.entity
+        if summary.lock_state in _LOCKED_STATES:
+            self.records.append(LockedSitesRecord(URL=summary.site_url, ScanID=report.scan_id or None))

office365/migration/sharepoint/scanners/long_onedrive_urls.py

@@ -0,0 +1,52 @@
+"""Long OneDrive URLs scan — the SMAT ``LongOneDriveUrls`` report.
+
+OneDrive and SharePoint sync fail on file paths whose decoded URL exceeds the
+sync limit, so before a migration it is worth listing them. This ``ITEMS``
+container report measures each file's full URL (the tenant origin plus its
+server-relative path) against ``Limits.LONG_ONEDRIVE_URL``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, site_url
+
+
+@dataclass
+class LongOneDriveUrlsRecord(SiteScanRecord):
+    """One row of the SMAT ``LongOneDriveUrls-detail`` report."""
+
+    File: str | None = None
+    UrlLength: int | None = None
+    ScanID: str | None = None
+
+
+class LongOneDriveUrlsScanner(BaseScanner[LongOneDriveUrlsRecord]):
+    """Reports files whose full URL is over the OneDrive sync limit (SMAT ``LongOneDriveUrls``)."""
+
+    category = "file"
+    scan_name = "LongOneDriveUrls"
+    record_type = LongOneDriveUrlsRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        limit = self.options.limit("long_onedrive_url")
+        location = site_url(target.location)
+        parts = urlsplit(target.location or "")
+        origin = f"{parts.scheme}://{parts.netloc}" if parts.scheme and parts.netloc else ""
+        for item in target.entity:
+            path = item.properties.get("FileRef", "")
+            url = f"{origin}{path}"
+            if len(url) <= limit.value:
+                continue
+            self.records.append(
+                LongOneDriveUrlsRecord(
+                    SiteURL=location,
+                    File=path,
+                    UrlLength=len(url),
+                    ScanID=report.scan_id or None,
+                )
+            )

office365/migration/sharepoint/scanners/lookup.py

@@ -0,0 +1,38 @@
+"""Lookup column scan — the SPMT ``LIST_VIEW_LOOKUP_EXCEED_LIMIT`` check.
+
+A ``FIELDS``-container scan: displaying/querying too many lookup, person/group,
+or managed-metadata columns trips the list view lookup threshold (8 joins
+blocked, 12 returned), so the list view (and some tooling) can fail.
+"""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
+
+_LOOKUP_TYPES = frozenset({"Lookup", "LookupMulti", "User", "UserMulti", "TaxonomyFieldType", "TaxonomyFieldTypeMulti"})
+
+
+class LookupColumnScanner(BaseScanner):
+    """Flags lists whose lookup/people/managed-metadata columns exceed the lookup threshold."""
+
+    category = "field"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        lookups = [
+            field.properties.get("InternalName", "")
+            for field in target.entity
+            if field.properties.get("TypeAsString") in _LOOKUP_TYPES
+        ]
+        limit = self.options.limit("lookup_joins")
+        if len(lookups) > limit.value:
+            self.flag(
+                report,
+                "warning",
+                target.location,
+                hint(limit, value=len(lookups), context="list"),
+                "Reduce the lookup columns or raise the resource-throttling limit",
+                risk_code="LIST_VIEW_LOOKUP_EXCEED_LIMIT",
+                limit=limit,
+            )

office365/migration/sharepoint/scanners/paths.py

@@ -0,0 +1,50 @@
+"""Path scanner — SharePoint path/name constraints that block a migration."""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
+
+
+class PathScanner(BaseScanner):
+    """Flags path/name length overruns and invalid characters."""
+
+    category = "path"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        path_limit = self.options.limit("max_path_length")
+        name_limit = self.options.limit("max_name_length")
+        for item in target.entity:
+            path = item.properties.get("FileRef", "")
+            name = item.properties.get("FileLeafRef", "")
+
+            if len(path) > path_limit.value:
+                self.flag(
+                    report,
+                    "blocker",
+                    path,
+                    hint(path_limit, value=len(path), context="path"),
+                    "Shorten folder names or restructure hierarchy",
+                    limit=path_limit,
+                )
+
+            if len(name) > name_limit.value:
+                self.flag(
+                    report,
+                    "blocker",
+                    path,
+                    hint(name_limit, value=len(name), context="file name"),
+                    "Rename file before migration",
+                    limit=name_limit,
+                )
+
+            bad = [c for c in name if c in self.options.invalid_chars]
+            if bad:
+                self.flag(
+                    report,
+                    "blocker",
+                    path,
+                    f"File name contains invalid chars: {bad}",
+                    "Rename file — remove invalid characters",
+                )

office365/migration/sharepoint/scanners/permissions.py

@@ -0,0 +1,42 @@
+"""Permission scanner — broken permission inheritance (expensive)."""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
+
+
+class PermissionScanner(BaseScanner):
+    """Flags lists with items that have unique role assignments."""
+
+    category = "permission"
+    items_load = "unique"  # requires the paged unique-permission items projection
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        unique = sum(1 for i in target.entity if i.properties.get("HasUniqueRoleAssignments", False))
+        supported = self.options.limit("unique_scopes")
+        recommended = self.options.limit("recommended_unique_scopes")
+        if unique > supported.value:
+            self.flag(
+                report,
+                "blocker",
+                target.location,
+                hint(supported, value=unique, context="list"),
+                "Reduce the number of uniquely-permitted items before migrating",
+                risk_code="UNIQUE_PERMISSION_EXCEED_LIMIT",
+                limit=supported,
+            )
+        elif unique > 0:
+            over_recommended = unique > recommended.value
+            self.flag(
+                report,
+                "warning",
+                target.location,
+                hint(recommended, value=unique, context="list")
+                if over_recommended
+                else f"{unique} items have unique permissions",
+                "Set preserve_permissions=True in MigrationOptions (slower migration)",
+                risk_code="UNIQUE_PERMISSION_EXCEED_LIMIT",
+                limit=recommended if over_recommended else None,
+            )

office365/migration/sharepoint/scanners/smat.py

@@ -0,0 +1,51 @@
+"""Shared SMAT detail-report scaffolding.
+
+Every SMAT ``<Scan>-detail.csv`` starts with the same site-collection context
+columns (``SiteId … DaysOfUsageData``). :class:`SiteScanRecord` declares that
+prefix once; each report scan subclasses it and appends its own columns (the
+dataclass fields ARE the report columns, base-first).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+__all__ = ["SiteScanRecord", "file_extension", "site_url"]
+
+
+@dataclass
+class SiteScanRecord:
+    """The SMAT detail-report site-collection column prefix.
+
+    ``None`` renders as ``n/a`` (the report convention for unavailable data);
+    the ``ContentDB*`` and usage-logging columns only exist on-premises.
+    """
+
+    SiteId: str | None = None
+    SiteURL: str | None = None
+    SiteOwner: str | None = None
+    SiteAdmins: str | None = None
+    SiteSizeInMB: float | None = None
+    NumOfWebs: int | None = None
+    ContentDBName: str | None = None
+    ContentDBServerName: str | None = None
+    ContentDBSizeInMB: str | None = None
+    LastContentModifiedDate: datetime | None = None
+    TotalItemCount: int | None = None
+    Hits: int | None = None
+    DistinctUsers: str | None = None
+    DaysOfUsageData: str | None = None
+
+
+def file_extension(item: Any) -> str:
+    """The item's lower-cased extension including the dot (``""`` when none)."""
+    name = item.properties.get("FileLeafRef") or ""
+    _, dot, extension = name.rpartition(".")
+    return f".{extension.lower()}" if dot and extension else ""
+
+
+def site_url(location: str | None) -> str | None:
+    """Best-effort site/web URL from a scan location (``<web>/lists/<title>``)."""
+    return location.rsplit("/lists/", 1)[0] if location and "/lists/" in location else None

office365/migration/sharepoint/scanners/summary.py

@@ -0,0 +1,38 @@
+"""Site collection scan summary — the SharePoint ``SITE``-container payload.
+
+Built by the SharePoint walkers (single-site and tenant) and handed to
+``SITE``-container scans once the whole subtree has settled.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SiteScanSummary:
+    """The site collection's scan state, aggregated by the walker.
+
+    Built as the walker visits the site collection (usage), its web tree
+    (``web_count``) and every list (``item_count``, ``last_modified``); handed
+    to ``SITE``-container scans once the whole subtree has settled.
+
+    The tenant walker populates it from ``SiteProperties`` instead and sets
+    ``report_impacted_only`` so SMAT-style scans only list impacted sites
+    (e.g. LargeSites lists only collections over the threshold, and locked
+    ones are surfaced by the LockedSites scan).
+    """
+
+    site_id: str | None = None
+    site_url: str | None = None
+    owner: str | None = None
+    admins: str | None = None
+    storage_bytes: int | None = None
+    hits: int | None = None
+    web_count: int = 0
+    item_count: int = 0
+    last_modified: Any | None = None
+    lock_state: str | None = None
+    web_template: str | None = None
+    report_impacted_only: bool = False

office365/migration/sharepoint/scanners/thicket_folders.py

@@ -0,0 +1,38 @@
+"""Thicket folders scan — the SPMT ``THICKET_FOLDER_UNSUPPORTED`` risk.
+
+Folders whose name ends in ``_file`` or ``_files`` are treated as *thicket*
+folders — the hidden linked folder SharePoint creates to store the supporting
+content of an HTM file. SharePoint in Microsoft 365 can't create them, so a
+migration carrying such a folder fails. This ``ITEMS``-container scan flags each
+one so it can be renamed first.
+"""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+
+#: Folder-name suffixes SharePoint treats as thicket folders.
+_THICKET_SUFFIXES = ("_file", "_files")
+
+
+class ThicketFolderScanner(BaseScanner):
+    """Flags folders whose name ends in ``_file``/``_files``."""
+
+    category = "file"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        for item in target.entity:
+            if getattr(item, "file", None) is not None:
+                continue  # a file, not a folder
+            name = item.properties.get("FileLeafRef", "")
+            if not name.lower().endswith(_THICKET_SUFFIXES):
+                continue
+            self.flag(
+                report,
+                "blocker",
+                item.properties.get("FileRef", "") or name,
+                f"Thicket folder '{name}' isn't supported in SharePoint in Microsoft 365",
+                "Rename the folder so it no longer ends in '_file'/'_files'",
+                risk_code="THICKET_FOLDER_UNSUPPORTED",
+            )

office365/migration/sharepoint/scanners/unsupported_site_templates.py

@@ -0,0 +1,90 @@
+"""Unsupported site templates scan — the SMAT ``UnsupportedSiteTemplates`` report.
+
+A site collection created from an on-premises-only site definition (a Central
+Administration site, a My Site host, a meeting workspace, an Access services
+database, ...) has no Microsoft 365 equivalent, so it can't be migrated as-is.
+This ``SITE``-container report lists the collections whose root web template is
+in that legacy set.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.summary import SiteScanSummary
+from office365.sharepoint.webs.templates import WebTemplateType
+
+#: Templates with no Microsoft 365 equivalent — a collection built from one can't
+#: be migrated as-is. Held as template names (the part before ``#``) so the match
+#: is independent of the site-definition configuration id.
+_UNSUPPORTED_TEMPLATES = frozenset(
+    template.name_part.upper()
+    for template in (
+        WebTemplateType.CENTRAL_ADMIN,
+        WebTemplateType.TENANT_ADMIN,
+        WebTemplateType.SHAREPOINT_ONLINE_TENANT_ADMIN,
+        WebTemplateType.SHARED_SERVICES_ADMINISTRATION,
+        WebTemplateType.SHAREPOINT_PORTAL_SERVER_SITE,
+        WebTemplateType.SHAREPOINT_PORTAL_PERSONAL_SPACE,
+        WebTemplateType.PERSONALIZATION_SITE,
+        WebTemplateType.MY_SITE_HOST,
+        WebTemplateType.CONTENTS_AREA,
+        WebTemplateType.TOPIC_AREA,
+        WebTemplateType.NEWS_SITE,
+        WebTemplateType.NEWS_HOME,
+        WebTemplateType.SITE_DIRECTORY,
+        WebTemplateType.COMMUNITY_AREA,
+        WebTemplateType.COLLABORATION_PORTAL,
+        WebTemplateType.REPORT_CENTER,
+        WebTemplateType.PROFILES,
+        WebTemplateType.ACCESS_SERVICES,
+        WebTemplateType.ASSETS_WEB_DATABASE,
+        WebTemplateType.CHARITABLE_CONTRIBUTIONS_WEB_DATABASE,
+        WebTemplateType.CONTACTS_WEB_DATABASE,
+        WebTemplateType.ISSUES_WEB_DATABASE,
+        WebTemplateType.PROJECTS_WEB_DATABASE,
+        WebTemplateType.DOCUMENT_CENTER,
+        WebTemplateType.EXPRESS_TEAM_SITE,
+        WebTemplateType.EXPRESS_HOSTED_SITE,
+        WebTemplateType.MEETING_BASIC,
+        WebTemplateType.MEETING_BLANK,
+        WebTemplateType.MEETING_DECISION,
+        WebTemplateType.MEETING_SOCIAL,
+        WebTemplateType.MEETING_MULTIPAGE,
+        WebTemplateType.POWERPOINT_BROADCAST,
+        WebTemplateType.BUSINESS_INTELLIGENCE_CENTER,
+        WebTemplateType.VISIO_PROCESS_REPOSITORY,
+    )
+)
+
+
+@dataclass
+class UnsupportedSiteTemplatesRecord:
+    """One row of the SMAT ``UnsupportedSiteTemplates-detail`` report."""
+
+    URL: str | None = None
+    Template: str | None = None
+    ScanID: str | None = None
+
+
+class UnsupportedSiteTemplatesScanner(BaseScanner[UnsupportedSiteTemplatesRecord]):
+    """SITE-container scan: reports legacy site templates with no Microsoft 365 equivalent."""
+
+    category = "site"
+    scan_name = "UnsupportedSiteTemplates"
+    record_type = UnsupportedSiteTemplatesRecord
+
+    def run(self, target: ScanTarget[SiteScanSummary], report: AssessmentReport) -> None:
+        summary = target.entity
+        template = summary.web_template
+        if not template or template.split("#", 1)[0].upper() not in _UNSUPPORTED_TEMPLATES:
+            return
+        self.records.append(
+            UnsupportedSiteTemplatesRecord(
+                URL=summary.site_url,
+                Template=template,
+                ScanID=report.scan_id or None,
+            )
+        )

office365/migration/sharepoint/tenant_assessor.py

@@ -0,0 +1,95 @@
+"""
+Tenant-scope pre-migration assessment (the TENANT container walker).
+
+Enumerates **all site collections** through the SharePoint Online tenant admin
+API and runs every enabled SITE-container scan from ``assessment.registry``
+against each site's property bag — e.g. the SMAT ``LargeSites`` and
+``LockedSites`` reports across the whole tenant, without per-site web-tree
+enumeration. Mirrors SMAT's farm-level scan: the site list comes from the
+tenant first, then each site collection is checked.
+
+Requires SharePoint admin access (``SPO.Tenant`` read). Use
+``ClientContext(admin_site_url)`` + ``Tenant(ctx)``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from office365.migration.assessment.containers import ScanContainer
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.runner import ScanRunner
+from office365.migration.assessment.scanners import AssessmentOptions
+from office365.migration.sharepoint.options import SharePointAssessmentOptions
+from office365.migration.sharepoint.registry import sharepoint_scan_pairs
+from office365.migration.sharepoint.scanners.summary import SiteScanSummary
+from office365.runtime.client_result import ClientResult
+from office365.runtime.converters.scalars import parse_int
+from office365.runtime.operations import emit_progress
+from office365.sharepoint.entity import Entity
+
+if TYPE_CHECKING:
+    from office365.runtime.operations import Progress
+    from office365.sharepoint.tenant.administration.tenant import Tenant
+
+
+def _clean_modified(value) -> datetime | None:
+    """Drop the naive ``datetime.min`` sentinel (unset) without comparing aware vs naive."""
+    if value is None:
+        return None
+    if value.tzinfo is None and value == datetime.min:
+        return None
+    return value
+
+
+class MigrationTenantAssessor(Entity):
+    """Tenant-scope assessment driven by the ``SPO.Tenant`` site-property bag."""
+
+    def __init__(self, tenant: "Tenant", options: AssessmentOptions | None = None) -> None:
+        super().__init__(tenant.context)
+        self._tenant = tenant
+        self._options = options or SharePointAssessmentOptions()
+
+    def assess(
+        self,
+        progress: Callable[["Progress"], None] | None = None,
+    ) -> ClientResult[AssessmentReport]:
+        """Enumerate all site collections and run the SITE-container scans.
+
+        Args:
+            progress: Optional hook fired per site collection as it is checked.
+        """
+        return_type = ClientResult[AssessmentReport](self.context, AssessmentReport.new())
+        runner = ScanRunner(sharepoint_scan_pairs(self._options, tenant_scope=True), report=return_type.value)
+        report = runner.report
+        done = {"count": 0}
+
+        def _progress() -> None:
+            done["count"] += 1
+            emit_progress(progress, done=done["count"], stage="assessing")
+
+        def _on_site_properties(sites) -> None:
+            for site in sites:
+                props = site.properties
+                storage = props.get("StorageUsage")  # SiteProperties.StorageUsage — bytes
+                summary = SiteScanSummary(
+                    site_id=props.get("SiteId"),
+                    site_url=site.url,
+                    owner=site.owner_login_name,
+                    storage_bytes=int(storage) if storage is not None else None,
+                    web_count=parse_int(site.webs_count) or 0,
+                    last_modified=_clean_modified(site.last_content_modified_date),
+                    lock_state=site.lock_state,
+                    report_impacted_only=True,
+                )
+                runner.dispatch(ScanContainer.SITE, summary, site.url or "")
+                _progress()
+
+        self._tenant.get_site_properties_from_sharepoint_by_filters("", None, include_detail=True).on_error(
+            lambda e: runner.flag_access("tenant", e)
+        ).after_execute(_on_site_properties)
+
+        report.attach_finalizer(runner.collect)
+        return return_type

office365/migration/sharepoint/transfer.py

@@ -0,0 +1,94 @@
+"""Parallel file transfer into a SharePoint document library (adapter-internal).
+
+Unlike the library's **deferred** upload primitives (``upload_folder`` /
+``upload_file`` / ``upload_content`` — single context, sequential, queue-then-
+execute), a transfer is the **concurrent driver** over them: file bytes can't
+ride an OData batch, so throughput comes from concurrency. This module is a thin
+specialization of the generic :func:`~office365.runtime.parallel.run_parallel`
+primitive — each worker uploads on a cloned ``ClientContext`` (reusing the
+source's auth + transport, thread-safe) and all workers pace *together* through
+the shared :class:`RateLimiter` the primitive wires up.
+
+Folders are created once (deduplicated) before transferring; the per-file upload
+delegates to the library's size-dispatching :meth:`FileCollection.upload_content`.
+
+Internal: consumed by :class:`SharePointLibraryTarget.write_many`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Tuple
+
+from office365.runtime.parallel import run_parallel
+from office365.sharepoint.thresholds import Limits
+
+if TYPE_CHECKING:
+    from office365.sharepoint.folders.folder import Folder
+
+_DEFAULT_CHUNK_SIZE = Limits.UPLOAD_SESSION_CHUNK.value
+
+# runtime-evaluated alias (typing form: the ``|``/``tuple[...]`` operators need 3.9+)
+Failure = Tuple[str, str]  # (dest_path, error)
+
+
+def _transfer_files_parallel(
+    target_folder: "Folder",
+    files: Iterable[tuple[str, bytes]],
+    *,
+    concurrency: int = 4,
+    progress: Callable | None = None,
+    chunk_size: int = _DEFAULT_CHUNK_SIZE,
+    context_factory: Callable | None = None,
+) -> list[Failure]:
+    """Transfer ``(dest_path, content)`` pairs into a library folder tree in parallel.
+
+    Folders are ensured once each (deduplicated); files at or below ``chunk_size``
+    use the simple ``upload``, larger ones a resumable ``create_upload_session``
+    (both via :meth:`FileCollection.upload_content`). All workers share one
+    :class:`RateLimiter`, so throttling pauses the group as a whole.
+
+    Args:
+        target_folder: Root target folder (``server_relative_url`` must be loaded).
+        files: Iterable of ``(relative_path, content_bytes)``.
+        concurrency: Number of parallel transfer workers.
+        progress: Optional hook fired per transferred file with a ``Progress`` snapshot.
+        chunk_size: Upload-session chunk size / size threshold (bytes).
+        context_factory: Optional per-worker context provider (defaults to a
+          ``ClientContext.clone`` of ``target_folder.context``).
+
+    Returns:
+        List of ``(dest_path, error)`` for files that failed (empty on success).
+    """
+    files = list(files)
+    if not files:
+        return []
+    root_url = (target_folder.server_relative_url or "").rstrip("/")
+    if not root_url:
+        raise ValueError("target folder must expose its server-relative URL")
+
+    parents = {dest.rsplit("/", 1)[0] for dest, _ in files if "/" in dest}
+    if parents:
+        target_folder.ensure_folders(parents)
+        target_folder.execute_query()
+
+    failures: list[Failure] = []
+    context_factory = context_factory or (lambda: target_folder.context.clone(target_folder.context.base_url))
+
+    def _worker(clone, item: tuple[str, bytes]) -> None:
+        dest_path, content = item
+        parts = dest_path.split("/")
+        name = parts[-1]
+        parent_url = f"{root_url}/{'/'.join(parts[:-1])}" if len(parts) > 1 else root_url
+        folder = clone.web.get_folder_by_server_relative_path(parent_url)
+        folder.files.upload_content(content, name, chunk_size).execute_query_retry(max_retry=5)
+
+    run_parallel(
+        _worker,
+        files,
+        concurrency=concurrency,
+        context_factory=context_factory,
+        progress=progress,
+        on_error=lambda item, error: failures.append((item[0], str(error))),
+    )
+    return failures