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

office365/runtime/odata/type_information.py

@@ -1,32 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Dict, Optional
-
-from typing_extensions import Self
-
-from office365.runtime.odata.member import MemberInformation
-from office365.runtime.odata.method import MethodInformation
-from office365.runtime.odata.property import PropertyInformation
-
-
-@dataclass
-class TypeInformation:
-    """Represents type metadata information in an OData service.
-
-    Contains metadata about entity types, complex types, and other structural
-    elements in an OData model. Used for type reflection and metadata operations.
-    """
-
-    BaseTypeFullName: str = ""
-    FullName: str = ""
-    IsValueObject: Optional[bool] = None
-    Methods: Dict[str, MethodInformation] = field(default_factory=dict)
-    Properties: Dict[str, PropertyInformation] = field(default_factory=dict)
-    Members: Dict[str, MemberInformation] = field(default_factory=dict)
-
-    def add_property(self, schema: PropertyInformation) -> Self:
-        self.Properties[schema.Name] = schema
-        return self
-
-    def add_member(self, schema: MemberInformation) -> Self:
-        self.Members[schema.Name] = schema
-        return self

office365/runtime/odata/v3/metadata_reader.py

@@ -1,52 +0,0 @@
-from typing import Dict, Optional
-from xml.etree.ElementTree import Element
-
-from office365.runtime.odata.property import PropertyInformation
-from office365.runtime.odata.reader import ODataReader
-
-
-class ODataV3Reader(ODataReader):
-    """OData v3 reader"""
-
-    def process_navigation_property_node(self, node: Element) -> Optional[PropertyInformation]:
-        schema = PropertyInformation()
-        schema.Name = node.get("Name") or ""
-        schema.IsNavigation = True
-
-        relationship = node.get("Relationship")
-        if relationship is None:
-            return None
-        to_role = node.get("ToRole")
-        if to_role is None:
-            return None
-
-        association_name = relationship.split(".")[-1] if "." in relationship else relationship
-
-        assert self._root is not None
-        association_node = self._root.find(f".//xmlns:Association[@Name='{association_name}']", self.xml_namespaces)
-        if association_node is None:
-            return None
-
-        end_node = association_node.find(f".//xmlns:End[@Role='{to_role}']", self.xml_namespaces)
-        if end_node is None:
-            return None
-
-        multiplicity = end_node.get("Multiplicity")
-
-        if multiplicity == "*":
-            schema.TypeName = f"Collection({end_node.get('Type')})"
-        else:
-            schema.TypeName = end_node.get("Type")
-
-        return schema
-
-    def process_method_node(self):
-        pass
-
-    @property
-    def xml_namespaces(self) -> Dict[str, str]:
-        return {
-            "xmlns": "http://schemas.microsoft.com/ado/2009/11/edm",
-            "edmx": "http://schemas.microsoft.com/ado/2007/06/edmx",
-            "m": "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata",
-        }

office365/runtime/odata/v4/metadata_reader.py

@@ -1,28 +0,0 @@
-from typing import Dict, Optional
-from xml.etree.ElementTree import Element
-
-from office365.runtime.odata.property import PropertyInformation
-from office365.runtime.odata.reader import ODataReader
-
-
-class ODataV4Reader(ODataReader):
-    """OData v4 reader"""
-
-    def process_navigation_property_node(self, node: Element) -> Optional[PropertyInformation]:
-        schema = PropertyInformation()
-        schema.Name = node.get("Name") or ""
-        schema.TypeName = node.get("Type")
-        schema.IsNavigation = True
-        schema.IsBeta = False
-
-        return schema
-
-    def process_method_node(self):
-        pass
-
-    @property
-    def xml_namespaces(self) -> Dict[str, str]:
-        return {
-            "xmlns": "http://docs.oasis-open.org/odata/ns/edm",
-            "edmx": "http://docs.oasis-open.org/odata/ns/edmx",
-        }

office365/runtime/queries/noop.py

