semiont 0.6.12.dev2__py3-none-any.whl

semiont/http/transport.py

@@ -0,0 +1,326 @@
+"""A knowledge base's bus over its gateway's HTTP transport (`docs/protocol/TRANSPORT-HTTP.md`), as a `semiont.transport.Transport`.
+
+One stream, `POST /bus/subscribe`, naming the client's global channels and an
+entry per resource scope it holds; and `POST /bus/emit` for what it sends. The
+stream is `semiont.http.stream`'s. The gateway's own operations ride plain
+request and response, and so does content (`HttpTransport.content`).
+
+What crosses the wire is told to OpenTelemetry as the telemetry table says:
+each emit is counted and sent in a span whose trace travels with it, and each
+frame's arrival is marked in the trace the frame was sent under.
+"""
+
+import asyncio
+import uuid
+from collections.abc import Collection, Mapping, Sequence
+from types import TracebackType
+from typing import Final, Self, final, override
+
+import httpx
+from pydantic import JsonValue, ValidationError
+
+from semiont import telemetry
+from semiont.channels import BRIDGED_CHANNELS, RESOURCE_SCOPED_CHANNELS
+from semiont.errors import SemiontError, TransportError
+from semiont.events import Broadcast, Events
+from semiont.http.content import HttpContentTransport
+from semiont.http.exchange import Exchange, TokenRefresher
+from semiont.http.stream import Bookmarks, Stream, Timing
+from semiont.identifiers import ResourceId
+from semiont.retry import BOOT, RetryFacts, retry_after_ms, retry_with_backoff
+from semiont.timing import EMIT_TIMEOUT_MS
+from semiont.transport import (
+    ConnectionState,
+    ContentTransport,
+    Frame,
+    FrameHub,
+    FrameSink,
+    GatewayOperations,
+    PendingReply,
+    ReplyRouter,
+    ResourceHold,
+    Transport,
+    unsubscribed,
+)
+from semiont.types import (
+    BusEmitAccepted,
+    BusEmitRequest,
+    HealthResponse,
+    MediaTokenRequest,
+    MediaTokenResponse,
+    ProtectedResourceMetadata,
+    StatusResponse,
+    UserResponse,
+)
+from semiont.watched import Watched
+
+__all__ = ["HttpTransport"]
+
+
+def _worth_another_emit(error: SemiontError) -> bool:
+    """Whether an emit that failed this way is made again: nothing answered, or the gateway said "not now"."""
+    return error.status is None or BOOT.retryable(RetryFacts(status=error.status, method="POST"))
+
+
+@final
+class HttpTransport(Transport, GatewayOperations):
+    """A transport to one gateway. Held with `async with`: its stream opens inside, once there is a token, and ends on the way out.
+
+    `token` is the token every request carries: the present one, and each one
+    after it. With none the transport sends nothing and waits for one.
+    `refresher` is asked for another when the gateway refuses the one it has;
+    with none, a refused token is waited out until `token` changes.
+    `channels` are the global channels its stream names: every channel a
+    client hears, unless a process that awaits only some operations names
+    their reply channels and no others. With `bookmarks`, each scope's stream
+    begins where they say the client's last life left it; with none, at the
+    present.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        token: Watched[str | None],
+        refresher: TokenRefresher | None = None,
+        channels: Sequence[str] = BRIDGED_CHANNELS,
+        timing: Timing | None = None,
+        bookmarks: Bookmarks | None = None,
+    ) -> None:
+        self._base_url: Final = base_url.rstrip("/")
+        self._token: Final = token
+        self._global: Final = tuple(channels)
+        self._timing: Final = Timing() if timing is None else timing
+        # This client's address for correlated replies: one per transport, not
+        # per connection, so both streams of a handoff present the same one.
+        self._client_id: Final = str(uuid.uuid4())
+        self._hub: Final = FrameHub()
+        self._router: Final = ReplyRouter()
+        self._failures: Final[Broadcast[SemiontError]] = Broadcast()
+        # It reads no environment variable: no proxy and no certificate file it was not given.
+        self._http: Final = httpx.AsyncClient(timeout=None, trust_env=False)
+        self._stream: Final = Stream(
+            base_url=self._base_url,
+            http=self._http,
+            token=token,
+            refresher=refresher,
+            client_id=self._client_id,
+            channels=self._global,
+            timing=self._timing,
+            hub=self._hub,
+            router=self._router,
+            failures=self._failures,
+            bookmarks=bookmarks,
+        )
+        self._closing: Final = asyncio.Event()
+        self._exchange: Final = Exchange(
+            base_url=self._base_url,
+            http=self._http,
+            token=token,
+            refresher=refresher,
+            failures=self._failures,
+            deadline_ms=self._timing.http_request_ms,
+            closing=self._closing,
+        )
+        self._content: Final = HttpContentTransport(self._exchange)
+        self._holds: Final[dict[ResourceId, int]] = {}
+        """How many holds each resource's scope has."""
+        self._running: asyncio.Task[None] | None = None
+        self._closed: Final = asyncio.Event()
+        self._emitting = 0
+        self._quiet: Final = asyncio.Event()
+        """Set while no emit of this transport is under way."""
+        self._quiet.set()
+
+    async def __aenter__(self) -> Self:
+        if self._running is not None or self._closing.is_set():
+            raise RuntimeError("a transport is opened once")
+        self._running = asyncio.create_task(self._run())
+        return self
+
+    async def __aexit__(self, kind: type[BaseException] | None, error: BaseException | None, trace: TracebackType | None) -> None:
+        await self.close()
+
+    async def _run(self) -> None:
+        """The transport's life: its stream, until it is closed; then the emits under way, each to its end."""
+        try:
+            await self._stream.run()
+            await self._quiet.wait()
+        finally:
+            # A failure is reported for as long as an emit can fail: to the end.
+            self._failures.close()
+            try:
+                # Whatever else is on the wire ends here, as a request that got no answer.
+                await self._http.aclose()
+                await self._exchange.ended()
+            finally:
+                self._closed.set()
+
+    @property
+    @override
+    def base_url(self) -> str:
+        return self._base_url
+
+    @property
+    @override
+    def state(self) -> Watched[ConnectionState]:
+        return self._stream.state
+
+    @property
+    def content(self) -> ContentTransport:
+        """Bytes, and a resource's description, from the same gateway."""
+        return self._content
+
+    @override
+    def failures(self) -> Events[SemiontError]:
+        return self._failures.listen()
+
+    @override
+    def is_subscribed(self, channel: str) -> bool:
+        return channel in self._global
+
+    @override
+    def frames(self, channel: str) -> Events[Frame]:
+        # A channel this stream can never carry would be a reader that is
+        # never given anything, which reads as a quiet system: refused at the
+        # call. A resource-scoped channel passes with no scope held yet, since
+        # frames flow the moment one is.
+        if not self.is_subscribed(channel) and channel not in RESOURCE_SCOPED_CHANNELS:
+            raise unsubscribed(channel)
+        return self._hub.frames(channel)
+
+    @override
+    def track_reply(self, correlation_id: str, reply_channels: Collection[str]) -> PendingReply:
+        return self._router.track(correlation_id, reply_channels)
+
+    @override
+    def bridge_into(self, bus: FrameSink) -> None:
+        self._hub.bridge(bus)
+
+    @override
+    def subscribe_to_resource(self, resource_id: ResourceId) -> ResourceHold:
+        held = self._holds.get(resource_id, 0)
+        self._holds[resource_id] = held + 1
+        if held == 0:
+            self._stream.take_scope(resource_id)
+
+        def release() -> None:
+            remaining = self._holds[resource_id] - 1
+            if remaining > 0:
+                self._holds[resource_id] = remaining
+                return
+            del self._holds[resource_id]
+            self._stream.let_go_of_scope(resource_id)
+
+        return ResourceHold(release)
+
+    @override
+    async def emit(
+        self,
+        channel: str,
+        payload: Mapping[str, JsonValue],
+        *,
+        scope: ResourceId | None = None,
+        correlation_id: str | None = None,
+    ) -> int | None:
+        if self._running is None:
+            raise RuntimeError("the transport is not open: hold it with `async with`")
+        body = BusEmitRequest(
+            channel=channel,
+            payload=dict(payload),
+            scope=scope,
+            client_id=self._client_id,
+            correlation_id=correlation_id,
+        ).model_dump_json(exclude_none=True)
+        self._emitting += 1
+        self._quiet.clear()
+        try:
+            with telemetry.emitting(channel, scope):
+                return await retry_with_backoff(
+                    self._timing.emit_retry,
+                    lambda: self._emit_once(body),
+                    retryable=_worth_another_emit,
+                    give_up=self._closing,
+                )
+        except TransportError as error:
+            # A failed emit is reported where every failure is, as its caller hears it.
+            self._failures.deliver(error)
+            raise
+        finally:
+            self._emitting -= 1
+            if self._emitting == 0:
+                self._quiet.set()
+
+    async def _emit_once(self, body: str) -> int | None:
+        """One attempt of an emit: `POST /bus/emit`, answered within `EMIT_TIMEOUT_MS`."""
+        if self._closing.is_set():
+            raise TransportError("error", "/bus/emit was not sent: the transport is closed")
+        try:
+            async with asyncio.timeout(EMIT_TIMEOUT_MS / 1000):
+                response = await self._http.post(
+                    f"{self._base_url}/bus/emit",
+                    content=body,
+                    headers={
+                        **telemetry.trace_headers(),
+                        "Authorization": f"Bearer {self._token.value or ''}",
+                        "Content-Type": "application/json",
+                    },
+                )
+        except TimeoutError:
+            raise TransportError.without_response(f"/bus/emit got no answer within {EMIT_TIMEOUT_MS // 1000}s") from None
+        except httpx.HTTPError as error:
+            raise TransportError.without_response(f"/bus/emit got no answer: {error!r}") from error
+        if not response.is_success:
+            status = response.status_code
+            detail = response.text[:500]
+            raise TransportError.of_status(
+                f"/bus/emit {status}: {detail}" if detail else f"/bus/emit {status}",
+                status,
+                retry_after_ms(response.headers.get("retry-after")),
+            )
+        # No count is reported as no count, never as a zero: an absent
+        # `subscribers` is the gateway saying it could not count, and a body
+        # that is not the declared one says nothing at all.
+        try:
+            return BusEmitAccepted.model_validate_json(response.content).subscribers
+        except ValidationError:
+            return None
+
+    @override
+    async def get_current_user(self) -> UserResponse:
+        return await self._exchange.answer(UserResponse, "GET", "/api/users/me")
+
+    @override
+    async def get_media_token(self, resource_id: ResourceId) -> MediaTokenResponse:
+        return await self._exchange.answer(
+            MediaTokenResponse,
+            "POST",
+            "/api/tokens/media",
+            headers={"Content-Type": "application/json"},
+            content=MediaTokenRequest(resource_id=resource_id).model_dump_json().encode(),
+        )
+
+    @override
+    async def get_protected_resource_metadata(self) -> ProtectedResourceMetadata:
+        return await self._exchange.answer(ProtectedResourceMetadata, "GET", "/.well-known/oauth-protected-resource", authenticated=False)
+
+    @override
+    async def health_check(self) -> HealthResponse:
+        return await self._exchange.answer(HealthResponse, "GET", "/api/health")
+
+    @override
+    async def get_status(self) -> StatusResponse:
+        return await self._exchange.answer(StatusResponse, "GET", "/api/status")
+
+    @override
+    async def close(self) -> None:
+        if not self._closing.is_set():
+            self._closing.set()
+            self._stream.stop()
+            if self._running is None:
+                # Never opened: its stream's task runs only to end.
+                self._running = asyncio.create_task(self._run())
+        await self._closed.wait()
+        if self._running is not None:
+            # Whatever ended the stream's task that was not its closing is raised here.
+            await self._running

