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

office365/runtime/client_request_exception.py

@@ -1,12 +1,69 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Optional
 
 from requests import RequestException, Response
 
+from office365.runtime.converters.scalars import parse_int
+
 _HEADER_REQUEST_IDS = ("request-id", "client-request-id", "SPRequestGuid")
 
 
+@dataclass(frozen=True)
+class ErrorPayload:
+    """Normalized view of an OData error response, parsed once for classification."""
+
+    code: str = ""
+    message: str = ""
+    details: tuple[dict, ...] = ()
+    status: Optional[int] = None
+
+    @property
+    def hresult(self) -> Optional[str]:
+        """The leading HRESULT of a SharePoint ``code`` (e.g. ``-2147018894``).
+
+        SharePoint encodes the error as ``"<hresult>, <dotnet-type>"`` (locale
+        independent), while Graph uses symbolic codes; returns ``None`` when the
+        code has no numeric prefix.
+        """
+        token = self.code.split(",", 1)[0].strip()
+        return token if token.lstrip("-").isdigit() else None
+
+    @property
+    def error_type(self) -> Optional[str]:
+        """The .NET type name embedded in a SharePoint ``code`` after the comma.
+
+        For ``"-2147018894, Microsoft.SharePoint.SPFileLockException"`` this is
+        ``"Microsoft.SharePoint.SPFileLockException"`` — a locale-independent,
+        self-describing discriminator that avoids matching on translated messages.
+        """
+        if "," not in self.code:
+            return None
+        type_name = self.code.split(",", 1)[1].strip()
+        return type_name or None
+
+
+def _parse_error(response: Response) -> dict:
+    try:
+        error = response.json().get("error", {})
+    except Exception:
+        return {}
+    return error if isinstance(error, dict) else {}
+
+
+def _to_payload(error: dict, response: Response) -> ErrorPayload:
+    msg = error.get("message")
+    message = str(msg.get("value", "")) if isinstance(msg, dict) else str(msg or "")
+    details = error.get("details")
+    return ErrorPayload(
+        code=str(error.get("code") or ""),
+        message=message,
+        details=tuple(d for d in details if isinstance(d, dict)) if isinstance(details, list) else (),
+        status=getattr(response, "status_code", None),
+    )
+
+
 class ClientRequestException(RequestException):
     """Custom exception for client requests with enhanced error handling.
 
@@ -20,38 +77,37 @@ class ClientRequestException(RequestException):
         super().__init__(*args, **kwargs)
         self._error: dict = {}
 
+    #: Specificity of this type when several match a payload; the highest wins
+    #: (ties broken by registration order). Lets catch-alls coexist with the
+    #: concrete types without depending on import order.
+    MATCH_PRIORITY: int = 0
+
+    @classmethod
+    def matches(cls, payload: ErrorPayload) -> bool:
+        """Whether this exception type describes the given error payload."""
+        return False
+
     @classmethod
     def from_response(cls, response: Response) -> ClientRequestException:
         """Factory: parse error response, dispatch to the right exception type.
 
