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

office365/intune/policies/local_admin_settings.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from office365.intune.devices.registration_membership import DeviceRegistrationMembership
+from office365.runtime.client_value import ClientValue
+
+
+@dataclass
+class LocalAdminSettings(ClientValue):
+    enableGlobalAdmins: bool | None = None
+    registeringUsers: DeviceRegistrationMembership = field(default_factory=DeviceRegistrationMembership)
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.LocalAdminSettings"

office365/intune/print/printers/incompatible_printer_settings.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class IncompatiblePrinterSettings(Enum):
+    show = "0"
+    hide = "1"
+    unknownFutureValue = "2"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.IncompatiblePrinterSettings"

office365/intune/print/user_print.py

@@ -7,8 +7,6 @@ from office365.runtime.client_value import ClientValue
 
 @dataclass
 class UserPrint(ClientValue):
-    # recentPrinterShares: EntityCollection[PrinterShare] | None = None
-
     @property
     def entity_type_name(self) -> str:
         return "microsoft.graph.UserPrint"

office365/intune/process_integrity_level.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class ProcessIntegrityLevel(Enum):
+    unknown = "0"
+    untrusted = "1"
+    low = "2"
+    medium = "3"
+    high = "4"
+    system = "5"
+    unknownFutureValue = "127"
+
+    @property
+    def entity_type_name(self) -> str:
+        return "microsoft.graph.ProcessIntegrityLevel"

office365/intune/resource_permission.py

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

office365/migration/__init__.py