@@ -1,17 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from office365.runtime.queries.client_query import ClientQuery
-
-if TYPE_CHECKING:
-    from office365.runtime.client_object import ClientObject
-
-
-class NoOpQuery(ClientQuery[Any]):
-    """Placeholder query for ensure_property when property is already cached.
-    Uses binding_type to hit the entity's own API URL, refreshing data from server.
-    """
-
-    def __init__(self, context, client_object: ClientObject):
-        super().__init__(context, binding_type=client_object, return_type=client_object)

office365/runtime/utilities.py

@@ -1,226 +0,0 @@
-from __future__ import annotations
-
-import mimetypes
-import warnings
-from datetime import datetime, timezone
-from enum import Enum
-from functools import wraps
-from typing import Any, Dict, Optional, Tuple, Union
-from urllib.parse import parse_qs, urlparse
-
-
-def is_absolute_url(url: str) -> bool:
-    """Determine if a URL is absolute (contains network location)."""
-    return bool(urlparse(url).netloc)
-
-
-def get_absolute_url(url: str) -> str:
-    """Extract the base URL (scheme+netloc) from a full URL.
-
-    Example:
-        >>> get_absolute_url("https://example.com/path?query=1")
-        'https://example.com'
-    """
-    path = urlparse(url).path
-    return url.replace(path, "")
-
-
-def parse_query_param(url: str, key: str) -> str:
-    """Extract the first value of a query string parameter.
-
-    Args:
-        url: URL containing query string
-        key: Query parameter key to look up
-
-    Returns:
-        First value for the specified key
-
-    Raises:
-        KeyError: If parameter not found
-    """
-    parsed_url = urlparse(url)
-    return parse_qs(parsed_url.query)[key][0]
-
-
-def get_mime_type(file_name: str) -> tuple[str | None, str | None]:
-    """Guess the MIME type and encoding for a filename.
-
-    Returns:
-        Tuple of (type, encoding) where either may be None
-    """
-    return mimetypes.guess_type(file_name)
-
-
-def deprecated(reason: str, version: str = "next"):
-    """Mark functions/methods as deprecated with a warning.
-
-    Args:
-        reason: Explanation why this is deprecated
-        version: Version when this will be removed
-    """
-
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            warnings.warn(
-                f"{func.__name__} is deprecated and will be removed in v{version}. {reason}",
-                category=FutureWarning,
-                stacklevel=2,
-            )
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def parse_enum(enum_type: type[Enum], value: str | int) -> Optional[Enum]:
-    """Safely converts a value to the specified enum type.
-
-    Args:
-        enum_type: The Enum class to convert to
-        value: The raw value to convert
-
-    Returns:
-        The enum member or None if conversion fails
-    """
-    try:
-        return enum_type(value)
-    except ValueError:
-        try:
-            return enum_type[str(value)]  # fallback: lookup by name
-        except KeyError:
-            return None
-
-
-def _normalize_datetime_string(value: str) -> str:
-    """Truncate or pad fractional seconds to exactly 6 digits for %f compatibility."""
-    if "." not in value:
-        return value
-    before, _, after = value.partition(".")
-    frac = after.rstrip("Z")[:6].ljust(6, "0")
-    return f"{before}.{frac}{'Z' if after.endswith('Z') else ''}"
-
-
-def parse_datetime(value: Union[str, datetime, None]) -> Optional[datetime]:
-    """
-    Converts string representations of Edm.DateTime/Edm.DateTimeOffset to datetime.
-
-    Args:
-        value: Input value (string, datetime, or None)
-
-    Returns:
-        Parsed datetime or None if conversion fails
-
-    Examples:
-        >>> parse_datetime("2023-01-01T12:00:00Z")
-        datetime.datetime(2023, 1, 1, 12, 0)
-    """
-    if value is None:
-        return None
-    if isinstance(value, datetime):
-        return value
-
-    known_formats = [
-        "%Y-%m-%dT%H:%M:%SZ",  # ISO 8601 UTC
-        "%Y-%m-%dT%H:%M:%S.%fZ",  # ISO 8601 with microseconds
-        "%Y-%m-%dT%H:%M:%S",  # Without timezone
-        "%Y-%m-%dT%H:%M:%S.%f",  # With microseconds no TZ
-        "%Y-%m-%d",  # Date only
-    ]
-
-    if isinstance(value, str):
-        value = _normalize_datetime_string(value)
-
-    for fmt in known_formats:
-        try:
-            result = datetime.strptime(value, fmt)
-            if result.tzinfo is None and fmt.endswith("Z"):
-                result = result.replace(tzinfo=timezone.utc)
-            return result
-        except ValueError:
-            continue
-    return None
-
-
-def parse_key_value(value: Dict[str, Any]) -> Tuple[Optional[str], Any]:
-    """Parses SharePoint key-value pairs with type conversion and warnings.
-
-    Args:
-        value: Dictionary containing:
-            - Key: The field name
-            - Value: The raw value to convert
-            - ValueType: The OData type descriptor
-
-    Returns:
-        Tuple of (original_key, converted_value). Returns original values on failure.
-
-    Warnings:
-        RuntimeWarning: When type conversion fails
-    """
-    key = value.get("Key")
-    raw_value = value.get("Value")
-    value_type = value.get("ValueType")
-
-    # Early return for missing data
-    if None in (key, value_type, raw_value):
-        return key, raw_value
-
-    # Type conversion mapping
-    conversions = {
-        "Edm.Int64": int,
-        "Edm.Int32": int,
-        "Edm.Double": float,
-        "Edm.Boolean": lambda v: v.lower() == "true",
-        "Edm.Binary": bytes.fromhex,
-        "Edm.DateTime": parse_datetime,
-        "Edm.Guid": str,
-    }
-
-    if value_type not in conversions:
-        return key, raw_value
-
-    try:
-        return key, conversions[value_type](raw_value)  # type: ignore
-    except (ValueError, AttributeError, TypeError) as e:
-        warnings.warn(
-            f"Failed to convert {key!r} (type {value_type}): {str(e)}",
-            RuntimeWarning,
-            stacklevel=2,  # Points to caller's line
-        )
-        return key, raw_value
-
-
-def parse_key_value_collection(
-    value: Dict[int, Dict[str, Any]],
-) -> Dict[str, Union[str, int, float, bool, bytes]]:
-    """Converts a SharePoint KeyValue collection to a Python dictionary with proper type conversion.
-
-    Args:
-        value: Dictionary in format {index: {'Key':..., 'Value':..., 'ValueType':...}}
-
-    Returns:
-        Dictionary with {key: converted_value} pairs
-
-    Examples:
-        >>> parse_key_value_collection(
-        ...     {
-        ...         0: {"Key": "UserProfile_GUID", "Value": "d895ff01...", "ValueType": "Edm.String"},
-        ...         1: {"Key": "IsAdmin", "Value": "true", "ValueType": "Edm.Boolean"},
-        ...     }
-        ... )
-        {'UserProfile_GUID': 'd895ff01...', 'IsAdmin': True}
-    """
-    result = {}
-    for item in value.values():
-        try:
-            key, converted_value = parse_key_value(item)
-            if key is not None:  # Only add if key exists
-                result[key] = converted_value
-        except (KeyError, ValueError, TypeError) as e:
-            warnings.warn(
-                f"Skipping malformed KeyValue entry: {str(e)}",
-                RuntimeWarning,
-                stacklevel=2,
-            )
-    return result