-        Inspects the error payload once and returns a specific subclass
-        (e.g. DuplicatedObjectException), so callers never deal with
-        HTTP status codes or error JSON.
+        Inspects the error payload once and returns the most specific matching
+        subclass (e.g. ``DuplicatedObjectException``), so callers never deal with
+        HTTP status codes or error JSON. ``MATCH_PRIORITY`` decides between
+        overlapping types and registration order breaks ties.
         """
-        try:
-            error = response.json().get("error", {})
-        except Exception:
-            error = {}
-
-        if not isinstance(error, dict):
-            error = {}
-
-        details = error.get("details", [])
-        code = error.get("code") or ""
-        msg = error.get("message")
-        msg_text = str(msg.get("value", "")) if isinstance(msg, dict) else str(msg or "")
-        if (
-            code in {"nameAlreadyExists", "ErrorFolderExists"}
-            or any(d.get("code") == "ConflictingObjects" for d in details)
-            or "183" in code
-            or "-2130575342" in code  # SharePoint: list/survey/document library already exists
-            or "already exists" in msg_text.lower()
-        ):
-            exc: ClientRequestException = DuplicatedObjectException(response=response)
-        elif "-2147024809" in code or code.lower() in {"itemnotfound", "resourcenotfound", "notfound"}:
-            exc: ClientRequestException = ObjectNotFoundException(response=response)
-        else:
-            exc = cls(response=response)
+        from office365.runtime import exceptions  # noqa: F401 — registers the built-in error types
+
+        error = _parse_error(response)
+        payload = _to_payload(error, response)
+        matches = [
+            (getattr(exc_type, "MATCH_PRIORITY", 0), -index, exc_type)
+            for index, exc_type in enumerate(_ERROR_TYPES)
+            if exc_type.matches(payload)
+        ]
+        exc: ClientRequestException = (
+            max(matches, key=lambda item: item[:2])[2](response=response) if matches else cls(response=response)
+        )
 
         exc._error = error
         if error:
@@ -65,6 +121,24 @@ class ClientRequestException(RequestException):
     def code(self) -> Optional[str]:
         return self._error.get("code")
 
+    @property
+    def hresult(self) -> Optional[str]:
+        """The leading HRESULT of a SharePoint ``code`` (``None`` for Graph codes)."""
+        code = self.code
+        if not code:
+            return None
+        token = code.split(",", 1)[0].strip()
+        return token if token.lstrip("-").isdigit() else None
+
+    @property
+    def error_type(self) -> Optional[str]:
+        """The .NET type name embedded in a SharePoint ``code`` (after the comma)."""
+        code = self.code
+        if not code or "," not in code:
+            return None
+        type_name = code.split(",", 1)[1].strip()
+        return type_name or None
+
     @property
     def message(self) -> str:
         msg = self._error.get("message")
@@ -107,25 +181,39 @@ class ClientRequestException(RequestException):
     @property
     def duration_ms(self) -> Optional[int]:
         """SharePoint server-side processing time (``SPRequestDuration``), ms."""
-        return _to_int((getattr(self.response, "headers", None) or {}).get("SPRequestDuration"))
+        return parse_int((getattr(self.response, "headers", None) or {}).get("SPRequestDuration"))
 
     @property
     def health_score(self) -> Optional[int]:
         """SharePoint server health score (``X-SharePointHealthScore``)."""
-        return _to_int((getattr(self.response, "headers", None) or {}).get("X-SharePointHealthScore"))
+        return parse_int((getattr(self.response, "headers", None) or {}).get("X-SharePointHealthScore"))
 
 
-def _to_int(value: object) -> Optional[int]:
-    """Parse a header value into an int, returning None when absent/invalid."""
-    try:
-        return int(value)  # type: ignore[arg-type]
-    except (TypeError, ValueError):
-        return None
+# Error types consulted by ``from_response``. The generic runtime types live in
+# ``office365.runtime.exceptions`` and product packages (e.g.
+# ``office365.sharepoint.exceptions``) register their own; both call
+# ``register_error_type`` so the dispatcher stays product-agnostic. Specificity is
+# decided by ``MATCH_PRIORITY`` (registration order breaks ties), not import order.
+_ERROR_TYPES: list[type[ClientRequestException]] = []
+
+
+def register_error_type(exc_type: type[ClientRequestException]) -> None:
+    """Register an error type for ``from_response`` dispatch.
+
+    Modules call this at import time; the dispatcher picks the highest
+    ``MATCH_PRIORITY`` match, breaking ties by registration order (earlier wins).
+    """
+    if exc_type not in _ERROR_TYPES:
+        _ERROR_TYPES.append(exc_type)
+
 
+_LAZY_EXPORTS = ("DuplicatedObjectException", "ObjectNotFoundException")
 
-class DuplicatedObjectException(ClientRequestException):
-    """Raised when creating an object that already exists (HTTP 400 + ConflictingObjects)."""
 
+def __getattr__(name: str):
+    """Backward-compatible re-export of the generic error types (now in ``exceptions``)."""
+    if name in _LAZY_EXPORTS:
+        from office365.runtime import exceptions
 
-class ObjectNotFoundException(ClientRequestException):
-    """Raised when a requested object is not found (HTTP 404 or ResourceNotFound code)."""
+        return getattr(exceptions, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

office365/runtime/client_runtime_context.py

@@ -12,11 +12,13 @@ from office365.runtime.client_request_exception import ClientRequestException
 from office365.runtime.client_result import ClientResult
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.http.request_options import RequestOptions
+from office365.runtime.limits import Limit, LimitDecl, collect_class_limits, collect_limit_meta
 from office365.runtime.queries.client_query import ClientQuery
 from office365.runtime.queries.read_entity import ReadEntityQuery
 
 if TYPE_CHECKING:
     from office365.runtime.client_object import ClientObject
+    from office365.runtime.http.throttling import RateLimiter
     from office365.runtime.queries.batch import BatchQuery
 
 
@@ -26,11 +28,26 @@ class ClientRuntimeContext(ABC):
     Provides core functionality for executing queries and managing request lifecycle.
     """
 