@@ -1,7 +1,122 @@
-# from office365.migration import (
-#    MigrationAssessor,
-#    TenantAssessor,
-#    MigrationEngine,
-#    Exporter,
-#    SyncEngine,
-# )
+"""Migration toolkit — resumable, client-side migrations.
+
+The core is product-agnostic: it composes a ``DataSource``/``DataTarget`` pair
+(filesystem, SharePoint, ...) with checkpoints, resumption, and verification.
+Product packages add the platform-specific pieces:
+``office365.migration.sharepoint`` and ``office365.migration.outlook``.
+
+Quick start (filesystem -> filesystem):
+
+    from office365.migration import MigrationJob
+    from office365.migration.adapters.filesystem import FileSystemSource, FileSystemTarget
+
+    job = MigrationJob(FileSystemSource("src"), FileSystemTarget("dst"))
+    job.plan()
+    job.run()
+    print(job.stats.summary())
+    print(job.verify().summary())
+
+Product conveniences (``MigrationAssessor``, ``MailboxAssessor``, ...) are
+re-exported lazily, so importing the core never pulls in SharePoint or Outlook.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from office365.migration.assessment.containers import ScanContainer
+from office365.migration.assessment.registry import ScanDefinition, scan_pairs
+from office365.migration.assessment.report import AssessmentReport, ScanReport
+from office365.migration.assessment.scanners import AssessmentOptions
+from office365.migration.base import (
+    ConflictResolution,
+    ExportFormat,
+    ItemStatus,
+    MigrationItem,
+    MigrationMode,
+    MigrationOptions,
+    MigrationPhase,
+    MigrationStats,
+)
+from office365.migration.checkpoint import Checkpoint
+from office365.migration.job import MigrationJob
+from office365.migration.manifest import Manifest
+from office365.migration.report import MigrationReport, build_report, export_reports
+from office365.migration.runner import MigrationRunner
+from office365.migration.server_job import MigrationServerJob
+from office365.migration.session import MigrationSession
+from office365.migration.validators import VerificationReport, verify
+
+if TYPE_CHECKING:
+    # Product conveniences resolved lazily by ``__getattr__`` (declared here so
+    # type checkers and ``__all__`` see them without importing the products).
+    from office365.migration.outlook import OUTLOOK_SCANS, MailboxAssessor, OutlookOptions
+    from office365.migration.sharepoint import (
+        SHAREPOINT_SCANS,
+        MigrationAssessor,
+        MigrationTenantAssessor,
+    )
+    from office365.migration.teams import (
+        TeamsArchiveSource,
+        TeamsArchiveTarget,
+        TeamsExportOptions,
+    )
+
+_LAZY_EXPORTS = {
+    "MigrationAssessor": "office365.migration.sharepoint",
+    "MigrationTenantAssessor": "office365.migration.sharepoint",
+    "SHAREPOINT_SCANS": "office365.migration.sharepoint",
+    "MailboxAssessor": "office365.migration.outlook",
+    "OutlookOptions": "office365.migration.outlook",
+    "OUTLOOK_SCANS": "office365.migration.outlook",
+    "TeamsArchiveSource": "office365.migration.teams",
+    "TeamsArchiveTarget": "office365.migration.teams",
+    "TeamsExportOptions": "office365.migration.teams",
+}
+
+__all__ = [
+    "AssessmentOptions",
+    "AssessmentReport",
+    "Checkpoint",
+    "ConflictResolution",
+    "ExportFormat",
+    "ItemStatus",
+    "Manifest",
+    "MigrationItem",
+    "MigrationJob",
+    "MigrationMode",
+    "MigrationOptions",
+    "MigrationPhase",
+    "MigrationReport",
+    "MigrationRunner",
+    "MigrationServerJob",
+    "MigrationSession",
+    "MigrationStats",
+    "ScanContainer",
+    "ScanDefinition",
+    "ScanReport",
+    "VerificationReport",
+    "build_report",
+    "export_reports",
+    "scan_pairs",
+    "verify",
+    "MigrationAssessor",
+    "MigrationTenantAssessor",
+    "SHAREPOINT_SCANS",
+    "MailboxAssessor",
+    "OutlookOptions",
+    "OUTLOOK_SCANS",
+    "TeamsArchiveSource",
+    "TeamsArchiveTarget",
+    "TeamsExportOptions",
+]
+
+
+def __getattr__(name: str):
+    """Resolve product conveniences lazily (keeps the core import light)."""
+    module_name = _LAZY_EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    import importlib
+
+    return getattr(importlib.import_module(module_name), name)

office365/migration/_util.py

@@ -0,0 +1,73 @@
+"""Shared helpers for the migration toolkit (progress, CSV/JSON, timestamps).
+
+Keeps the small, repeated idioms (progress emission, record export, ISO-8601
+timestamps) in one place instead of inlining them in every adapter/runner.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def emit_progress(progress, *, done: int, total: int | None = None, stage: str, items=None) -> None:
+    """Invoke a progress hook (if any) with a ``Progress`` snapshot.
+
+    Centralizes the ``if callable(progress): Progress(...)`` idiom used across
+    the toolkit.
+    """
+    if callable(progress):
+        from office365.runtime.operations import Progress
+
+        progress(Progress(done=done, total=total, stage=stage, items=items))
+
+
+def write_csv_json(dir_: str | Path, stem: str, records: list[dict], columns: list[str] | None = None) -> list[str]:
+    """Write records as both CSV and JSON under ``dir_``; returns the file paths."""
+    os.makedirs(dir_, exist_ok=True)
+    columns = list(columns) if columns else (list(records[0]) if records else [])
+
+    csv_path = os.path.join(str(dir_), f"{stem}.csv")
+    with open(csv_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=columns, restval="n/a")
+        writer.writeheader()
+        writer.writerows(records)
+
+    json_path = os.path.join(str(dir_), f"{stem}.json")
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(records, f, indent=2)
+
+    return [csv_path, json_path]
+
+
+def coerce_int(value) -> int | None:
+    """Best-effort ``int`` conversion (``None`` for unset/invalid values)."""
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def utc_now_iso() -> str:
+    """Current UTC time as an ISO-8601 string (second precision)."""
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def iso(value) -> str:
+    """ISO-8601 string for a datetime (second precision); ``""`` for ``None``."""
+    if value is None:
+        return ""
+    return value.isoformat(timespec="seconds")
+
+
+def record_to_json(payload: object) -> str:
+    """Serialize a record to the canonical JSON text used when persisting it.
+
+    SharePoint property values are often entity/datetime objects, so a str
+    fallback keeps the payload JSON-safe. Source/target checksums both use this
+    form, so content verification compares identical text.
+    """
+    return json.dumps(payload, indent=2, default=str)