office365/sharepoint/migration/assessment/scanners/base.py

@@ -1,57 +0,0 @@
-from abc import ABC, abstractmethod
-from functools import wraps
-from typing import Any, Callable, Dict, Generic
-
-from typing_extensions import Self
-
-from office365.runtime.client_object import ClientObjectT
-
-
-def mapped_property(name: str) -> Callable:
-    """
-    Decorator that maps a property to a specific key in _properties
-
-    Args:
-        name: The key to use when storing in _properties dictionary
-    """
-
-    def decorator(func: Callable) -> property:
-        @wraps(func)
-        def wrapper(self: Any) -> Any:
-            value = func(self)
-            if hasattr(self, "_properties"):
-                self._properties[name] = value
-            return value
-
-        wrapper._serialized = True  # type: ignore[attr-defined]
-        return property(wrapper)
-
-    return decorator
-
-
-class BaseScanner(ABC, Generic[ClientObjectT]):
-    def __init__(self, source: ClientObjectT) -> None:
-        self.source = source
-        self._properties: Dict[str, Any] = {}
-
-    @abstractmethod
-    def build_query(self) -> Self:
-        pass
-
-    def scan(self) -> Self:
-        self.build_query()
-        self.source.execute_query()
-        self.process()
-        return self
-
-    def process(self) -> None:
-        for name, attr in self.__class__.__dict__.items():
-            if isinstance(attr, property) and hasattr(attr.fget, "_serialized"):
-                getattr(self, name)
-
-    @property
-    def properties(self):
-        return self._properties
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({self._properties})"