+    _limit_meta: dict[str, Tuple[LimitDecl, ...]] = {}
+    _class_limit_decls: Tuple[LimitDecl, ...] = ()
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        cls._limit_meta = collect_limit_meta(cls)
+        cls._class_limit_decls = collect_class_limits(cls)
+
     def __init__(self) -> None:
         self._queries: deque[ClientQuery] = deque()
         self._current_query = None
         self._pending_request: ClientRequest | None = None
 
+    @classmethod
+    def declared_limits(cls) -> Tuple[Limit, ...]:
+        """The limits declared on this class and its methods/properties (``@limit``)."""
+        class_limits = tuple(decl.limit for decl in cls._class_limit_decls)
+        member_limits = tuple(decl.limit for decls in cls._limit_meta.values() for decl in decls)
+        return (*class_limits, *member_limits)
+
     @property
     def service_root_url(self) -> str:
         """Get the API service root URL"""
@@ -54,6 +71,7 @@ class ClientRuntimeContext(ABC):
         success_callback: Optional[Callable[[ClientObject | None], None]] = None,
         failure_callback: Optional[Callable[[int, Exception], Optional[int]]] = None,
         exceptions: Tuple[Type[Exception], ...] = (ClientRequestException,),
+        is_retriable: Optional[Callable[[Exception], bool]] = None,
     ) -> None:
         """Executes pending queries with retry logic.
 
@@ -74,8 +92,12 @@ class ClientRuntimeContext(ABC):
             failure_callback: Called after each failed attempt; may return a
                 retry delay in seconds to override the backoff
             exceptions: Exception types that trigger retries
+            is_retriable: Optional predicate deciding whether a caught exception
+                is retried. Defaults to :func:`~office365.runtime.retry.is_transient_error`;
+                pass :func:`~office365.runtime.retry.retry_on` to also retry
+                otherwise-permanent errors such as a locked file (HTTP 423).
         """
-        from office365.runtime.retry import retry
+        from office365.runtime.retry import is_transient_error, retry
 
         def _on_failure(_attempt: int, ex: Exception) -> Optional[int]:
             # Re-queue the failed query for a retry, except on the last attempt —
@@ -96,6 +118,7 @@ class ClientRuntimeContext(ABC):
                 max_delay=max_delay,
                 jitter=jitter,
                 exceptions=exceptions,
+                is_retriable=is_retriable or is_transient_error,
                 on_failure=_on_failure,
                 on_success=_on_success,
             )
@@ -188,6 +211,12 @@ class ClientRuntimeContext(ABC):
         return self
 
     def on_error(self, action: Callable[[ClientRequestException], None], once: bool = True) -> Self:
+        """Attach an error handler for the pending query — the error is swallowed.
+
+        This is a control hook (see :meth:`ClientRequest.on_error`): once a
+        handler is attached, a failing query is considered handled and does not
+        re-raise. Use ``after_execute`` / ``throttle_guard`` for observation.
+        """
         if len(self._queries) == 0:
             return self
         query = self._queries[-1]
@@ -210,6 +239,33 @@ class ClientRuntimeContext(ABC):
         """
         return self.pending_request().execute_request(path)
 
+    @property
+    def rate_limiter(self) -> "RateLimiter | None":
+        """The shared rate limiter pacing this context's requests, if any.
+
+        Returns ``None`` until :meth:`with_rate_limit` (or a shared limiter via
+        ``ClientRequest.with_rate_limiter``) is configured.
+        """
+        return self.pending_request().rate_limiter
+
+    def with_rate_limit(self, health_threshold: int = 80, min_interval: float = 0.0) -> Self:
+        """Enable fleet-wide pacing for this context (opt-in).
+
+        Wraps the context transport with a shared rate limiter, so every request
+        — including the parallel batches dispatched by ``execute_batch`` — is
+        gated by ``Retry-After`` / ``X-SharePointHealthScore`` as a group. Call
+        this after any transport configuration (``with_transport``).
+
+        Args:
+            health_threshold: Health score at/above which the group paces.
+            min_interval: Minimum pause applied on a high health score (seconds).
+
+        Returns:
+            Self: Supports method chaining
+        """
+        self.pending_request().with_rate_limit(health_threshold=health_threshold, min_interval=min_interval)
+        return self
+
     def execute_query(self) -> Self:
         """Executes all pending queries.
 
