contextbase-shared-plugins 0.0.0a1__py3-none-any.whl

shared_plugins/microsoft_dataverse/types.py

@@ -0,0 +1,355 @@
+"""Dataverse AttributeType → dlt TColumnSchema mapping.
+
+Single source of truth for every type-mapping decision the plan §9 locks in.
+Unknown types raise loudly — new Microsoft types must be added explicitly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from shared_plugins.exceptions import PluginConfigurationError
+
+from .annotations import ODATA_ANNOTATION_COLUMN_SUFFIXES
+from .identifiers import annotation_column_name
+from .metadata import AttributeMetadataIngress, extract_label
+
+# Existing skips preserved from plugin's runtime_ingress.py.
+SKIPPED_ATTRIBUTE_TYPES: frozenset[str] = frozenset(
+    {
+        "Virtual",
+        "File",
+        "Image",
+        "CalendarRules",
+        "PartyList",
+        "ManagedProperty",
+    }
+)
+# Attributes that appear in EntityDefinitions metadata but are not exposed as
+# OData-selectable properties on the entity type, so a $select naming them
+# fails with HTTP 400 ("Could not find a property named ..."). No single
+# metadata flag distinguishes them (IsValidODataAttribute is false for many
+# perfectly selectable columns too), so they are enumerated explicitly:
+#   stageid         — BPF stage pointer, present on most entities
+#   attachmentcount — activity attachment rollup (email/appointment)
+SKIPPED_ATTRIBUTE_NAMES: frozenset[str] = frozenset({"stageid", "attachmentcount"})
+
+LOOKUP_ATTRIBUTE_TYPES: frozenset[str] = frozenset({"Customer", "Lookup", "Owner"})
+PICKLIST_ATTRIBUTE_TYPES: frozenset[str] = frozenset({"Picklist", "State", "Status"})
+
+# Scalar AttributeTypes that emit @OData.Community.Display.V1.FormattedValue
+# alongside their raw value, so the builder reserves a _formatted_value
+# companion column. Empirically observed: all numeric scalars + Boolean emit a
+# locale-rendered string (customer tenant, May 2026); EntityName emits the
+# referenced entity's display label (e.g. activitytypecode -> "Email" /
+# "Meeting" on the activity entities, observed 2026-06-20). Memo / String /
+# Uniqueidentifier do not. If a new type starts emitting one, the per-table
+# model's extra="forbid" fails loud at validation — add it here then.
+_SCALAR_TYPES_WITH_FORMATTED_VALUE: frozenset[str] = frozenset(
+    {"Integer", "BigInt", "Double", "Boolean", "EntityName"}
+)
+
+_ANNOTATION_DESCRIPTIONS: dict[str, str] = {
+    "_formatted_value": "Formatted value of {base}",
+    "_lookup_logical_name": "Logical-name of the entity referenced by {base}",
+}
+
+
+@dataclass(frozen=True)
+class RuntimeAnnotationColumn:
+    column_name: str
+    pg_type: str
+    description: str | None
+
+
+@dataclass(frozen=True)
+class RuntimeFieldSpec:
+    """Per-attribute description ready for column emission.
+
+    Captures both Description and DisplayName for the
+    `description ?? display_name` fallback at the dlt edge. Other
+    consumers (LLM tool definitions, sibling metadata exporters) can
+    read the rich object directly without re-deriving from raw metadata.
+    """
+
+    logical_name: str
+    pg_type: str
+    pg_type_args: dict[str, Any]
+    description: str | None
+    display_name: str | None
+    is_custom_attribute: bool
+    attribute_type: str
+    annotation_columns: tuple[RuntimeAnnotationColumn, ...]
+
+
+def field_spec_for_attribute(
+    attribute: AttributeMetadataIngress,
+) -> RuntimeFieldSpec | None:
+    """Build a RuntimeFieldSpec from Dataverse attribute metadata.
+
+    Returns None if the attribute should be skipped per the existing filter
+    rules (IsValidForRead=False, AttributeOf set, type/name in skip sets).
+
+    Raises PluginConfigurationError if AttributeType is unknown — new
+    Microsoft types require explicit triage in this module.
+    """
+    if attribute.is_valid_for_read is False:
+        return None
+    if attribute.attribute_of:
+        return None
+    if attribute.logical_name in SKIPPED_ATTRIBUTE_NAMES:
+        return None
+
+    attr_type = attribute.attribute_type or ""
+
+    # MultiSelectPicklist arrives as Virtual + AttributeTypeName.Value=MultiSelectPicklistType.
+    if attribute.type_name_value == "MultiSelectPicklistType":
+        return _build_multiselect_field(attribute)
+
+    if attr_type in SKIPPED_ATTRIBUTE_TYPES:
+        return None
+
+    if attr_type in LOOKUP_ATTRIBUTE_TYPES:
+        return _build_lookup_field(attribute)
+
+    if attr_type in PICKLIST_ATTRIBUTE_TYPES:
+        return _build_picklist_field(attribute)
+
+    if attr_type == "DateTime":
+        return _build_datetime_field(attribute)
+
+    if attr_type in ("Decimal", "Money"):
+        return _build_numeric_field(attribute)
+
+    pg_type = _SCALAR_TYPE_MAP.get(attr_type)
+    if pg_type is None:
+        raise PluginConfigurationError(
+            f"Unknown Dataverse AttributeType {attr_type!r} for attribute "
+            f"{attribute.logical_name!r}. New Microsoft types require explicit "
+            "triage in shared_plugins.microsoft_dataverse.types."
+        )
+
+    if attr_type in _SCALAR_TYPES_WITH_FORMATTED_VALUE:
+        annotations = _build_annotation_columns(
+            attribute.logical_name,
+            kept_suffixes=("_formatted_value",),
+            context_table=attribute.logical_name,
+        )
+    else:
+        annotations = ()
+
+    return RuntimeFieldSpec(
+        logical_name=attribute.logical_name,
+        pg_type=pg_type,
+        pg_type_args={},
+        description=extract_label(attribute.description),
+        display_name=extract_label(attribute.display_name),
+        is_custom_attribute=attribute.is_custom_attribute,
+        attribute_type=attr_type,
+        annotation_columns=annotations,
+    )
+
+
+_SCALAR_TYPE_MAP: dict[str, str] = {
+    "String": "text",
+    "Memo": "text",
+    "Integer": "bigint",
+    "BigInt": "bigint",
+    "Double": "double",
+    "Boolean": "bool",
+    "Uniqueidentifier": "uuid",
+    "EntityName": "text",
+}
+
+
+def _build_lookup_field(attr: AttributeMetadataIngress) -> RuntimeFieldSpec:
+    base = f"_{attr.logical_name}_value"
+    annotations = _build_annotation_columns(
+        base,
+        kept_suffixes=("_formatted_value", "_lookup_logical_name"),
+        context_table=attr.logical_name,
+    )
+    return RuntimeFieldSpec(
+        logical_name=base,
+        pg_type="uuid",
+        pg_type_args={},
+        description=extract_label(attr.description),
+        display_name=extract_label(attr.display_name),
+        is_custom_attribute=attr.is_custom_attribute,
+        attribute_type=attr.attribute_type or "",
+        annotation_columns=annotations,
+    )
+
+
+def _build_picklist_field(attr: AttributeMetadataIngress) -> RuntimeFieldSpec:
+    annotations = _build_annotation_columns(
+        attr.logical_name,
+        kept_suffixes=("_formatted_value",),
+        context_table=attr.logical_name,
+    )
+    return RuntimeFieldSpec(
+        logical_name=attr.logical_name,
+        pg_type="bigint",
+        pg_type_args={},
+        description=extract_label(attr.description),
+        display_name=extract_label(attr.display_name),
+        is_custom_attribute=attr.is_custom_attribute,
+        attribute_type=attr.attribute_type or "",
+        annotation_columns=annotations,
+    )
+
+
+def _build_multiselect_field(attr: AttributeMetadataIngress) -> RuntimeFieldSpec:
+    annotations = _build_annotation_columns(
+        attr.logical_name,
+        kept_suffixes=("_formatted_value",),
+        context_table=attr.logical_name,
+    )
+    return RuntimeFieldSpec(
+        logical_name=attr.logical_name,
+        pg_type="bigint[]",
+        pg_type_args={},
+        description=extract_label(attr.description),
+        display_name=extract_label(attr.display_name),
+        is_custom_attribute=attr.is_custom_attribute,
+        attribute_type=attr.attribute_type or "MultiSelectPicklist",
+        annotation_columns=annotations,
+    )
+
+
+def _build_datetime_field(attr: AttributeMetadataIngress) -> RuntimeFieldSpec:
+    fmt = attr.format
+    behavior = (attr.date_time_behavior or {}).get("Value")
+    if fmt == "DateOnly":
+        pg_type = "date"
+        pg_args: dict[str, Any] = {}
+    else:
+        pg_type = "timestamp"
+        pg_args = {"timezone": behavior != "TimeZoneIndependent"}
+
+    annotations = _build_annotation_columns(
+        attr.logical_name,
+        kept_suffixes=("_formatted_value",),
+        context_table=attr.logical_name,
+    )
+
+    return RuntimeFieldSpec(
+        logical_name=attr.logical_name,
+        pg_type=pg_type,
+        pg_type_args=pg_args,
+        description=extract_label(attr.description),
+        display_name=extract_label(attr.display_name),
+        is_custom_attribute=attr.is_custom_attribute,
+        attribute_type=attr.attribute_type or "DateTime",
+        annotation_columns=annotations,
+    )
+
+
+def _build_numeric_field(attr: AttributeMetadataIngress) -> RuntimeFieldSpec:
+    if attr.attribute_type == "Money":
+        precision = 28
+        scale = 4
+    else:
+        precision = 28
+        scale = attr.precision if attr.precision is not None else 4
+
+    annotations = _build_annotation_columns(
+        attr.logical_name,
+        kept_suffixes=("_formatted_value",),
+        context_table=attr.logical_name,
+    )
+
+    return RuntimeFieldSpec(
+        logical_name=attr.logical_name,
+        pg_type="numeric",
+        pg_type_args={"precision": precision, "scale": scale},
+        description=extract_label(attr.description),
+        display_name=extract_label(attr.display_name),
+        is_custom_attribute=attr.is_custom_attribute,
+        attribute_type=attr.attribute_type or "",
+        annotation_columns=annotations,
+    )
+
+
+def _build_annotation_columns(
+    base: str,
+    *,
+    kept_suffixes: tuple[str, ...],
+    context_table: str,
+) -> tuple[RuntimeAnnotationColumn, ...]:
+    columns: list[RuntimeAnnotationColumn] = []
+    for suffix in kept_suffixes:
+        # Verify suffix is in the registry; this catches typos.
+        if suffix not in ODATA_ANNOTATION_COLUMN_SUFFIXES.values():
+            raise PluginConfigurationError(
+                f"Annotation suffix {suffix!r} is not registered in "
+                "ODATA_ANNOTATION_COLUMN_SUFFIXES."
+            )
+        column_name = annotation_column_name(
+            base,
+            suffix,
+            context=f"{context_table}.{base}",
+        )
+        description_template = _ANNOTATION_DESCRIPTIONS[suffix]
+        columns.append(
+            RuntimeAnnotationColumn(
+                column_name=column_name,
+                pg_type="text",
+                description=description_template.format(base=base),
+            )
+        )
+    return tuple(columns)
+
+
+# dlt's TDataType literal (text, double, bool, timestamp, bigint, binary, json,
+# decimal, wei, date, time) does not include "uuid", "numeric", or "bigint[]"
+# today. We keep the richer pg_type on RuntimeFieldSpec so non-dlt consumers
+# (LLM tool descriptions, sibling exporters, postgres-native upgrades) retain
+# the fidelity. When dlt adds native uuid / numeric / array support, delete
+# the corresponding entries from this mapping and pass pg_type through
+# unchanged.
+# Tracked: dlt's TDataType definition lives at
+# dlt/common/data_types/typing.py (Literal); follow upstream support there.
+_DLT_DATA_TYPE_OVERRIDES: dict[str, str] = {
+    "uuid": "text",
+    "numeric": "decimal",
+    "bigint[]": "json",
+}
+
+
+def _to_dlt_data_type(pg_type: str) -> str:
+    return _DLT_DATA_TYPE_OVERRIDES.get(pg_type, pg_type)
+
+
+def build_dlt_column_hints(
+    fields: tuple[RuntimeFieldSpec, ...],
+    *,
+    sync_mode_is_delta: bool,
+) -> dict[str, dict[str, Any]]:
+    """Build the dlt `columns={col: {...}}` hint for `@ctx_dlt_resource`.
+
+    Description policy: `description ?? display_name`. If both are absent,
+    `description` is omitted from the hint entirely.
+    """
+    hints: dict[str, dict[str, Any]] = {}
+    for field in fields:
+        entry: dict[str, Any] = {
+            "data_type": _to_dlt_data_type(field.pg_type),
+            **field.pg_type_args,
+        }
+        column_doc = field.description or field.display_name
+        if column_doc:
+            entry["description"] = column_doc
+        hints[field.logical_name] = entry
+
+        for ann in field.annotation_columns:
+            ann_entry: dict[str, Any] = {"data_type": _to_dlt_data_type(ann.pg_type)}
+            if ann.description:
+                ann_entry["description"] = ann.description
+            hints[ann.column_name] = ann_entry
+
+    if sync_mode_is_delta:
+        hints["is_deleted"] = {"hard_delete": True}
+
+    return hints

shared_plugins/microsoft_graph.py

@@ -0,0 +1,250 @@
+"""Shared Microsoft Graph client mechanics for Graph-backed plugins.
+
+SDK-agnostic on purpose: the version-specific pieces — the SDK's
+`GraphRequestAdapter` class, the default middleware `options` from its
+`graph_request_adapter` module, and the matching `APIVersion` — are passed in
+by each plugin, so a plugin pulls in only the Graph SDK it actually uses
+(`msgraph` for v1.0, `msgraph_beta` for beta) and shared_plugins depends only
+on the common `msgraph-core`/kiota runtime.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass, make_dataclass
+from typing import Any, TypeVar
+from urllib.parse import parse_qs, quote, urlparse
+
+import httpx
+from azure.core.credentials import AccessToken
+from azure.core.credentials_async import AsyncTokenCredential
+from azure.identity.aio import ClientSecretCredential
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.headers_collection import HeadersCollection
+from kiota_abstractions.serialization import Parsable
+from kiota_authentication_azure.azure_identity_authentication_provider import (
+    AzureIdentityAuthenticationProvider,
+)
+from kiota_serialization_json.json_serialization_writer import JsonSerializationWriter
+from msgraph_core import APIVersion, BaseGraphRequestAdapter, GraphClientFactory
+
+from base_client import (
+    BindingAuth_AuthenticatedAccount,
+    BindingAuth_ClientCredentials,
+    DagsterAllPlanBinding,
+)
+
+from .provider_token import DelegatedTokenProvider, ProviderTokenClient
+
+_GRAPH_SCOPES = ["https://graph.microsoft.com/.default"]
+
+_RequestAdapterT = TypeVar("_RequestAdapterT", bound=BaseGraphRequestAdapter)
+
+
+def build_h11_request_adapter(
+    credential: AsyncTokenCredential,
+    *,
+    api_version: APIVersion,
+    adapter_cls: type[_RequestAdapterT],
+    adapter_options: dict[str, Any],
+) -> _RequestAdapterT:
+    """Build a Graph request adapter whose underlying httpx transport is
+    HTTP/1.1 only.
+
+    `api_version`, `adapter_cls`, and `adapter_options` come as a set from
+    the calling plugin's msgraph SDK: the `GraphRequestAdapter` class and the
+    default middleware `options` dict from its `graph_request_adapter`
+    module, plus the `APIVersion` it serves.
+
+    Force HTTP/1.1 (kiota's default is `http2=True`). Microsoft Graph's
+    frontdoor terminates HTTP/2 connections at ~30s with an advisory
+    GOAWAY (`error_code=NO_ERROR`, `last_stream_id=2^31-1`; RFC 7540
+    §6.8 graceful shutdown). httpcore turns that into a fatal
+    `RemoteProtocolError` for the in-flight stream
+    (`httpcore/_async/http2.py:350-355` — `stream_id > last_stream_id`
+    is unreachable when `last_stream_id` is `HIGHEST_ALLOWED_STREAM_ID`),
+    and kiota_http's `RetryHandler` doesn't catch transport exceptions
+    (it retries on status codes 429/503/504 only). HTTP/1.1 keep-alive
+    has no equivalent server-driven termination — empirically, a single
+    TCP connection comfortably serves 600+ requests over ~40s with the
+    same per-request latency as HTTP/2. Full empirical breakdown at
+    `internal/in-progress/2026-05-14-codecreators-komal-first-sync.md`
+    (B4 entry).
+    """
+    raw = httpx.AsyncClient(
+        http2=False,
+        base_url=f"https://graph.microsoft.com/{api_version.value}",
+    )
+    wrapped = GraphClientFactory.create_with_default_middleware(
+        api_version=api_version,
+        client=raw,
+        options=adapter_options,
+    )
+    auth_provider = AzureIdentityAuthenticationProvider(
+        credential, scopes=_GRAPH_SCOPES
+    )
+    return adapter_cls(auth_provider, client=wrapped)
+
+
+class DelegatedTokenCredential:
+    """Adapts a DelegatedTokenProvider to azure's AsyncTokenCredential so a Graph
+    SDK's AzureIdentityAuthenticationProvider can stamp a delegated
+    (authenticated_account) bearer. The delegated token's scopes are fixed by the
+    grant, so the requested Graph scopes are ignored.
+    """
+
+    def __init__(self, provider: DelegatedTokenProvider) -> None:
+        self._provider = provider
+
+    async def get_token(self, *scopes: str, **kwargs: object) -> AccessToken:
+        # current_lease() redeems synchronously on first use and may do so again
+        # during refresh; loop isolation is the calling client's concern.
+        lease = self._provider.current_lease()
+        if lease.access_token_expires_at is None:
+            raise ValueError(
+                "delegated microsoft lease declares no expiry; cannot build an "
+                "AccessToken.expires_on."
+            )
+        return AccessToken(
+            lease.access_token, int(lease.access_token_expires_at.timestamp())
+        )
+
+    async def close(self) -> None:
+        # The ProviderTokenClient is a Dagster resource; its lifecycle isn't ours.
+        return None
+
+
+def build_credential_factory(
+    binding: DagsterAllPlanBinding,
+    *,
+    tenant_id: str,
+    provider_token: ProviderTokenClient,
+) -> Callable[[], AsyncTokenCredential]:
+    """One credential factory per Graph binding's auth: `client_credentials`
+    builds an app credential from the binding's secrets; `authenticated_account`
+    wraps a DelegatedTokenProvider in a DelegatedTokenCredential. Graph reads
+    address `/users/{id}` identically whichever credential produced the bearer,
+    so `binding.auth` branches ONLY the credential the client opens with. A
+    factory (not an instance) because Graph sync clients build it inside their own
+    event loop — aio credentials are loop-bound.
+    """
+    auth = binding.auth
+    if isinstance(auth, BindingAuth_ClientCredentials):
+        return lambda: ClientSecretCredential(
+            tenant_id=tenant_id,
+            client_id=auth.client_id,
+            client_secret=auth.client_secret,
+        )
+    if isinstance(auth, BindingAuth_AuthenticatedAccount):
+        provider = DelegatedTokenProvider(
+            auth=auth, provider_token_client=provider_token
+        )
+        return lambda: DelegatedTokenCredential(provider)
+    raise RuntimeError(
+        f"{binding.plugin_id} binding requires auth.type 'client_credentials' or "
+        f"'authenticated_account', got '{auth.type}'."
+    )
+
+
+def _query_parameters_from_mapping(
+    query_params: Mapping[str, object | None] | None,
+) -> object | None:
+    values = [
+        (f"param_{index}", name, value)
+        for index, (name, value) in enumerate((query_params or {}).items())
+        if value is not None
+    ]
+    if not values:
+        return None
+
+    encoded_name_by_field = {
+        field_name: quote(name, safe="") for field_name, name, _value in values
+    }
+
+    def get_query_parameter(_self: object, original_name: str) -> str:
+        return encoded_name_by_field.get(original_name, original_name)
+
+    query_type = make_dataclass(
+        "_GraphQueryParameters",
+        [(field_name, object) for field_name, _name, _value in values],
+        namespace={"get_query_parameter": get_query_parameter},
+        frozen=True,
+    )
+    return query_type(
+        **{field_name: value for field_name, _name, value in values},
+    )
+
+
+def request_configuration(
+    *,
+    query_params: Mapping[str, object | None] | None = None,
+    prefer_header: str | None = None,
+) -> RequestConfiguration[Any]:
+    cfg: RequestConfiguration[Any] = RequestConfiguration()
+    cfg.headers = HeadersCollection()
+    cfg.query_parameters = _query_parameters_from_mapping(query_params)
+    if prefer_header:
+        cfg.headers.add("Prefer", prefer_header)
+    return cfg
+
+
+@dataclass(frozen=True)
+class DeltaPage:
+    rows: list[Any]
+    cursor_url: str
+
+
+def is_delta_cursor_url(cursor_url: str) -> bool:
+    query = parse_qs(urlparse(cursor_url).query)
+    return "$deltatoken" in query or "deltatoken" in query
+
+
+def drain_delta_pages(
+    *,
+    initial_cursor_url: str | None,
+    fetch_page: Callable[[str | None], Any],
+    rows_from_page: Callable[[Any], list[Any]],
+) -> Iterator[DeltaPage]:
+    cursor_url = initial_cursor_url
+
+    while True:
+        response = fetch_page(cursor_url)
+        rows = rows_from_page(response)
+
+        delta_link = getattr(response, "odata_delta_link", None)
+        if delta_link:
+            yield DeltaPage(rows=rows, cursor_url=delta_link)
+            return
+
+        next_link = getattr(response, "odata_next_link", None)
+        if not next_link:
+            raise RuntimeError(
+                "Graph delta response did not include @odata.nextLink or "
+                "@odata.deltaLink"
+            )
+
+        yield DeltaPage(rows=rows, cursor_url=next_link)
+        cursor_url = next_link
+
+
+def graph_object_to_payload(obj: object) -> dict[str, Any]:
+    if isinstance(obj, Mapping):
+        return dict(obj)
+    if not isinstance(obj, Parsable):
+        raise TypeError(
+            "Expected a Microsoft Graph Kiota Parsable object or mapping; "
+            f"got {type(obj).__name__}."
+        )
+
+    writer = JsonSerializationWriter()
+    writer.write_object_value(None, obj)
+    payload = writer.value if writer.value is not None else writer.writer
+    if not isinstance(payload, dict):
+        raise RuntimeError(
+            "Microsoft Graph Kiota serializer returned a non-object payload."
+        )
+    raw = dict(payload)
+    additional_data = getattr(obj, "additional_data", None)
+    if isinstance(additional_data, dict):
+        raw["additional_data"] = dict(additional_data)
+    return raw