semiont/identifiers.py

@@ -0,0 +1,114 @@
+# Generated from specs/src/identifiers/kinds.json and each kind's schema; do not edit.
+# Regenerate: node scripts/spec/generate-identifiers-python.mjs
+
+"""The kinds of id.
+
+A value of one of these types is text that passed its kind's rule, which is the
+schema's pattern. It is made here and nowhere else: by the kind's constructor,
+which raises `InvalidIdentifier` for text the rule refuses, by `parse`, which
+answers `None` instead, and by decoding, which goes through the same rule. It
+is a `str`, so it reads as the text it is. One kind is not another: a type
+checker refuses a `ResourceId` where an `AnnotationId` is wanted.
+"""
+
+import re
+from typing import ClassVar, Final, Self, final
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+__all__ = ["AnnotationId", "InvalidIdentifier", "JobId", "ResourceId", "UserId"]
+
+
+@final
+class InvalidIdentifier(ValueError):
+    """Text that is not an id of the kind it was to be."""
+
+    def __init__(self, kind: str, pattern: str, value: str) -> None:
+        super().__init__(f"{value!r} is not a {kind}: it does not match {pattern}")
+        self.kind: Final = kind
+        self.pattern: Final = pattern
+        self.value: Final = value
+
+
+class _Identifier(str):
+    """What the kinds share: text held to a rule, wherever it is made."""
+
+    __slots__ = ()
+    PATTERN: ClassVar[str]
+    """The kind's rule, as its schema states it."""
+    _RULE: ClassVar[re.Pattern[str]]
+
+    def __new__(cls, text: str) -> Self:
+        if cls._RULE.fullmatch(text) is None:
+            raise InvalidIdentifier(cls.__name__, cls.PATTERN, text)
+        return super().__new__(cls, text)
+
+    @classmethod
+    def parse(cls, text: str) -> Self | None:
+        """`text` as this kind of id, or `None` when the kind's rule refuses it.
+
+        For where text that is not an id is an ordinary answer and not a fault:
+        an address someone typed, a key read from storage.
+        """
+        return super().__new__(cls, text) if cls._RULE.fullmatch(text) is not None else None
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source: object, handler: GetCoreSchemaHandler) -> CoreSchema:
+        # Decoding goes through the constructor: an id in an answer passed the
+        # same rule as one a caller made.
+        return core_schema.no_info_after_validator_function(cls, core_schema.str_schema())
+
+
+@final
+class ResourceId(_Identifier):
+    """A resource's id: a name, never the resource's URI or a path. 1 to 128 of the letters `A`–`Z`
+    and `a`–`z`, the digits, `_` and `-`. It is one segment of a URL and one name in a file
+    system, and it is held to that wherever it enters: a gateway refuses a payload that carries
+    anything else. How one is made is no part of the rule. `__system__` is the one that names no
+    resource: the scope events about the knowledge base itself are logged under.
+    """
+
+    __slots__ = ()
+    PATTERN: ClassVar[str] = "^[A-Za-z0-9_-]{1,128}$"
+    _RULE: ClassVar[re.Pattern[str]] = re.compile("[A-Za-z0-9_-]{1,128}")
+
+
+@final
+class AnnotationId(_Identifier):
+    """An annotation's id: a name, never the annotation's URI. 1 to 128 of the letters `A`–`Z` and
+    `a`–`z`, the digits, `_` and `-`. It is one segment of a URL and one name in a file system,
+    and it is held to that wherever it enters: a gateway refuses a payload that carries anything
+    else. How one is made is no part of the rule.
+    """
+
+    __slots__ = ()
+    PATTERN: ClassVar[str] = "^[A-Za-z0-9_-]{1,128}$"
+    _RULE: ClassVar[re.Pattern[str]] = re.compile("[A-Za-z0-9_-]{1,128}")
+
+
+@final
+class JobId(_Identifier):
+    """A job's id. 1 to 128 of the letters `A`–`Z` and `a`–`z`, the digits, `_` and `-`. It is one
+    segment of a URL and one name in a file system, and it is held to that wherever it enters: a
+    gateway refuses a payload that carries anything else. How one is made is no part of the
+    rule.
+    """
+
+    __slots__ = ()
+    PATTERN: ClassVar[str] = "^[A-Za-z0-9_-]{1,128}$"
+    _RULE: ClassVar[re.Pattern[str]] = re.compile("[A-Za-z0-9_-]{1,128}")
+
+
+@final
+class UserId(_Identifier):
+    """The identity of whoever did something, a person or a software agent alike: a DID
+    (`did:web:<domain>:users:<subject>`, `did:web:<domain>:agents:<provider>:<model>`), with no
+    whitespace in it. Never a name, an address, or a row in a table. What follows `did:` is not
+    constrained further: a subject is the issuer's, percent-encoded, and that encoding leaves
+    some punctuation as it is.
+    """
+
+    __slots__ = ()
+    PATTERN: ClassVar[str] = "^did:\\S+$"
+    _RULE: ClassVar[re.Pattern[str]] = re.compile("did:\\S+")