@@ -428,24 +484,39 @@ class ClientRuntimeContext(ABC):
         """Execute batch units concurrently on a thread pool.
 
         Reuses the generic :func:`~office365.runtime.parallel.run_parallel`
-        primitive; ``success_callback`` is invoked per batch in **input order**
-        (deterministic). On the first failure the exception is re-raised.
+        primitive; ``success_callback`` is invoked **live, as each batch
+        completes** (on the calling thread), so callers can report progress.
+        After the pool drains, the first failure is re-raised.
 
         Args:
             batches: Batch units to execute
             concurrency: Maximum number of concurrent batch requests
-            success_callback: Called with each batch's return types
+            success_callback: Called with each successfully completed batch's
+                return types, in completion order
         """
         from office365.runtime.parallel import run_parallel
 
-        results = run_parallel(
+        errors: list[BaseException] = []
+
+        def _on_progress(snapshot: Any) -> None:
+            if not callable(success_callback):
+                return
+            for return_types in snapshot.items or []:
+                if return_types is not None:
+                    success_callback(return_types)
+
+        def _on_error(_task: Any, error: BaseException) -> None:
+            errors.append(error)
+
+        run_parallel(
             lambda _ctx, batch_qry: self._execute_batch(batch_qry),
             batches,
             concurrency=concurrency,
+            progress=_on_progress,
+            on_error=_on_error,
         )
-        if callable(success_callback):
-            for return_types in results:
-                success_callback(return_types)
+        if errors:
+            raise errors[0]
 
     def _execute_batch(self, batch_qry: "BatchQuery") -> List[Any]:
         """Execute a single batch unit (implemented by concrete contexts)."""

office365/runtime/converters/csv_writer.py

@@ -22,7 +22,7 @@ def _cell(value: Any) -> str:
     return str(value)
 
 
-def write_csv(collection: ClientObjectCollection, file: IO[str]) -> None:
+def write_csv(collection: ClientObjectCollection, file: IO[str], delimiter: str = ",") -> None:
     """Write collection items to CSV using the shared record projection.
 
     The projection (``records.iter_records``) mirrors the previous behaviour:
@@ -38,10 +38,10 @@ def write_csv(collection: ClientObjectCollection, file: IO[str]) -> None:
         ...     .to_csv(f) \\
         ...     .execute_query()
     """
-    write_records(iter_records(collection), file)
+    write_records(iter_records(collection), file, delimiter=delimiter)
 
 
-def write_records(records: list[dict], file: IO[str], columns: Optional[List[str]] = None) -> None:
+def write_records(records: list[dict], file: IO[str], columns: Optional[List[str]] = None, delimiter: str = ",") -> None:
     """Write a list of dict records to CSV.
 
     Args:
@@ -54,7 +54,13 @@ def write_records(records: list[dict], file: IO[str], columns: Optional[List[str
         return
     if columns is None:
         columns = list(dict.fromkeys(key for record in records for key in record))
-    writer = csv.writer(file)
+    writer = csv.writer(file, delimiter=delimiter)
     writer.writerow(columns)
+    write_rows(records, file, columns, delimiter)
+
+
+def write_rows(records: list[dict], file: IO[str], columns: list[str], delimiter: str = ",") -> None:
+    """Write data rows only (no header) — used by the paged/streaming exporter."""
+    writer = csv.writer(file, delimiter=delimiter)
     for record in records:
         writer.writerow([_cell(record.get(key)) for key in columns])

office365/runtime/converters/dataframe.py

@@ -9,7 +9,9 @@ risk of requiring the ``[pandas]`` extra.
 from __future__ import annotations
 
 import math
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
+from datetime import date, datetime
+from os import PathLike
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, cast
 
 from typing_extensions import Self
 
@@ -74,6 +76,43 @@ def read_dataframe(df) -> List[Dict[str, Any]]:
     return records_from_dataframe(df)
 
 
+def dataframe_to_bytes(df, format: str = "csv", index: bool = False, **opts: Any) -> bytes:  # noqa: A002
+    """Serialize a DataFrame to file bytes (``csv``/``xlsx``/``json``/``parquet``).
+
+    CSV is written UTF-8 with a BOM (``utf-8-sig``) so Excel keeps the columns.
+    """
+    import io
+
+    if format in ("xlsx", "excel"):
+        buffer = io.BytesIO()
+        df.to_excel(buffer, index=index, **opts)
+        return buffer.getvalue()
+    if format == "json":
+        return df.to_json(**opts).encode("utf-8")
+    if format in ("parquet", "orc", "feather"):
+        buffer = io.BytesIO()
+        writer = {"parquet": df.to_parquet, "orc": df.to_orc, "feather": df.to_feather}[format]
+        writer(buffer, **opts)
+        return buffer.getvalue()
+    return df.to_csv(index=index, **opts).encode("utf-8-sig")
+
+
+def dataframe_from_bytes(content: bytes, format: str = "csv", **opts: Any) -> "pd.DataFrame":  # noqa: A002
+    """Parse in-memory file bytes into a DataFrame (``csv``/``xlsx``/``json``/``parquet``)."""
+    import io
+
+    pd = require_pandas()
+    buffer = io.BytesIO(content)
+    if format in ("xlsx", "excel"):
+        return pd.read_excel(buffer, **opts)
+    if format == "json":
+        return pd.read_json(buffer, **opts)
+    if format in ("parquet", "orc", "feather"):
+        reader = {"parquet": pd.read_parquet, "orc": pd.read_orc, "feather": pd.read_feather}[format]
+        return reader(buffer, **opts)
+    return pd.read_csv(buffer, **opts)
+
+
 def series_kind(pd, series) -> str:
     """Categorize a pandas column dtype into a generic kind.
 
@@ -81,19 +120,36 @@ def series_kind(pd, series) -> str:
     Kept in the pandas boundary so callers can map the generic kind onto their
     own schema (e.g. a SharePoint ``FieldType``) without importing pandas.
 
+    Nullable dtypes are handled; complex and timedelta map to ``"text"`` (no
+    SharePoint equivalent), and an object column holding only ``datetime``/``date``
+    values is treated as ``"datetime"``.
+
     Args:
         pd: The pandas module (e.g. from :func:`require_pandas`).
         series: A pandas Series (a DataFrame column).
     """
-    if pd.api.types.is_bool_dtype(series):
+    dtype = series.dtype
+    if pd.api.types.is_bool_dtype(dtype):
         return "boolean"
-    if pd.api.types.is_datetime64_any_dtype(series):
+    if pd.api.types.is_datetime64_any_dtype(dtype):
         return "datetime"
-    if pd.api.types.is_numeric_dtype(series):
+    if pd.api.types.is_complex_dtype(dtype):
+        return "text"
+    if pd.api.types.is_numeric_dtype(dtype):
         return "number"
+    if pd.api.types.is_object_dtype(dtype) and _holds_datetimes(series):
+        return "datetime"
     return "text"
 
 
+def _holds_datetimes(series) -> bool:
+    """Whether an object-dtype column holds only ``datetime``/``date`` values."""
+    non_null = series.dropna()
+    if non_null.empty:
+        return False
+    return all(isinstance(value, (datetime, date)) for value in non_null.head(100))
+
+
 def records_from_dataframe(
     df,
     key_fn: Optional[Callable[[str], str]] = None,
@@ -120,3 +176,27 @@ def records_from_dataframe(
             record[key_fn(key) if key_fn is not None else key] = value
         records.append(record)
     return records
+
+
+def dataframe_chunks(source: Any, chunksize: int) -> tuple[Iterator[Any], Optional[int]]:
+    """Split a DataFrame/CSV source into chunks, with the total when known.
+
+    Accepts a ``DataFrame`` (sliced into ``chunksize``-row slices), a CSV
+    path/URL/file (read with ``pandas.read_csv(chunksize=)``), a pandas chunk
+    reader (``pd.read_csv(..., chunksize=)``, used as-is), or any iterable of
+    chunks (used as-is). Returns ``(chunks, total)`` — ``total`` is ``None`` when
+    it can't be known upfront (a CSV stream or an opaque iterable).
+
+    Args:
+        source: A DataFrame, a CSV path/URL/file, or an iterable of chunks.
+        chunksize: Rows per chunk for a DataFrame or CSV source.
+    """
+    if hasattr(source, "iloc"):  # a pandas DataFrame — slice it (bounded queue)
+        total = len(source)
+        return (source.iloc[start : start + chunksize] for start in range(0, total, chunksize)), total
+    if hasattr(source, "get_chunk"):  # a pandas TextFileReader (already chunked) — iterate
+        return iter(source), None
+    if isinstance(source, (str, PathLike)) or hasattr(source, "read"):
+        pd = require_pandas()
+        return pd.read_csv(source, chunksize=chunksize), None
+    return iter(source), None

office365/runtime/converters/json_file.py

@@ -7,15 +7,24 @@ of records — useful for round-tripping an export verbatim.
 from __future__ import annotations
 
 import json
-from typing import IO, Any, Dict, List
+from typing import IO, Any, Dict, List, Optional
 
 
-def write_json(records: List[Dict[str, Any]], file: IO[str]) -> None:
+def write_json(records: List[Dict[str, Any]], file: IO[str], indent: Optional[int] = None) -> None:
     """Write records as a JSON array."""
-    json.dump(records, file)
+    json.dump(records, file, indent=indent, default=str)
 
 
 def read_json(file: IO[str]) -> List[Dict[str, Any]]:
     """Read a JSON array of records."""
     data = json.load(file)
     return data if isinstance(data, list) else []
+
+
+def record_to_json(payload: Any) -> str:
+    """Serialize a record to the canonical JSON text used when persisting it.
+
+    Non-JSON values (entity/datetime objects) fall back to ``str`` so the text is
+    stable — source and target checksums both use this form.
+    """
+    return json.dumps(payload, indent=2, default=str)

office365/runtime/converters/parquet.py

@@ -0,0 +1,67 @@
+"""Parquet/ORC/Feather reader/writer via pyarrow — the optional-dependency boundary.
+
+Every function imports pyarrow lazily, so the core library never depends on it
+(``pip install office365-rest-python-client[parquet]``). Sources/targets accept a
+path or an open binary stream.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+def require_pyarrow():
+    """Import pyarrow or raise an actionable error."""
+    try:
+        import pyarrow  # type: ignore[import-not-found]
+    except ImportError:
+        raise ImportError("pip install office365-rest-python-client[parquet]") from None
+    return pyarrow
+
+
+def _read(source: Any, reader: str) -> List[Dict[str, Any]]:
+    require_pyarrow()
+    from office365.runtime.converters.streams import open_binary
+
+    module = __import__(f"pyarrow.{reader}", fromlist=["read_table"])
+    with open_binary(source, "rb") as f:
+        return module.read_table(f).to_pylist()
+
+
+def _write(records: List[Dict[str, Any]], target: Any, writer: str) -> None:
+    import pyarrow as pa  # type: ignore[import-not-found]
+
+    require_pyarrow()
+    from office365.runtime.converters.streams import open_binary
+
+    module = __import__(f"pyarrow.{writer}", fromlist=["write_table"])
+    table = pa.Table.from_pylist(records)
+    with open_binary(target, "wb") as f:
+        if writer == "feather":
+            module.write_feather(table, f)
+        else:
+            module.write_table(table, f)
+
+
+def read_parquet(source: Any) -> List[Dict[str, Any]]:
+    return _read(source, "parquet")
+
+
+def write_parquet(records: List[Dict[str, Any]], target: Any) -> None:
+    _write(records, target, "parquet")
+
+
+def read_orc(source: Any) -> List[Dict[str, Any]]:
+    return _read(source, "orc")
+
+
+def write_orc(records: List[Dict[str, Any]], target: Any) -> None:
+    _write(records, target, "orc")
+
+
+def read_feather(source: Any) -> List[Dict[str, Any]]:
+    return _read(source, "feather")
+
+
+def write_feather(records: List[Dict[str, Any]], target: Any) -> None:
+    _write(records, target, "feather")