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

office365/migration/sharepoint/assessor.py

@@ -22,16 +22,17 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
-from office365.migration._util import emit_progress
 from office365.migration.assessment.containers import ScanContainer
 from office365.migration.assessment.issue import AssessmentIssue
 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.adapters import is_taxonomy_validation
+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.operations import emit_progress
 from office365.sharepoint.entity import Entity
 
 if TYPE_CHECKING:
@@ -56,7 +57,7 @@ class MigrationAssessor(Entity):
     def __init__(self, web: "Web", options: AssessmentOptions | None = None) -> None:
         super().__init__(web.context)
         self._web = web
-        self._options = options or AssessmentOptions()
+        self._options = options or SharePointAssessmentOptions()
 
     # ── Configuration ────────────────────────────────────────────
 
@@ -104,7 +105,11 @@ class MigrationAssessor(Entity):
         report = runner.report
 
         needs_site = bool(runner.scanners(ScanContainer.SITE))
-        needs_list_metadata = needs_site  # item counts / last-modified for the summary
+        needs_site_template = any(
+            scanner.scan_name == "UnsupportedSiteTemplates" for scanner in runner.scanners(ScanContainer.SITE)
+        )
+        # item counts / last-modified feed the SITE summary and the LIST-container scans
+        needs_list_metadata = needs_site or bool(runner.scanners(ScanContainer.LIST))
         summary = SiteScanSummary()
 
         def _flag_failure(location: str, error: Exception) -> None:
@@ -138,9 +143,14 @@ class MigrationAssessor(Entity):
         # site collection metadata (usage/storage, owner) for SITE-container scans
         if needs_site:
             site = self._web.context.site
+            columns = ["Id", "Url", "UsageInfo", "Owner/Title", "Owner/Email"]
+            expands = ["Owner"]
+            if needs_site_template:  # the root web template feeds UnsupportedSiteTemplates
+                columns += ["RootWeb/WebTemplate", "RootWeb/Configuration"]
+                expands.append("RootWeb")
             (
-                site.select(["Id", "Url", "UsageInfo", "Owner/Title", "Owner/Email"])
-                .expand(["Owner"])
+                site.select(columns)
+                .expand(expands)
                 .get()
                 .on_error(lambda e: _flag_failure("web", e))
                 .after_execute(lambda site: self._on_site_loaded(site, summary, needs_site))
@@ -182,6 +192,20 @@ class MigrationAssessor(Entity):
             site.root_web.associated_owner_group.users.get().on_error(lambda e: None).after_execute(
                 lambda users: self._set_site_admins(summary, users)
             )
+        root_web = site.properties.get("RootWeb")
+        if root_web is not None:
+            summary.web_template = self._web_template(root_web)
+
+    @staticmethod
+    def _web_template(web: "Web") -> str | None:
+        """The root web's ``WebTemplate`` plus its configuration id (e.g. ``STS#0``)."""
+        template = web.properties.get("WebTemplate")
+        if not template:
+            return None
+        if "#" in template:
+            return template
+        configuration = web.properties.get("Configuration")
+        return f"{template}#{configuration}" if configuration is not None else template
 
     @staticmethod
     def _set_site_admins(summary: SiteScanSummary, users) -> None:
@@ -247,16 +271,19 @@ class MigrationAssessor(Entity):
         has_fields = bool(runner.scanners(ScanContainer.FIELDS))
         has_items = bool(runner.scanners(ScanContainer.ITEMS, "default"))
         has_unique_items = bool(runner.scanners(ScanContainer.ITEMS, "unique"))
+        has_list = bool(runner.scanners(ScanContainer.LIST))
 
         def _progress(lst) -> None:
             completed["count"] += 1
             emit_progress(progress, done=completed["count"], total=total, stage="assessing", items=[lst])
 
         for lst in lists:
+            location = f"{prefix}/lists/{lst.title}"
+            if has_list:
+                runner.dispatch(ScanContainer.LIST, lst, location)
             if lst.hidden:
                 _progress(lst)
                 continue
-            location = f"{prefix}/lists/{lst.title}"
             pending = {"count": 0}
 
             def _scan_done(lst=lst, pending=pending) -> None:
@@ -278,9 +305,18 @@ class MigrationAssessor(Entity):
                 )
             if has_items:
                 pending["count"] += 1