office365/migration/adapters/__init__.py

@@ -0,0 +1,94 @@
+"""Source/target adapters for the migration runner.
+
+A migration moves items from a :class:`DataSource` to a :class:`DataTarget`
+through a canonical form (bytes for files, dict records for tabular data).
+Adapters implement this small contract, so the runner is platform-agnostic —
+SharePoint, the filesystem, and (later) S3 / PostgreSQL / Kafka all plug in here.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Optional
+
+from office365.migration.base import ConflictResolution, MigrationItem
+
+if TYPE_CHECKING:
+    from office365.runtime.operations import Progress
+
+# NOTE: runtime-evaluated alias, so keep Optional (the ``|`` operator is 3.10+).
+MigrationProgress = Optional[Callable[["Progress"], None]]
+
+
+class DataSource(ABC):
+    """Reads migration items from a source."""
+
+    @abstractmethod
+    def list_items(self, progress: MigrationProgress = None) -> list[MigrationItem]:
+        """Enumerate the items to migrate (with per-item progress)."""
+
+    @abstractmethod
+    def read(self, item: MigrationItem) -> object:
+        """Read the payload for an item (bytes for files, dict for records)."""
+
+    @abstractmethod
+    def checksum(self, item: MigrationItem) -> str:
+        """Content hash of an item, used for idempotency and verification."""
+
+
+class DataTarget(ABC):
+    """Writes migration items to a target."""
+
+    @abstractmethod
+    def exists(self, item: MigrationItem) -> bool:
+        """Whether the item's destination already exists."""
+
+    @abstractmethod
+    def write(self, item: MigrationItem, payload: object) -> None:
+        """Write the item's payload to its destination."""
+
+    def write_many(
+        self,
+        items: list[MigrationItem],
+        payloads: list[object],
+        concurrency: int = 1,
+    ) -> list:
+        """Bulk-write a batch; the default falls back to per-item :meth:`write`.
+
+        Targets that support true parallel writes (e.g. the SharePoint library
+        target) override this. Returns a list of ``(path, error)`` failures.
+        """
+        for item, payload in zip(items, payloads):
+            self.write(item, payload)
+        return []
+
+    @abstractmethod
+    def list_paths(self) -> Iterable[str]:
+        """Return all destination paths present on the target (for verification)."""
+
+    @abstractmethod
+    def checksum(self, item: MigrationItem) -> str:
+        """Content hash of an item already on the target."""
+
+
+def resolve_dest(item: MigrationItem, target: DataTarget, conflict: ConflictResolution) -> str:
+    """Resolve a destination path honoring the conflict-resolution policy.
+
+    ``SKIP`` keeps the original dest (the caller decides whether to skip);
+    ``OVERWRITE`` and ``RENAME`` return the effective destination (RENAME appends
+    a numeric suffix while the name collides).
+    """
+    dest = item.dest_path
+    if conflict != ConflictResolution.RENAME:
+        return dest
+    probe = MigrationItem(item.source_path, dest, item.size_bytes, item.item_type)
+    if not target.exists(probe):
+        return dest
+    base, dot, ext = dest.rpartition(".")
+    counter = 1
+    while True:
+        candidate = f"{base}-{counter}{dot}{ext}" if dot else f"{base}-{counter}"
+        if not target.exists(MigrationItem(item.source_path, candidate, item.size_bytes, item.item_type)):
+            return candidate
+        counter += 1

office365/migration/adapters/filesystem.py

