sg-python-api 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

shotgun_api3/_driver.py

@@ -12,7 +12,6 @@ from typing import Literal, Protocol, TypeVar, cast, runtime_checkable
 
 from . import _protocol, _transport
 from ._config import (
-    CompatibilityWarningCode,
     EventRoute,
     ObserverCallback,
     Outcome,
@@ -181,14 +180,11 @@ class ExecutionOptions:
     """Control executor behavior that is not part of retry classification.
 
     Attributes:
-        compatibility_warning_codes: Compatibility warnings emitted before
-            attempts.
         logical_method_name: Optional observer-facing operation name.
         redirect_factory: Optional request factory for redirect responses.
         streaming: Whether the response body is consumed as a stream.
     """
 
-    compatibility_warning_codes: tuple[CompatibilityWarningCode, ...] = ()
     logical_method_name: str | None = None
     redirect_factory: 'Callable[[LiveResponse], TransportRequest] | None' = None
     streaming: bool = False
@@ -443,13 +439,9 @@ class Driver:
             raise AssertionError('response consumption ended without an outcome')
         return attempt_result
 
-    def _emit_warnings(
-        self,
-        context: RequestContext,
-        warning_codes: tuple[CompatibilityWarningCode, ...],
-    ) -> None:
+    def _emit_warnings(self, context: RequestContext) -> None:
         """Publish fixed-message compatibility warnings."""
-        for event in compatibility_warning_events(warning_codes, context.timeout):
+        for event in compatibility_warning_events(context.timeout):
             notify_observer(context.on_compatibility_warning, event)
 
     def _execute_rpc(
@@ -623,7 +615,6 @@ class Driver:
         params: object,
         context: RequestContext,
         include_auth: bool = True,
-        compatibility_warning_codes: tuple[CompatibilityWarningCode, ...] = (),
         *,
         _logical_method_name: str | None = None,
     ) -> object:
@@ -635,8 +626,6 @@ class Driver:
             context: Immutable operation configuration.
             include_auth: Whether to include the captured authentication
                 payload.
-            compatibility_warning_codes: Sanitized compatibility notices
-                attached by the client surface.
             _logical_method_name: Optional logical operation name when it
                 differs from the wire method.
 
@@ -648,10 +637,7 @@ class Driver:
                 response contract (`reason` and `content`).
         """
         normalized_params = copy.deepcopy(params)
-        options = ExecutionOptions(
-            compatibility_warning_codes=compatibility_warning_codes,
-            logical_method_name=_logical_method_name,
-        )
+        options = ExecutionOptions(logical_method_name=_logical_method_name)
         return self._execute_rpc(
             method_name,
             normalized_params,
@@ -745,7 +731,7 @@ class Driver:
             Exception: If status validation or response consumption fails.
         """
         execution_options = options or ExecutionOptions()
-        self._emit_warnings(context, execution_options.compatibility_warning_codes)
+        self._emit_warnings(context)
         route = event_route(operation)
         for attempt in range(1, context.max_rpc_attempts + 1):
             state = self._attempt_state(operation, context, route, attempt)

shotgun_api3/_files.py

@@ -10,7 +10,7 @@ import urllib.parse
 import urllib.request
 import uuid
 from collections.abc import Callable, Generator, Iterator, Mapping, Sequence
-from contextlib import ExitStack, contextmanager
+from contextlib import contextmanager
 from pathlib import Path
 from typing import BinaryIO, Literal, TypeAlias, TypedDict, cast
 
@@ -34,7 +34,7 @@ _FILE_SERVE_ATTACHMENT = '/file_serve/attachment/'
 _MULTIPART_CHUNK_SIZE = 20_000_000
 _Origin: TypeAlias = tuple[str, str, int]
 _PART_LINK_FIELD_COUNT = 2
-_UPLOAD_FILE = '/upload/upload_file'
+_THUMBNAIL_UPLOAD_FIELDS = ('image', 'filmstrip_image')
 
 
 @dataclasses.dataclass(frozen=True)
@@ -245,17 +245,6 @@ class _ExactOriginCookiePolicy(http.cookiejar.DefaultCookiePolicy):
         )
 
 