-                lst.items.select(["FileRef", "FileLeafRef", "File/Length"]).expand(["File"]).get().on_error(
-                    _fail
-                ).after_execute(
+                lst.items.select(
+                    [
+                        "FileRef",
+                        "FileLeafRef",
+                        "File/Length",
+                        "File/MajorVersion",
+                        "File/MinorVersion",
+                        "File/CheckOutType",
+                        "File/TimeCreated",
+                        "File/TimeLastModified",
+                    ]
+                ).expand(["File", "File/ModifiedBy", "File/CheckedOutByUser"]).get().on_error(_fail).after_execute(
                     lambda col, lst=lst, loc=location, done=_scan_done: (
                         self._scan_items(runner, col, loc),
                         done(lst),

office365/migration/sharepoint/options.py

@@ -0,0 +1,57 @@
+"""SharePoint assessment options — the SharePoint defaults for the scanners.
+
+Seeds the product-agnostic :class:`~office365.migration.assessment.scanners.AssessmentOptions`
+with the SharePoint thresholds (from ``office365.sharepoint.thresholds.Limits``)
+and the ``limits`` mapping, so findings reference the authoritative limit.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from office365.migration.assessment.scanners import AssessmentOptions
+from office365.runtime.limits import Limit
+from office365.sharepoint.fields.builtin_field_name import SYSTEM_FIELD_NAMES
+from office365.sharepoint.thresholds import Limits
+
+
+def _limits() -> dict[str, Limit]:
+    return {
+        "max_path_length": Limits.FILE_PATH_LENGTH,
+        "max_name_length": Limits.FILE_NAME_LENGTH,
+        "large_file_bytes": Limits.MIGRATION_FILE_SIZE,
+        "large_excel_bytes": Limits.LARGE_EXCEL_FILE,
+        "long_onedrive_url": Limits.LONG_ONEDRIVE_URL,
+        "list_view_threshold": Limits.LIST_VIEW,
+        "index_threshold": Limits.INDEX_ADD_REMOVE,
+        "max_list_items": Limits.MAX_LIST_ITEMS,
+        "lookup_joins": Limits.LOOKUP_JOINS,
+        "unique_scopes": Limits.UNIQUE_SCOPES,
+        "recommended_unique_scopes": Limits.UNIQUE_SCOPES_RECOMMENDED,
+    }
+
+
+@dataclass
+class SharePointAssessmentOptions(AssessmentOptions):
+    """The SharePoint defaults — thresholds + the ``limits`` mapping."""
+
+    max_path_length: Optional[int] = Limits.FILE_PATH_LENGTH.value
+    max_name_length: Optional[int] = Limits.FILE_NAME_LENGTH.value
+    invalid_chars: set[str] = field(default_factory=lambda: set(r'~"#%&*:<>?/\{|}'))
+    large_file_bytes: Optional[int] = Limits.MIGRATION_FILE_SIZE.value
+    large_excel_bytes: Optional[int] = Limits.LARGE_EXCEL_FILE.value
+    long_onedrive_url: Optional[int] = Limits.LONG_ONEDRIVE_URL.value
+    list_view_threshold: Optional[int] = Limits.LIST_VIEW.value
+    index_threshold: Optional[int] = Limits.INDEX_ADD_REMOVE.value
+    max_list_items: Optional[int] = Limits.MAX_LIST_ITEMS.value
+    lookup_joins: Optional[int] = Limits.LOOKUP_JOINS.value
+    unique_scopes: Optional[int] = Limits.UNIQUE_SCOPES.value
+    recommended_unique_scopes: Optional[int] = Limits.UNIQUE_SCOPES_RECOMMENDED.value
+    large_site_threshold_gb: Optional[float] = 500.0
+    strip_field_attrs: set[str] = field(default_factory=lambda: {"ColName", "RowOrdinal", "SourceID", "Version"})
+    approval_workflow_fields: set[str] = field(
+        default_factory=lambda: {"_ApprovalStatus", "_ApprovalRespondedBy", "_ApprovalAssignedTo"}
+    )
+    system_field_names: set[str] = field(default_factory=lambda: set(SYSTEM_FIELD_NAMES))
+    limits: dict[str, Limit] = field(default_factory=_limits)

office365/migration/sharepoint/package_target.py

@@ -0,0 +1,209 @@
+"""Server-side migration target — build a Migration API package and ingest it.
+
+Unlike the client-side :class:`SharePointLibraryTarget` (which uploads each file
+over REST), this target accumulates files/folders into a Migration API package,
+stages the blobs in Azure Storage, and submits an ingestion job — the only path
+that preserves version history and full ACL fidelity.
+
+Content and manifest go to **different** containers; the caller supplies their SAS
+URIs (e.g. from ``Site.provision_migration_containers``).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from office365.migration.base import MigrationItem
+from office365.migration.package.builder import PackageBuilder
+from office365.migration.package.staging import create_staging
+from office365.migration.server_job import MigrationServerJob
+
+if TYPE_CHECKING:
+    from office365.migration.package.builder import Package
+
+__all__ = ["SharePointPackageTarget"]
+
+
+def _resolve_site_url(site, site_url: str | None) -> str:
+    """The target site URL for ``ExportSettings.xml`` (the API rejects an empty URI)."""
+    resolved = site_url or getattr(site, "url", None)
+    if not resolved and hasattr(site, "ensure_property"):
+        site.ensure_property("Url").execute_query()
+        resolved = site.url
+    if not resolved:
+        raise ValueError("site_url is required — ExportSettings.xml needs the target site URL")
+    return resolved
+
+
+class SharePointPackageTarget:
+    """A ``DataTarget`` that builds a package and submits a server-side ingestion job."""
+
+    def __init__(
+        self,
+        site,
+        web_id,
+        *,
+        content_uri: str | None = None,
+        manifest_uri: str | None = None,
+        site_url: str | None = None,
+        list_title: str = "Documents",
+        list_url: str | None = None,
+        web_url: str = "/",
+        root_folder_id: str | None = None,
+        root_folder_parent_id: str | None = None,
+        source_type: str = "SharePointOnline",
+        azure_queue_report_uri: str | None = None,
+        encryption_key: bytes | None = None,
+        staging=None,
+    ) -> None:
+        self._site = site
+        self._web_id = web_id
+        self._list_title = list_title
+        self._content_uri = content_uri
+        self._manifest_uri = manifest_uri
+        self._azure_queue_report_uri = azure_queue_report_uri
+        self._encryption_key = encryption_key
+        if staging is None:
+            if not (content_uri and manifest_uri):
+                raise ValueError("content_uri and manifest_uri are required unless staging is provided")
+            staging = create_staging(content_uri, manifest_uri, encryption_key=encryption_key)
+        self._staging = staging
+        self._builder = PackageBuilder(
+            _resolve_site_url(site, site_url),
+            web_id=web_id,
+            web_url=web_url,
+            list_title=list_title,
+            list_url=list_url,
+            root_folder_id=root_folder_id,
+            root_folder_parent_id=root_folder_parent_id,
+            source_type=source_type,
+        )
+        self.job_id: str | None = None
+        self._package: "Package | None" = None
+
+    def label(self) -> str:
+        return f"migration-package:{self._list_title}"
+
+    # ── DataTarget ───────────────────────────────────────────────
+
+    def exists(self, item: MigrationItem) -> bool:
+        # The server-side API handles overwrite/merge; nothing is checked client-side.
+        return False
+
+    def write(self, item: MigrationItem, payload: object) -> None:
+        if item.item_type == "folder":
+            self._builder.add_folder(
+                item.dest_path,
+                time_created=item.created,
+                time_last_modified=item.modified,
+            )
+            return
+        content = payload if isinstance(payload, bytes) else str(payload).encode("utf-8")
+        self._builder.add_file(
+            item.dest_path,
+            content,
+            time_created=item.created,
+            time_last_modified=item.modified,
+        )
+
+    def list_paths(self) -> list[str]:
+        return []
+
+    def checksum(self, item: MigrationItem) -> str:
+        return ""
+
+    # ── Package + submission ─────────────────────────────────────
+
+    def build(self) -> "Package":
+        """Render the package from the items written so far."""
+        self._package = self._builder.build()
+        return self._package
+
+    def stage(self) -> "Package":
+        """Build the package and stage its blobs for ingestion."""
+        package = self.build()
+        self._staging.stage(package)
+        return package
+
+    def commit(self, options=None) -> None:
+        """Stage the package and submit the ingestion job (called by the runner)."""
+        if not (self._content_uri and self._manifest_uri):
+            raise ValueError("content_uri and manifest_uri are required to submit an ingestion job")
+        self.stage()
+        server = MigrationServerJob(self._site)
+        if self._encryption_key is not None:
+            self.job_id = server.submit_encrypted(
+                self._web_id,
+                self._content_uri,
+                self._manifest_uri,
+                self._encryption_key,
+                self._azure_queue_report_uri,
+            )
+        else:
+            self.job_id = server.submit(
+                self._web_id,
+                self._content_uri,
+                self._manifest_uri,
+                self._azure_queue_report_uri,
+            )
+
+    def monitor(self, interval: float = 5, timeout: float = 1800, progress=None) -> str:
+        """Poll the submitted job to completion (``GetMigrationJobProgress``)."""
+        if self.job_id is None:
+            raise ValueError("no job submitted yet — call commit() first")
+        return MigrationServerJob(self._site).monitor(self.job_id, interval=interval, timeout=timeout, progress=progress)
+
+    @property
+    def staging(self):
+        """The staging strategy (``FileSystemStaging`` / ``BlobStaging``)."""
+        return self._staging
+
+    def events(self) -> list[dict]:
+        """All progress events for the submitted job (call after :meth:`monitor`)."""
+        if self.job_id is None:
+            return []
+        return MigrationServerJob(self._site).all_events(self.job_id)
+
+    def errors(self) -> list[dict]:
+        """The ``JobError`` events for the submitted job (call after :meth:`monitor`)."""
+        if self.job_id is None:
+            return []
+        return MigrationServerJob(self._site).errors(self.job_id)
+
+    def diagnose(self) -> list[str]:
+        """Human-readable reasons the submitted job failed (errors, events, API log).
+
+        The progress events omit the detail; the API writes it to a log in the
+        manifest container (named by the ``JobLogFileCreate`` event), which this
+        fetches — the container grants ``Read``.
+        """
+        if self.job_id is None:
+            return []
+        events = self.events()
+        lines = [f"! {e.get('ErrorType', 'error')}: {e.get('Message', '')}".rstrip() for e in self.errors()]
+        if not lines:
+            lines = [f"· {e.get('Event')}: {e.get('Message', '')}".rstrip() for e in events]
+        lines.extend(self._read_logs(events))
+        return lines
+
+    def _read_logs(self, events: list[dict]) -> list[str]:
+        reader = getattr(self._staging, "read_manifest_blob", None)
+        if not callable(reader):
+            return []
+        names = [event.get("FileName") for event in events if event.get("FileName")]
+        if not names and self.job_id:
+            names = [f"Import-{self.job_id}-1.log"]
+        lines: list[str] = []
+        for name in names:
+            try:
+                data = reader(name)
+                text = data.decode("utf-8", "replace") if isinstance(data, bytes) else str(data)
+            except Exception as exc:  # noqa: BLE001 — diagnostics are best-effort
+                lines.append(f"(log {name} unavailable: {exc})")
+            else:
+                lines.append(f"--- {name} ---")
+                lines.append(text[:4000])
+        return lines
+
+    def close(self) -> None:
+        pass

office365/migration/sharepoint/registry.py

@@ -10,19 +10,41 @@ from __future__ import annotations
 from office365.migration.assessment.containers import ScanContainer
 from office365.migration.assessment.registry import ScanDefinition, scan_pairs
 from office365.migration.assessment.scanners.base import AssessmentOptions, BaseScanner
+from office365.migration.sharepoint.scanners.browser_file_handling import BrowserFileHandlingScanner
+from office365.migration.sharepoint.scanners.checked_out_files import CheckedOutFilesScanner
 from office365.migration.sharepoint.scanners.fields import FieldScanner
+from office365.migration.sharepoint.scanners.file_versions import FileVersionsScanner
 from office365.migration.sharepoint.scanners.files import FileScanner
+from office365.migration.sharepoint.scanners.large_excel_files import LargeExcelFilesScanner
+from office365.migration.sharepoint.scanners.large_lists import LargeListScanner
 from office365.migration.sharepoint.scanners.large_sites import LargeSitesScanner
 from office365.migration.sharepoint.scanners.locked_sites import SiteLockedScanner
+from office365.migration.sharepoint.scanners.long_onedrive_urls import LongOneDriveUrlsScanner
+from office365.migration.sharepoint.scanners.lookup import LookupColumnScanner
 from office365.migration.sharepoint.scanners.paths import PathScanner
 from office365.migration.sharepoint.scanners.permissions import PermissionScanner
+from office365.migration.sharepoint.scanners.thicket_folders import ThicketFolderScanner
+from office365.migration.sharepoint.scanners.unsupported_site_templates import UnsupportedSiteTemplatesScanner
 
 SHAREPOINT_SCANS: list[ScanDefinition] = [
     ScanDefinition(name="fields", scanner=FieldScanner, container=ScanContainer.FIELDS),
+    ScanDefinition(name="lookups", scanner=LookupColumnScanner, container=ScanContainer.FIELDS),
+    ScanDefinition(name="largeLists", scanner=LargeListScanner, container=ScanContainer.LIST),
     ScanDefinition(name="paths", scanner=PathScanner, container=ScanContainer.ITEMS),
     ScanDefinition(name="files", scanner=FileScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="FileVersions", scanner=FileVersionsScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="CheckedOutFiles", scanner=CheckedOutFilesScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="LargeExcelFiles", scanner=LargeExcelFilesScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="LongOneDriveUrls", scanner=LongOneDriveUrlsScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="BrowserFileHandling", scanner=BrowserFileHandlingScanner, container=ScanContainer.ITEMS),
+    ScanDefinition(name="ThicketFolder", scanner=ThicketFolderScanner, container=ScanContainer.ITEMS),
     ScanDefinition(name="permissions", scanner=PermissionScanner, container=ScanContainer.ITEMS),
     ScanDefinition(name="LargeSites", scanner=LargeSitesScanner, container=ScanContainer.SITE),
+    ScanDefinition(
+        name="UnsupportedSiteTemplates",
+        scanner=UnsupportedSiteTemplatesScanner,
+        container=ScanContainer.SITE,
+    ),
     ScanDefinition(
         name="LockedSites",
         scanner=SiteLockedScanner,

office365/migration/sharepoint/resolvers.py

@@ -0,0 +1,96 @@
+"""Resolve a declarative :class:`MigrationTask` into source/target adapters.
+
+SPMT-shaped tasks (``Add-SPMTTask``) name a source and a target site/list; this
+turns them into the toolkit's ``DataSource``/``DataTarget`` pair against a
+SharePoint ``ClientContext``. Client-side REST uploads are the default; set
+``MigrationSettings.use_migration_api`` for the server-side Migration API path
+(full fidelity: versions/ACLs).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from office365.migration.adapters.filesystem import FileSystemSource
+from office365.migration.tasks import FILE_SHARE, SHAREPOINT, MigrationTask
+
+if TYPE_CHECKING:
+    from office365.migration.settings import MigrationSettings
+
+__all__ = ["resolve_task"]
+
+
+def resolve_task(task: MigrationTask, context, settings: "MigrationSettings | None" = None):
+    """Return a ``(source, target)`` adapter pair for a task descriptor."""
+    if task.kind == FILE_SHARE:
+        return _file_share(task, context, settings)
+    if task.kind == SHAREPOINT:
+        return _sharepoint(task, context, settings)
+    raise ValueError(f"unsupported task kind {task.kind!r}")
+
+
+def _file_share(task: MigrationTask, context, settings):
+    if not task.file_share_source:
+        raise ValueError("a file-share task requires file_share_source")
+    source = FileSystemSource(task.file_share_source)
+    library, folder = _target_folder(context, task)
+    return source, _build_target(task, context, settings, library, folder)
+
+
+def _sharepoint(task: MigrationTask, context, settings):
+    from office365.migration.sharepoint.adapters import SharePointLibrarySource
+
+    if task.migrate_all or not task.source_list:
+        raise NotImplementedError(
+            "SharePoint-source tasks need a source list; migrate-all / whole-site migrations are not supported yet"
+        )
+    source_list = context.web.get_list_by_title(task.source_list)
+    source = SharePointLibrarySource(source_list.root_folder)
+    library, folder = _target_folder(context, task)
+    return source, _build_target(task, context, settings, library, folder)
+
+
+def _target_folder(context, task: MigrationTask):
+    """The target library (and, when set, its relative subfolder)."""
+    library = context.web.get_list_by_title(task.target_list).get().execute_query()
+    folder = library.root_folder.get().execute_query()
+    if task.target_list_relative_path:
+        url = f"{(folder.server_relative_url or '').rstrip('/')}/{task.target_list_relative_path.strip('/')}"
+        folder = context.web.get_folder_by_server_relative_url(url)
+    return library, folder
+
+
+def _build_target(task: MigrationTask, context, settings, library, folder):
+    if settings is not None and settings.use_migration_api:
+        return _package_target(task, context, library)
+    from office365.migration.sharepoint.adapters import SharePointLibraryTarget
+
+    return SharePointLibraryTarget(folder)
+
+
+def _package_target(task: MigrationTask, context, library):
+    """The server-side Migration API target (provisions containers)."""
+    from urllib.parse import urlparse
+
+    from office365.migration.sharepoint.package_target import SharePointPackageTarget
+
+    web = context.web.get().execute_query()
+    root = library.root_folder
+    root.ensure_properties(["UniqueId", "ServerRelativeUrl"]).execute_query()
+    parent = root.parent_folder.ensure_property("UniqueId")
+    parent.execute_query()
+    containers = context.site.provision_migration_containers().execute_query().value
+    return SharePointPackageTarget(
+        context.site,
+        web.id,
+        content_uri=containers.DataContainerUri,
+        manifest_uri=containers.MetadataContainerUri,
+        encryption_key=containers.EncryptionKey,
+        site_url=context.base_url,
+        list_title=library.title,
+        list_url=root.server_relative_url,
+        web_url=urlparse(context.base_url).path or "/",
+        root_folder_id=root.unique_id,
+        root_folder_parent_id=parent.unique_id,
+        source_type="FileShare" if task.kind == FILE_SHARE else "SharePointOnline",
+    )

office365/migration/sharepoint/scanners/__init__.py

@@ -5,23 +5,52 @@ from office365.migration.assessment.scanners.base import (
     BaseScanner,
     ScanTarget,
 )
+from office365.migration.sharepoint.scanners.browser_file_handling import (
+    BrowserFileHandlingRecord,
+    BrowserFileHandlingScanner,
+)
+from office365.migration.sharepoint.scanners.checked_out_files import (
+    CheckedOutFilesRecord,
+    CheckedOutFilesScanner,
+)
 from office365.migration.sharepoint.scanners.fields import FieldScanner
+from office365.migration.sharepoint.scanners.file_versions import FileVersionsRecord, FileVersionsScanner
 from office365.migration.sharepoint.scanners.files import FileScanner
+from office365.migration.sharepoint.scanners.large_excel_files import LargeExcelFilesRecord, LargeExcelFilesScanner
 from office365.migration.sharepoint.scanners.large_sites import LargeSitesScanner
 from office365.migration.sharepoint.scanners.locked_sites import SiteLockedScanner
+from office365.migration.sharepoint.scanners.long_onedrive_urls import LongOneDriveUrlsRecord, LongOneDriveUrlsScanner
 from office365.migration.sharepoint.scanners.paths import PathScanner
 from office365.migration.sharepoint.scanners.permissions import PermissionScanner
 from office365.migration.sharepoint.scanners.summary import SiteScanSummary
+from office365.migration.sharepoint.scanners.thicket_folders import ThicketFolderScanner
+from office365.migration.sharepoint.scanners.unsupported_site_templates import (
+    UnsupportedSiteTemplatesRecord,
+    UnsupportedSiteTemplatesScanner,
+)
 
 __all__ = [
     "AssessmentOptions",
     "BaseScanner",
+    "BrowserFileHandlingRecord",
+    "BrowserFileHandlingScanner",
+    "CheckedOutFilesRecord",
+    "CheckedOutFilesScanner",
     "FieldScanner",
     "FileScanner",
+    "FileVersionsRecord",
+    "FileVersionsScanner",
+    "LargeExcelFilesRecord",
+    "LargeExcelFilesScanner",
     "LargeSitesScanner",
+    "LongOneDriveUrlsRecord",
+    "LongOneDriveUrlsScanner",
     "PathScanner",
     "PermissionScanner",
     "ScanTarget",
     "SiteLockedScanner",
     "SiteScanSummary",
+    "ThicketFolderScanner",
+    "UnsupportedSiteTemplatesRecord",
+    "UnsupportedSiteTemplatesScanner",
 ]

office365/migration/sharepoint/scanners/browser_file_handling.py

@@ -0,0 +1,55 @@
+"""Browser file handling scan — the SMAT ``BrowserFileHandling`` report.
+
+The target enforces the "Strict" browser file handling setting, so ``.htm`` /
+``.html`` files no longer open in the browser — users are prompted to download
+them. This ``ITEMS``-container report lists the affected files.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, file_extension, site_url
+
+#: Extensions affected by the Strict browser file handling change.
+HTML_EXTENSIONS = frozenset({".htm", ".html"})
+
+
+@dataclass
+class BrowserFileHandlingRecord(SiteScanRecord):
+    """One row of the SMAT ``BrowserFileHandling-detail`` report."""
+
+    File: str | None = None
+    TimeCreated: datetime | None = None
+    TimeModified: datetime | None = None
+    ModifiedBy: str | None = None
+    ScanID: str | None = None
+
+
+class BrowserFileHandlingScanner(BaseScanner[BrowserFileHandlingRecord]):
+    """Reports ``.htm``/``.html`` files affected by Strict browser handling."""
+
+    category = "file"
+    scan_name = "BrowserFileHandling"
+    record_type = BrowserFileHandlingRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        location = site_url(target.location)
+        for item in target.entity:
+            if file_extension(item) not in HTML_EXTENSIONS:
+                continue
+            file = getattr(item, "file", None)
+            modified_by = file.modified_by if file is not None else None
+            self.records.append(
+                BrowserFileHandlingRecord(
+                    SiteURL=location,
+                    File=item.properties.get("FileRef", ""),
+                    TimeCreated=file.time_created if file is not None else None,
+                    TimeModified=file.time_last_modified if file is not None else None,
+                    ModifiedBy=(modified_by.login_name or modified_by.title) if modified_by is not None else None,
+                    ScanID=report.scan_id or None,
+                )
+            )