@@ -0,0 +1,174 @@
+"""Filesystem source/target adapters.
+
+A pure-stdlib adapter pair that copies a directory tree — the reference
+implementation and the primary storage for the migration toolkit — plus a
+:class:`JsonFileTarget` for persisting record payloads (one JSON file per item).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from office365.migration._util import emit_progress, iso, record_to_json
+from office365.migration.adapters import MigrationProgress
+from office365.migration.base import MigrationItem
+
+
+class FileSystemSource:
+    """Enumerates and reads files under a root directory."""
+
+    def __init__(self, root: str | Path) -> None:
+        self._root = Path(root)
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    def label(self) -> str:
+        return str(self._root)
+
+    def list_items(self, progress: MigrationProgress = None) -> list[MigrationItem]:
+        items: list[MigrationItem] = []
+        for path in sorted(self._root.rglob("*")):
+            if not path.is_file():
+                continue
+            stat = path.stat()
+            item = MigrationItem(
+                source_path=str(path),
+                dest_path=str(path.relative_to(self._root)).replace("\\", "/"),
+                size_bytes=stat.st_size,
+                modified=iso(datetime.fromtimestamp(stat.st_mtime, timezone.utc)),
+            )
+            items.append(item)
+            emit_progress(progress, done=len(items), stage="planning", items=[item])
+        return items
+
+    def read(self, item: MigrationItem) -> bytes:
+        return Path(item.source_path).read_bytes()
+
+    def checksum(self, item: MigrationItem) -> str:
+        return _md5(Path(item.source_path))
+
+    def close(self) -> None:
+        pass
+
+
+class FileSystemTarget:
+    """Writes files under a root directory."""
+
+    def __init__(self, root: str | Path, include_folders: bool = False) -> None:
+        self._root = Path(root)
+        self._include_folders = include_folders  # list folder entries in list_paths (verify)
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    def label(self) -> str:
+        return str(self._root)
+
+    def exists(self, item: MigrationItem) -> bool:
+        return (self._root / item.dest_path).exists()
+
+    def write(self, item: MigrationItem, payload: object) -> None:
+        dest = self._root / item.dest_path
+        if item.item_type == "folder":
+            dest.mkdir(parents=True, exist_ok=True)
+            return
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(payload if isinstance(payload, bytes) else str(payload).encode("utf-8"))
+
+    def list_paths(self) -> list[str]:
+        paths = []
+        for p in self._root.rglob("*"):
+            rel = str(p.relative_to(self._root)).replace("\\", "/")
+            if p.is_dir():
+                if self._include_folders:
+                    paths.append(f"{rel}/")
+            else:
+                paths.append(rel)
+        return paths
+
+    def modified(self, item: MigrationItem) -> str:
+        """Last-modified of the target file, for incremental migration."""
+        return iso(datetime.fromtimestamp((self._root / item.dest_path).stat().st_mtime, timezone.utc))
+
+    def checksum(self, item: MigrationItem) -> str:
+        return _md5(self._root / item.dest_path)
+
+    def commit(self, options=None) -> None:
+        pass
+
+    def close(self) -> None:
+        pass
+
+
+class JsonFileSource:
+    """Reads record payloads (one JSON file per item) — the import counterpart
+    of :class:`JsonFileTarget`. Enables records round-trips through the filesystem.
+    """
+
+    def __init__(self, root: str | Path) -> None:
+        self._root = Path(root)
+
+    def label(self) -> str:
+        return str(self._root)
+
+    def list_items(self, progress: MigrationProgress = None) -> list[MigrationItem]:
+        items: list[MigrationItem] = []
+        for path in sorted(self._root.rglob("*.json")):
+            item = MigrationItem(
+                source_path=str(path),
+                dest_path=path.relative_to(self._root).with_suffix("").as_posix(),
+                item_type="record",
+            )
+            items.append(item)
+            emit_progress(progress, done=len(items), stage="planning", items=[item])
+        return items
+
+    def read(self, item: MigrationItem) -> object:
+        with open(item.source_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def checksum(self, item: MigrationItem) -> str:
+        return _md5(Path(item.source_path))
+
+    def close(self) -> None:
+        pass
+
+
+class JsonFileTarget(FileSystemTarget):
+    """Persists record payloads (dicts) as one JSON file per item.
+
+    An interchange format for migrating tabular data (SharePoint lists,
+    PostgreSQL tables, ...) through the filesystem — a stepping stone for
+    S3/object-storage targets.
+    """
+
+    def _path(self, item: MigrationItem) -> Path:
+        return self._root / f"{item.dest_path}.json"
+
+    def exists(self, item: MigrationItem) -> bool:
+        return self._path(item).exists()
+
+    def write(self, item: MigrationItem, payload: object) -> None:
+        dest = self._path(item)
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(record_to_json(payload), encoding="utf-8")
+
+    def list_paths(self) -> list[str]:
+        return [p.relative_to(self._root).with_suffix("").as_posix() for p in self._root.rglob("*.json")]
+
+    def checksum(self, item: MigrationItem) -> str:
+        return _md5(self._path(item))
+
+
+def _md5(path: Path) -> str:
+    digest = hashlib.md5()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

office365/migration/assessment/__init__.py

@@ -0,0 +1,27 @@
+"""Pre-migration assessment core — SMAT-style modular scans, scoped to containers.
+
+Product-specific scans live in the product packages
+(``office365.migration.sharepoint``, ``office365.migration.outlook``).
+"""
+
+from office365.migration.assessment.containers import ScanContainer
+from office365.migration.assessment.registry import ScanDefinition, scan_pairs
+from office365.migration.assessment.report import AssessmentReport, ScanReport
+from office365.migration.assessment.runner import ScanRunner
+from office365.migration.assessment.scanners import (
+    AssessmentOptions,
+    BaseScanner,
+    ScanTarget,
+)
+
+__all__ = [
+    "AssessmentOptions",
+    "AssessmentReport",
+    "BaseScanner",
+    "ScanContainer",
+    "ScanDefinition",
+    "ScanReport",
+    "ScanRunner",
+    "ScanTarget",
+    "scan_pairs",
+]

office365/migration/assessment/containers.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+
+class ScanContainer(Enum):
+    """Where a scan runs in the product object tree — the dispatch + report container.
+
+    Follows the container hierarchy (``TENANT -> SITE -> WEB -> LIST`` with
+    ``FIELDS`` / ``ITEMS`` / ``FILES`` as list sub-resources) for SharePoint;
+    Outlook adds ``MAILBOX -> MAIL_FOLDER``. Scans declare the container(s)
+    they consume; the per-product assessor walker loads each container's data
+    once and dispatches to the matching scans.
+    """
+
+    TENANT = "tenant"  # reserved — tenant assessor (site enumeration)
+    SITE = "site"  # the site collection
+    WEB = "web"  # subsite
+    LIST = "list"  # list / library container
+    FIELDS = "fields"  # a list's column schema
+    ITEMS = "items"  # list items
+    FILES = "files"  # list files / folders
+
+    # Outlook (mail)
+    MAILBOX = "mailbox"  # the mailbox root
+    MAIL_FOLDER = "mail_folder"  # a mail folder

office365/migration/assessment/export.py

@@ -0,0 +1,51 @@
+"""Assessment report export — write the issues and per-scan detail reports.
+
+Uses the report's records form (:meth:`AssessmentReport.to_records`) and the
+per-scan detail records (:attr:`AssessmentReport.scan_reports`), so the report
+model stays format-agnostic while the caller gets the downloadable
+assessment. Scan detail files land in a ``ScannerReports`` subfolder, mirroring
+SMAT's output layout (``<ScanName>-detail.csv``).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from office365.migration._util import write_csv_json
+from office365.migration.assessment.report import AssessmentReport
+
+_COLUMNS = ["severity", "category", "location", "message", "suggestion"]
+
+
+def export_assessment(report: AssessmentReport, output_dir: str | Path) -> list[str]:
+    """Write the aggregate issues plus each scan's detail report.
+
+    Args:
+        report: The assessment result.
+        output_dir: Directory to write the files into.
+
+    Returns:
+        List of written file paths.
+    """
+    written = write_csv_json(output_dir, "AssessmentReport", report.to_records(), _COLUMNS)
+    written += export_scan_reports(report, output_dir)
+    return written
+
+
+def export_scan_reports(report: AssessmentReport, output_dir: str | Path) -> list[str]:
+    """Write each scan's SMAT-style detail report (``ScannerReports/<Scan>-detail``).
+
+    Only scans that produced rows are written. Returns the written paths.
+    """
+    written: list[str] = []
+    for scan in report.scan_reports.values():
+        if not scan.records:
+            continue
+        written += write_csv_json(
+            os.path.join(output_dir, "ScannerReports"),
+            f"{scan.name}-detail",
+            scan.to_records(),
+            list(scan.columns),
+        )
+    return written