semiont/identity.py

@@ -0,0 +1,59 @@
+"""How a knowledge base is named, and the principals who act in it.
+
+Every function here is held to a case table every implementation runs: the
+knowledge base's own names to `specs/src/kb-identity/cases.json`, the rest to
+`specs/src/principals/cases.json`.
+"""
+
+import re
+from typing import Final
+from urllib.parse import quote
+
+from semiont.identifiers import UserId
+
+__all__ = ["agent_address", "agent_did", "agent_name", "encode_uri_component", "kb_did", "kb_resource", "person_did"]
+
+# What ECMAScript's `encodeURIComponent` leaves alone, beside letters and digits.
+_UNRESERVED: Final = "-_.!~*'()"
+_NOT_OF_AN_ADDRESS: Final = re.compile(r"[^A-Za-z0-9]+")
+
+
+def encode_uri_component(value: str) -> str:
+    """`value` as `encodeURIComponent` writes it: each UTF-8 byte of every other character as `%XX`, in uppercase hex."""
+    return quote(value, safe=_UNRESERVED)
+
+
+def kb_did(domain: str) -> UserId:
+    """The knowledge base's DID: `did:web:` and its domain as it is, which is already a colon path."""
+    return UserId(f"did:web:{domain}")
+
+
+def kb_resource(domain: str) -> str:
+    """The knowledge base's resource identifier, the audience its tokens carry: its DID as an https URL."""
+    return f"https://{domain.replace(':', '/')}"
+
+
+def person_did(domain: str, subject: str) -> UserId:
+    """A person, named by the subject the issuer asserted."""
+    return UserId(f"did:web:{domain}:users:{encode_uri_component(subject)}")
+
+
+def agent_did(domain: str, provider: str, model: str) -> UserId:
+    """A software agent: one per provider and model, under the knowledge base's domain."""
+    return UserId(f"did:web:{domain}:agents:{encode_uri_component(provider)}:{encode_uri_component(model)}")
+
+
+def agent_address(domain: str, provider: str, model: str) -> str:
+    """An agent's address.
+
+    `provider:model`, with every run of characters outside `[A-Za-z0-9-]` one
+    hyphen and none at either end, at `agents.` and the domain up to its first
+    colon.
+    """
+    slug = re.sub("-+", "-", _NOT_OF_AN_ADDRESS.sub("-", f"{provider}:{model}")).strip("-")
+    return f"{slug}@agents.{domain.split(':', 1)[0]}"
+
+
+def agent_name(provider: str, model: str) -> str:
+    """An agent's name."""
+    return f"{provider} {model}"