-def _build_form_upload_fields(prepared: PreparedUpload) -> dict[str, str]:
-    """Build the non-authenticated legacy form-upload fields."""
-    arguments = prepared.options.arguments
-    return {
-        'entity_type': arguments.entity_type,
-        'entity_id': str(arguments.entity_id),
-        'field_name': arguments.field_name or '',
-        'display_name': arguments.display_name or prepared.filename,
-    }
-
-
 def _entity_reference(entity: Mapping[str, object]) -> str:
     """Serialize one entity as the upload endpoint reference grammar."""
     entity_type = entity.get('type')
@@ -294,48 +283,6 @@ def _iter_file(
                 remaining -= len(chunk)
 
 
-def _multipart_content_length(
-    plan: _protocol.MultipartPlan,
-    file_sizes: Mapping[str, int],
-) -> int:
-    """Return the exact byte length of a multipart plan."""
-    return sum(
-        file_sizes[segment.name] if isinstance(segment, _protocol.FileSlot) else len(segment)
-        for segment in plan.segments
-    )
-
-
-def _pump_multipart(
-    plan: _protocol.MultipartPlan,
-    opened: Mapping[str, BinaryIO],
-    chunk_size: int = 65536,
-) -> Generator[bytes, None, None]:
-    """Yield multipart framing while reading file slots incrementally."""
-    if chunk_size <= 0:
-        raise ValueError('multipart chunk size must be positive')
-    for segment in plan.segments:
-        if isinstance(segment, _protocol.FileSlot):
-            handle = opened[segment.name]
-            while chunk := handle.read(chunk_size):
-                yield chunk
-        else:
-            yield segment
-
-
-def _pump_multipart_from_disk(
-    plan: _protocol.MultipartPlan,
-    paths: Mapping[str, str],
-    chunk_size: int = 65536,
-) -> Generator[bytes, None, None]:
-    """Pump multipart framing through lazily opened disk files."""
-    with ExitStack() as stack:
-        opened: dict[str, BinaryIO] = {}
-        for segment in plan.segments:
-            if isinstance(segment, _protocol.FileSlot) and segment.name not in opened:
-                opened[segment.name] = stack.enter_context(Path(paths[segment.name]).open('rb'))
-        yield from _pump_multipart(plan, opened, chunk_size)
-
-
 def _requires_direct_upload(
     server_info: Mapping[str, object],
     entity_type: str,
@@ -693,53 +640,6 @@ def build_download_redirect(
     return build_download_request(context, location, {'user-agent': context.user_agent})
 
 
-def build_form_upload_exchange(
-    canonical_origin: str,
-    user_agent: str,
-    prepared: PreparedUpload,
-    auth: Mapping[str, object],
-    chunk_size: int = 65536,
-) -> UploadExchange:
-    """Plan one restartable legacy multipart form upload.
-
-    The body can be rebuilt, but the operation is not replay-safe after
-    transmission.
-
-    Args:
-        canonical_origin: Captured site origin.
-        user_agent: Captured user-agent header value.
-        prepared: Validated upload metadata and arguments.
-        auth: Captured authentication form fields.
-        chunk_size: Maximum file bytes read per iteration.
-
-    Returns:
-        Complete restartable form-upload exchange.
-    """
-    fields = add_auth_fields(_build_form_upload_fields(prepared), auth)
-    slot = _protocol.FileSlot(
-        name='file',
-        filename=prepared.filename,
-        content_type='application/octet-stream',
-    )
-    plan = _protocol.build_multipart_plan(fields, [slot])
-    path = prepared.options.arguments.path
-    return UploadExchange(
-        body_factory=lambda: _pump_multipart_from_disk(
-            plan,
-            {'file': path},
-            chunk_size,
-        ),
-        headers={
-            'content-length': str(_multipart_content_length(plan, {'file': prepared.file_size})),
-            'content-type': plan.content_type,
-            'user-agent': user_agent,
-        },
-        method='POST',
-        operation=SHARE_THUMBNAIL_OPERATION,
-        url=f'{canonical_origin}{_UPLOAD_FILE}',
-    )
-
-
 def build_upload_endpoint_exchange(
     canonical_origin: str | None,
     user_agent: str,
@@ -992,8 +892,8 @@ def prepare_upload(options: UploadOptions) -> PreparedUpload:
         Captured filename, size, and options for one upload.
 
     Raises:
-        ShotgunError: If the path does not name a nonempty file or `created_at`
-            is not a datetime.
+        ShotgunError: If the path does not name a file, the file is empty, or
+            `created_at` is not a datetime.
     """
     created_at = cast('object', options.arguments.created_at)
     if created_at is not None and not isinstance(created_at, datetime.datetime):
@@ -1006,14 +906,38 @@ def prepare_upload(options: UploadOptions) -> PreparedUpload:
         )
     path = Path(options.arguments.path)
     try:
-        file_size = path.stat().st_size if path.is_file() else 0
+        is_file = path.is_file()
+        file_size = path.stat().st_size if is_file else 0
     except OSError:
-        file_size = 0
+        is_file, file_size = False, 0
+    if not is_file:
+        raise ShotgunError(f"Path must be a valid file, got '{options.arguments.path}'")
     if file_size <= 0:
-        raise ShotgunError('File must exist and be non-empty')
+        raise ShotgunError(f"Path cannot be an empty file: '{options.arguments.path}'")
     return PreparedUpload(filename=path.name, file_size=file_size, options=options)
 
 
+def require_supported_upload_path(
+    upload_path: Literal['form', 'direct', 'multipart'],
+) -> Literal['direct', 'multipart']:
+    """Reject the unsupported legacy form route before upload I/O.
+
+    Args:
+        upload_path: Route selected from server capabilities.
+
+    Returns:
+        The selected supported route.
+
+    Raises:
+        ShotgunError: If the server requires legacy form uploads.
+    """
+    if upload_path == 'form':
+        raise ShotgunError(
+            'server requires legacy form uploads, which this client does not support'
+        )
+    return upload_path
+
+
 def resolve_attachment_url(attachment: object, base_url: str) -> str | None:
     """Resolve a supported attachment reference to its download URL.
 
@@ -1049,6 +973,41 @@ def resolve_attachment_url(attachment: object, base_url: str) -> str | None:
     raise ShotgunError('attachment must be an id or dictionary')
 
 
+def split_thumbnail_uploads(
+    data: object,
+    *,
+    keep_image_none: bool,
+) -> tuple[object, dict[str, object]]:
+    """Separate `image` and `filmstrip_image` paths from entity field data.
+
+    Autodesk's client uploads these paths after the entity write instead of
+    sending them as field values.
+
+    Args:
+        data: Public field mapping. A non-dictionary is returned unchanged so
+            that the caller's own validation reports it.
+        keep_image_none: Whether an `image` value of `None` stays in the field
+            data, which lets an update clear both thumbnails.
+
+    Returns:
+        A copy of the field data without the separated fields, and the
+        non-empty paths to upload, with `image` before `filmstrip_image`.
+    """
+    if not isinstance(data, dict):
+        return data, {}
+    mapping = cast('dict[object, object]', data)
+    fields: dict[object, object] = {}
+    paths: dict[str, object] = {}
+    for name, value in mapping.items():
+        if name not in _THUMBNAIL_UPLOAD_FIELDS or (
+            keep_image_none and name == 'image' and value is None
+        ):
+            fields[name] = value
+        elif value:
+            paths[cast('str', name)] = value
+    return fields, {name: paths[name] for name in _THUMBNAIL_UPLOAD_FIELDS if name in paths}
+
+
 def thumbnail_source_ready(
     result: object,
     field_name: Literal['filmstrip_image', 'image'],

shotgun_api3/_methods.py

@@ -1,16 +1,12 @@
 """Shared pure plans for synchronous and asynchronous client methods."""
 
-import contextvars
 import dataclasses
 import datetime
 import inspect
-import warnings
-from collections.abc import Callable, Generator
-from contextlib import contextmanager
+from collections.abc import Callable, Mapping
 from typing import Any, NotRequired, TypedDict, cast
 
 from . import _crud, _protocol
-from ._config import CompatibilityWarningCode
 from ._errors import ShotgunError
 from ._signatures import bind_arguments, expose_signature
 
@@ -68,6 +64,9 @@ _ACTIVITY_STREAM_READ_SIGNATURE = inspect.Signature(
 )
 _EXPORT_PAGE_DOCSTRING = """Export a page using the documented arguments.
 
+The Page or its layout must be marked API Exportable in the web UI,
+or the server rejects the export.
+
 Args:
     page_id: Numeric page identifier.
     format: Required nonempty export format name.
@@ -111,10 +110,6 @@ _METHOD_EXPORT_PAGE_SIGNATURE = inspect.Signature(
     ),
     return_annotation=str,
 )
-_PENDING_COMPATIBILITY_WARNINGS = tuple[
-    object,
-    tuple[CompatibilityWarningCode, ...],
-]
 _SCHEDULE_DATE_LENGTH = 10
 _SUMMARIZE_DOCSTRING = """Summarize field data returned by a query.
 
@@ -241,12 +236,6 @@ _WORK_SCHEDULE_UPDATE_SIGNATURE = inspect.Signature(
     _WORK_SCHEDULE_UPDATE_PARAMETERS,
     return_annotation=dict[str, object],
 )
-SCHEMA_ENTITY_READ_WARNINGS: contextvars.ContextVar[_PENDING_COMPATIBILITY_WARNINGS | None] = (
-    contextvars.ContextVar('SCHEMA_ENTITY_READ_WARNINGS', default=None)
-)
-SCHEMA_FIELD_READ_WARNINGS: contextvars.ContextVar[_PENDING_COMPATIBILITY_WARNINGS | None] = (
-    contextvars.ContextVar('SCHEMA_FIELD_READ_WARNINGS', default=None)
-)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -342,6 +331,18 @@ def _entity(value: object) -> object:
     return _protocol.optimize_entity(value)
 
 
+def _is_subscription_value(value: object) -> bool:
+    """Check the supported subscription value forms."""
+    return (
+        value is None
+        or isinstance(value, str)
+        or (
+            isinstance(value, list)
+            and all(isinstance(item, str) for item in cast('list[object]', value))
+        )
+    )
+
+
 def _project_entity(value: object) -> object:
     """Optimize an optional project entity."""
     return None if value is None else _entity(value)
@@ -934,11 +935,38 @@ def build_user_subscriptions_create_params(users: object) -> dict[str, object]:
         users,
         'user_subscriptions_create users must be a list',
     )
-    message = 'user_subscriptions_create users must contain dictionaries with a user_id key'
+    entry_message = (
+        'user_subscriptions_create users must contain dictionaries with '
+        'humanUserId and subscription keys'
+    )
+    params: dict[str, object] = {}
     for member in validated:
-        if not isinstance(member, dict) or 'user_id' not in member:
-            raise ShotgunError(message)
-    return {'users': cast('list[dict[str, object]]', validated)}
+        if not isinstance(member, dict):
+            raise ShotgunError(entry_message)
+        entry = cast('dict[str, object]', member)
+        if 'humanUserId' not in entry or 'subscription' not in entry:
+            raise ShotgunError(entry_message)
+        user_id = entry['humanUserId']
+        if isinstance(user_id, bool) or not isinstance(user_id, (str, int)):
+            raise ShotgunError(
+                'user_subscriptions_create users must contain string or integer humanUserId values'
+            )
+        if not _is_subscription_value(entry['subscription']):
+            raise ShotgunError(
+                'user_subscriptions_create users must contain valid subscription values'
+            )
+        key = str(user_id)
+        if key in params:
+            raise ShotgunError(
+                'user_subscriptions_create users must not contain duplicate user IDs'
+            )
+        subscription = entry['subscription']
+        params[key] = (
+            cast('list[str]', subscription).copy()
+            if isinstance(subscription, list)
+            else subscription
+        )
+    return params
 
 
 def build_work_schedule_read_params(
@@ -1007,43 +1035,13 @@ def build_work_schedule_update_params(
     return params
 
 
-def consume_compatibility_warnings(
-    warning_context: contextvars.ContextVar[_PENDING_COMPATIBILITY_WARNINGS | None],
-    owner: object,
-) -> tuple[CompatibilityWarningCode, ...]:
-    """Consume operation-local compatibility warnings exactly once.
-
-    Args:
-        warning_context: Context-local warning state.
-        owner: Client instance expected to own the warning.
+def entity_types_alias_error() -> ShotgunError:
+    """Build the error raised by the deprecated `entity_types` alias.
 
     Returns:
-        Compatibility warning codes for the target call.
-    """
-    pending = warning_context.get()
-    if pending is None or pending[0] is not owner:
-        return ()
-    warning_context.set(None)
-    return pending[1]
-
-
-@contextmanager
-def entity_types_alias(owner: object) -> Generator[None, None, None]:
-    """Scope the deprecated `entity_types` compatibility notice.
-
-    Args:
-        owner: Client instance invoking the alias.
-
-    Yields:
-        Control while the public target method consumes the warning.
+        A `ShotgunError` naming `schema_entity_read()` as the replacement.
     """
-    token = SCHEMA_ENTITY_READ_WARNINGS.set(
-        (owner, ('deprecated-entity-types-alias',)),
-    )
-    try:
-        yield
-    finally:
-        SCHEMA_ENTITY_READ_WARNINGS.reset(token)
+    return ShotgunError('Deprecated: use schema_entity_read() instead')
 
 
 def expose_activity_stream_read_signature(
@@ -1168,38 +1166,64 @@ def require_string_result(value: object, method_name: str) -> str:
     return value
 
 
-@contextmanager
-def schema_alias(owner: object) -> Generator[None, None, None]:
-    """Scope the deprecated `schema` compatibility notice.
+def require_user_subscriptions_create_result(value: object) -> bool:
+    """Interpret a mapping of per-user subscription assignment reports.
 
     Args:
-        owner: Client instance invoking the alias.
+        value: Raw result returned by the server.
+
+    Returns:
+        `True` if every report is `None`, otherwise `False`.
 
-    Yields:
-        Control while the public target method consumes the warning.
+    Raises:
+        ShotgunError: If the result is not a mapping with string keys.
     """
-    token = SCHEMA_FIELD_READ_WARNINGS.set(
-        (owner, ('deprecated-schema-alias',)),
-    )
-    try:
-        yield
-    finally:
-        SCHEMA_FIELD_READ_WARNINGS.reset(token)
+    message = 'user_subscriptions_create returned an invalid result mapping'
+    if not isinstance(value, Mapping):
+        raise ShotgunError(message)
+    reports = cast('Mapping[object, object]', value)
+    if any(not isinstance(key, str) for key in reports):
+        raise ShotgunError(message)
+    return all(report is None for report in reports.values())
 
 
-def warn_entity_types_alias() -> None:
-    """Warn at the caller of the deprecated `entity_types` method."""
-    warnings.warn(
-        'entity_types() is deprecated; use schema_entity_read()',
-        DeprecationWarning,
-        stacklevel=3,
-    )
+def require_user_subscriptions_result(value: object) -> list[dict[str, object]]:
+    """Convert a subscription mapping to ordered public entries.
+
+    Args:
+        value: Raw subscription mapping returned by the server.
 
+    Returns:
+        Entries with unchanged string `humanUserId` and `subscription` values
+        of `None`, string, or list of strings. Lists are copied.
 
-def warn_schema_alias() -> None:
-    """Warn at the caller of the deprecated `schema` method."""
-    warnings.warn(
-        'schema() is deprecated; use schema_field_read()',
-        DeprecationWarning,
-        stacklevel=3,
-    )
+    Raises:
+        ShotgunError: If the result is not a valid subscription mapping.
+    """
+    if not isinstance(value, Mapping):
+        raise ShotgunError('user_subscriptions_read did not return a dictionary')
+    subscriptions: list[dict[str, object]] = []
+    for user_id, subscription in cast('Mapping[object, object]', value).items():
+        if not isinstance(user_id, str) or not user_id:
+            raise ShotgunError('user_subscriptions_read returned an invalid user ID')
+        if not _is_subscription_value(subscription):
+            raise ShotgunError('user_subscriptions_read returned an invalid subscription')
+        public_subscription = (
+            cast('list[str]', subscription).copy()
+            if isinstance(subscription, list)
+            else subscription
+        )
+        subscriptions.append({'humanUserId': user_id, 'subscription': public_subscription})
+    return subscriptions
+
+
+def schema_alias_error(entity_type: object) -> ShotgunError:
+    """Build the error raised by the deprecated `schema` alias.
+
+    Args:
+        entity_type: Caller-supplied entity type, rendered with `str()`.
+
+    Returns:
+        A `ShotgunError` naming the equivalent `schema_field_read()` call.
+    """
+    return ShotgunError(f"Deprecated: use schema_field_read('{entity_type}') instead")

shotgun_api3/_protocol.py

@@ -7,7 +7,6 @@ import json
 import math
 import re
 import sys
-import uuid as _uuid
 from collections.abc import Callable, Mapping, Sequence
 from datetime import UTC
 from email.utils import parsedate_to_datetime
@@ -107,7 +106,6 @@ _IMF_FIXDATE_PATTERN = re.compile(
 _JITTER_BYTES = 8
 _JITTER_RANGE = 1 << (_JITTER_BYTES * 8)
 _MIN_CONDITION_PARTS = 2
-_MULTIPART_BOUNDARY_PATTERN = re.compile(r"[A-Za-z0-9'+._-]{1,70}")
 _OPTIMIZABLE_RELATIONS = frozenset({'is', 'is_not', 'in', 'not_in'})
 _RETRYABLE_STATUSES = frozenset({502, 503, 504})
 _RETRY_AFTER_TOO_LARGE: Final = 'too-large'
@@ -209,34 +207,6 @@ class Failure:
     retry_after: _RetryAfter
 
 
-@dataclasses.dataclass(frozen=True)
-class FileSlot:
-    """Placeholder for file bytes inside a multipart plan.
-
-    Attributes:
-        name: Multipart form field name.
-        filename: Filename exposed in the multipart part.
-        content_type: Media type exposed in the multipart part.
-    """
-
-    name: str
-    filename: str
-    content_type: str
-
-
-@dataclasses.dataclass(frozen=True)
-class MultipartPlan:
-    """Byte segments and file slots forming a multipart/form-data body.
-
-    Attributes:
-        content_type: Multipart content type including its boundary.
-        segments: Ordered encoded segments and file placeholders.
-    """
-
-    content_type: str
-    segments: list[bytes | FileSlot]
-
-
 @dataclasses.dataclass(frozen=True)
 class OperationDescriptor:
     """Describe the replay properties of one logical operation.
@@ -365,11 +335,6 @@ def _entity_optimization_disabled() -> bool:
     return cast('bool', module.SHOTGUN_API_DISABLE_ENTITY_OPTIMIZATION)
 
 
-def _escape_disposition(value: str) -> str:
-    """Make a value safe inside a Content-Disposition quoted-string."""
-    return value.replace('\\', '\\\\').replace('"', '%22').replace('\r', '').replace('\n', '')
-
-
 def _explicit_delay_is_safe(delay: float) -> bool:
     """Return whether a delay stays within the bounded retry policy."""
     return math.isfinite(delay) and 0 <= delay <= _BACKOFF_CAP
@@ -491,13 +456,6 @@ def _parse_retry_after(headers: Mapping[str, str], now: float) -> _RetryAfter:
     return delay
 
 
-def _validate_multipart_boundary(boundary: str) -> str:
-    """Return a boundary safe for multipart framing and an unquoted header."""
-    if not _MULTIPART_BOUNDARY_PATTERN.fullmatch(boundary):
-        raise ValueError('multipart boundary must be 1 to 70 safe ASCII characters')
-    return boundary
-
-
 def _validated_nonnegative_integer(value: object, name: str) -> int:
     """Return a non-boolean, nonnegative integer paging value."""
     if not isinstance(value, int) or isinstance(value, bool) or value < 0:
@@ -615,57 +573,6 @@ def classify_endpoint(
     )
 
 
-def build_multipart_plan(
-    fields: dict[str, str],
-    files: list[FileSlot],
-    boundary: str | None = None,
-) -> MultipartPlan:
-    """Build a pure multipart/form-data framing plan.
-
-    Args:
-        fields: Text form fields in multipart emission order.
-        files: File placeholders in multipart emission order.
-        boundary: Explicit boundary of 1-70 ASCII letters, digits, apostrophes,
-            plus signs, periods, underscores, or hyphens; `None` generates one.
-
-    Returns:
-        A content type and ordered framing segments for the multipart body.
-
-    Raises:
-        ValueError: If an explicit boundary is empty or unsafe for unquoted
-            use.
-    """
-    multipart_boundary = (
-        _uuid.uuid4().hex if boundary is None else _validate_multipart_boundary(boundary)
-    )
-    segments: list[bytes | FileSlot] = []
-    for name, value in fields.items():
-        segments.append(
-            (
-                f'--{multipart_boundary}\r\nContent-Disposition: form-data; '
-                f'name="{_escape_disposition(name)}"'
-                f'\r\n\r\n{value}\r\n'
-            ).encode()
-        )
-    for slot in files:
-        segments.append(
-            (
-                f'--{multipart_boundary}\r\nContent-Disposition: form-data; '
-                f'name="{_escape_disposition(slot.name)}"; '
-                f'filename="{_escape_disposition(slot.filename)}"'
-                f'\r\nContent-Type: {slot.content_type}'
-                '\r\n\r\n'
-            ).encode()
-        )
-        segments.append(slot)
-        segments.append(b'\r\n')
-    segments.append(f'--{multipart_boundary}--\r\n'.encode())
-    return MultipartPlan(
-        content_type=f'multipart/form-data; boundary={multipart_boundary}',
-        segments=segments,
-    )
-
-
 def classify(
     method_name: str,
     normalized_params: object,