shared_plugins/models.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Annotated, Any, Optional, TypeVar, cast
+
+from pydantic import (
+    AwareDatetime,
+    BaseModel,
+    ConfigDict,
+    Field,
+    StringConstraints,
+    ValidationError,
+    create_model,
+)
+
+IdStr = Annotated[str, StringConstraints(min_length=1, strict=True)]
+NonNegativeInt = Annotated[int, Field(ge=0, strict=True)]
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+def format_validation_error(error: ValidationError) -> str:
+    parts: list[str] = []
+    for issue in error.errors():
+        location = ".".join(str(part) for part in issue["loc"]) or "root"
+        parts.append(f"{location}: {issue['msg']}")
+    return "; ".join(parts)
+
+
+class StrictModel(BaseModel):
+    """Shared strict model base: unknown fields are always rejected."""
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+
+class IngressModel(StrictModel):
+    """Shared plugin ingress contract base."""
+
+
+class CtxModel(StrictModel):
+    """Shared plugin row metadata contract."""
+
+    ctx_binding_id: str = Field(min_length=1, alias="_ctx_binding_id")
+    ctx_source_updated_at: AwareDatetime | None = Field(
+        default=None,
+        alias="_ctx_source_updated_at",
+    )
+
+
+def partialize(model_cls: type[ModelT], *, name: str | None = None) -> type[ModelT]:
+    """Return a cached partial model class with all inherited fields optional."""
+
+    partial_name = name or f"{model_cls.__name__}Partial"
+    return cast(type[ModelT], _partialize_cached(model_cls, partial_name))
+
+
+def _to_optional_annotation(annotation: Any) -> Any:
+    try:
+        return annotation | None
+    except TypeError:
+        return Optional[annotation]  # type: ignore[valid-type]
+
+
+@lru_cache(maxsize=None)
+def _partialize_cached(
+    model_cls: type[BaseModel], partial_name: str
+) -> type[BaseModel]:
+    partial_fields: dict[str, tuple[Any, Any]] = {}
+
+    for field_name, field_info in model_cls.model_fields.items():
+        field_dict = field_info.asdict()
+        field_attributes = dict(field_dict["attributes"])
+        field_attributes.pop("default", None)
+        field_attributes.pop("default_factory", None)
+
+        optional_annotation = _to_optional_annotation(field_dict["annotation"])
+        annotated_field = Annotated[
+            (
+                optional_annotation,
+                *field_dict["metadata"],
+                Field(**field_attributes),
+            )
+        ]
+        partial_fields[field_name] = (annotated_field, None)
+
+    return create_model(
+        partial_name,
+        __base__=model_cls,
+        __module__=model_cls.__module__,
+        **partial_fields,
+    )