semiont/media_types.py

@@ -0,0 +1,69 @@
+"""The rules read from the media types a knowledge base admits.
+
+The table is `specs/src/media-types/registry.json`
+(`semiont.media_types_table`), and the rules are the ones
+`specs/src/media-types/cases.json` holds in every SDK: the format a clone
+takes, and the name content is stored under.
+"""
+
+from typing import Final
+
+from semiont.media_types_table import MEDIA_TYPES, MediaType
+from semiont.types import Representation, ResourceDescriptor
+
+__all__ = ["base_media_type", "capabilities_of", "clone_format", "primary_media_type", "storage_file_name", "storage_uri"]
+
+_BY_MEDIA_TYPE: Final = {row.media_type: row for row in MEDIA_TYPES}
+_PLAIN_TEXT: Final = _BY_MEDIA_TYPE["text/plain"]
+
+
+def base_media_type(format: str) -> str:
+    """A format without its parameters (`; charset=…`), in lower case."""
+    return format.split(";", 1)[0].strip().lower()
+
+
+def capabilities_of(format: str) -> MediaType | None:
+    """The table's row for `format`, whose parameters are not read.
+
+    A stored type may be one the table does not have: what was imported keeps
+    the type it came with.
+    """
+    return _BY_MEDIA_TYPE.get(base_media_type(format))
+
+
+def primary_media_type(resource: ResourceDescriptor) -> str | None:
+    """The media type of a resource's first representation."""
+    stated = resource.representations
+    if isinstance(stated, Representation):
+        return stated.media_type
+    return stated[0].media_type if stated else None
+
+
+def clone_format(source: str | None) -> MediaType:
+    """The format a clone of a resource takes: its source's, when that is one a person can author, and plain text otherwise.
+
+    A clone opens where a person writes.
+    """
+    row = None if source is None else capabilities_of(source)
+    return row if row is not None and row.authorable else _PLAIN_TEXT
+
+
+def storage_file_name(name: str, format: MediaType) -> str:
+    """The name a resource's content is stored under.
+
+    Its title in lower case, every run of characters that are not a to z or 0
+    to 9 made one hyphen, none at either end, and then the format's
+    extension.
+    """
+    kept: list[str] = []
+    for character in name.lower():
+        if character.isascii() and (character.islower() or character.isdigit()):
+            kept.append(character)
+        elif not kept or kept[-1] != "-":
+            kept.append("-")
+    return "".join(kept).strip("-") + format.extension
+
+
+def storage_uri(name: str, format: MediaType) -> str:
+    """The `file://` URI of `storage_file_name`: where the content is stored, at the root of the working tree."""
+    return f"file://{storage_file_name(name, format)}"