office365/sharepoint/migration/assessment/scanners/list.py

@@ -1,68 +0,0 @@
-from typing_extensions import Self
-
-from office365.sharepoint.listitems.collection import ListItemCollection
-from office365.sharepoint.lists.list import List
-from office365.sharepoint.migration.assessment.scanners.base import BaseScanner, mapped_property
-
-
-class ListScanner(BaseScanner[List]):
-    @property
-    def files_count(self):
-        return self._properties.get("FilesCount", None)
-
-    @property
-    def folders_count(self):
-        return self._properties.get("FoldersCount", None)
-
-    @mapped_property("ItemsCount")
-    def items_count(self):
-        return self.source.item_count
-
-    @mapped_property("FieldsCount")
-    def fields_count(self):
-        return len(self.source.fields)
-
-    @mapped_property("ContentTypesCount")
-    def content_types_count(self):
-        return len(self.source.content_types)
-
-    @property
-    def list_template(self):
-        return self.source.base_template
-
-    def build_query(self) -> Self:
-        self._query_list_metadata()
-
-        self._query_list_items()
-
-        return self
-
-    def _query_list_metadata(self):
-        self.source.select(
-            [
-                "Id",
-                "Title",
-                "IsCatalog",
-                "BaseTemplate",
-                "ItemCount",
-                "SchemaXml",
-                "LastItemModifiedDate",
-                "RootFolder/ServerRelativeUrl",
-                "ContentTypes/Name",
-                "Fields/InternalName",
-            ]
-        ).expand(["RootFolder", "ContentTypes", "Fields"]).get()
-
-    def _query_list_items(self):
-        self.source.items.select(["Id", "FSObjType", "FileLeafRef", "ContentTypeId"]).get().paged(
-            page_size=1000, page_loaded=self._process_item
-        )
-
-    def _process_item(self, items: ListItemCollection) -> None:
-        self._properties.setdefault("FilesCount", 0)
-        self._properties.setdefault("FoldersCount", 0)
-
-        file_count = sum(1 for item in items if item.properties.get("FSObjType") == 0)
-        folder_count = sum(1 for item in items if item.properties.get("FSObjType") == 1)
-        self._properties["FilesCount"] += file_count
-        self._properties["FoldersCount"] += folder_count

office365/sharepoint/migration/assessment/scanners/site.py

@@ -1,25 +0,0 @@
-from office365.sharepoint.migration.assessment.scanners.base import BaseScanner, mapped_property
-from office365.sharepoint.sites.site import Site
-
-
-class SiteScanner(BaseScanner[Site]):
-    """ """
-
-    @mapped_property("FeaturesCount")
-    def features_count(self):
-        return len(self.source.features)
-
-    @mapped_property("UsersCount")
-    def users_count(self):
-        return len(self.source.root_web.site_users)
-
-    @mapped_property("GroupsCount")
-    def groups_count(self):
-        return len(self.source.root_web.site_groups)
-
-    def build_query(self):
-        self.source.select(["UsageInfo", "Features/Name"]).expand(["Features"]).get()
-
-        self.source.root_web.site_users.get()
-        self.source.root_web.site_groups.get()
-        return self

office365/todo/wellknown_list_name.py

@@ -1,2 +0,0 @@
-class WellknownListName:
-    pass