semiont/media_types_table.py

@@ -0,0 +1,89 @@
+# Generated from specs/src/media-types/registry.json; do not edit.
+# Regenerate: node scripts/spec/generate-media-types-python.mjs
+
+"""The media types a knowledge base admits, with what this SDK reads of each."""
+
+from dataclasses import dataclass
+from typing import Final, final
+
+__all__ = ["MEDIA_TYPES", "MediaType"]
+
+
+@final
+@dataclass(frozen=True, slots=True, kw_only=True)
+class MediaType:
+    """One media type a knowledge base admits."""
+
+    media_type: str
+    extension: str
+    """The extension a stored name takes, with its dot."""
+    authorable: bool
+    """Offered where a person writes a resource."""
+
+
+# The registry, in its own order: 63 media types.
+MEDIA_TYPES: Final[tuple[MediaType, ...]] = (
+    MediaType(media_type="text/markdown", extension=".md", authorable=True),
+    MediaType(media_type="text/plain", extension=".txt", authorable=True),
+    MediaType(media_type="text/html", extension=".html", authorable=True),
+    MediaType(media_type="application/json", extension=".json", authorable=False),
+    MediaType(media_type="image/png", extension=".png", authorable=False),
+    MediaType(media_type="image/jpeg", extension=".jpg", authorable=False),
+    MediaType(media_type="application/pdf", extension=".pdf", authorable=False),
+    MediaType(media_type="text/css", extension=".css", authorable=False),
+    MediaType(media_type="text/csv", extension=".csv", authorable=False),
+    MediaType(media_type="text/xml", extension=".xml", authorable=False),
+    MediaType(media_type="application/xml", extension=".xml", authorable=False),
+    MediaType(media_type="application/yaml", extension=".yaml", authorable=False),
+    MediaType(media_type="application/x-yaml", extension=".yaml", authorable=False),
+    MediaType(media_type="text/javascript", extension=".js", authorable=False),
+    MediaType(media_type="application/javascript", extension=".js", authorable=False),
+    MediaType(media_type="text/x-typescript", extension=".ts", authorable=False),
+    MediaType(media_type="application/typescript", extension=".ts", authorable=False),
+    MediaType(media_type="text/x-python", extension=".py", authorable=False),
+    MediaType(media_type="text/x-java", extension=".java", authorable=False),
+    MediaType(media_type="text/x-c", extension=".c", authorable=False),
+    MediaType(media_type="text/x-c++", extension=".cpp", authorable=False),
+    MediaType(media_type="text/x-csharp", extension=".cs", authorable=False),
+    MediaType(media_type="text/x-go", extension=".go", authorable=False),
+    MediaType(media_type="text/x-rust", extension=".rs", authorable=False),
+    MediaType(media_type="text/x-ruby", extension=".rb", authorable=False),
+    MediaType(media_type="text/x-php", extension=".php", authorable=False),
+    MediaType(media_type="text/x-swift", extension=".swift", authorable=False),
+    MediaType(media_type="text/x-kotlin", extension=".kt", authorable=False),
+    MediaType(media_type="text/x-shell", extension=".sh", authorable=False),
+    MediaType(media_type="application/msword", extension=".doc", authorable=False),
+    MediaType(media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document", extension=".docx", authorable=False),
+    MediaType(media_type="application/vnd.ms-excel", extension=".xls", authorable=False),
+    MediaType(media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", extension=".xlsx", authorable=False),
+    MediaType(media_type="application/vnd.ms-powerpoint", extension=".ppt", authorable=False),
+    MediaType(media_type="application/vnd.openxmlformats-officedocument.presentationml.presentation", extension=".pptx", authorable=False),
+    MediaType(media_type="application/zip", extension=".zip", authorable=False),
+    MediaType(media_type="application/gzip", extension=".gz", authorable=False),
+    MediaType(media_type="application/x-tar", extension=".tar", authorable=False),
+    MediaType(media_type="application/x-7z-compressed", extension=".7z", authorable=False),
+    MediaType(media_type="application/octet-stream", extension=".bin", authorable=False),
+    MediaType(media_type="application/wasm", extension=".wasm", authorable=False),
+    MediaType(media_type="image/gif", extension=".gif", authorable=False),
+    MediaType(media_type="image/webp", extension=".webp", authorable=False),
+    MediaType(media_type="image/svg+xml", extension=".svg", authorable=False),
+    MediaType(media_type="image/bmp", extension=".bmp", authorable=False),
+    MediaType(media_type="image/tiff", extension=".tiff", authorable=False),
+    MediaType(media_type="image/x-icon", extension=".ico", authorable=False),
+    MediaType(media_type="video/mp4", extension=".mp4", authorable=False),
+    MediaType(media_type="video/mpeg", extension=".mpeg", authorable=False),
+    MediaType(media_type="video/webm", extension=".webm", authorable=False),
+    MediaType(media_type="video/ogg", extension=".ogv", authorable=False),
+    MediaType(media_type="video/quicktime", extension=".mov", authorable=False),
+    MediaType(media_type="video/x-msvideo", extension=".avi", authorable=False),
+    MediaType(media_type="audio/mpeg", extension=".mp3", authorable=False),
+    MediaType(media_type="audio/wav", extension=".wav", authorable=False),
+    MediaType(media_type="audio/ogg", extension=".ogg", authorable=False),
+    MediaType(media_type="audio/webm", extension=".webm", authorable=False),
+    MediaType(media_type="audio/aac", extension=".aac", authorable=False),
+    MediaType(media_type="audio/flac", extension=".flac", authorable=False),
+    MediaType(media_type="font/woff", extension=".woff", authorable=False),
+    MediaType(media_type="font/woff2", extension=".woff2", authorable=False),
+    MediaType(media_type="font/ttf", extension=".ttf", authorable=False),
+    MediaType(media_type="font/otf", extension=".otf", authorable=False),
+)