UncountablePythonSDK 0.0.21__tar.gz → 0.0.23__tar.gz

{uncountablepythonsdk-0.0.21/UncountablePythonSDK.egg-info → uncountablepythonsdk-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.21
+Version: 0.0.23
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23/UncountablePythonSDK.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.21
+Version: 0.0.23
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/UncountablePythonSDK.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ docs/static/favicons/favicon-32x32.png
 docs/static/favicons/manifest.json
 docs/static/favicons/mstile-150x150.png
 docs/static/favicons/safari-pinned-tab.svg
+examples/async_batch.py
 examples/create_entity.py
 examples/upload_files.py
 examples/recipe-import/importer.py
@@ -114,6 +115,7 @@ type_spec/external/api/triggers/run_trigger.yaml
 uncountable/__init__.py
 uncountable/py.typed
 uncountable/core/__init__.py
+uncountable/core/async_batch.py
 uncountable/core/client.py
 uncountable/core/file_upload.py
 uncountable/core/types.py

uncountablepythonsdk-0.0.23/examples/async_batch.py

@@ -0,0 +1,36 @@
+from decimal import Decimal
+from uncountable.core import AuthDetailsApiKey, Client
+from uncountable.core import AsyncBatchProcessor
+from uncountable.types import (
+    recipe_metadata,
+)
+from uncountable.types.identifier import IdentifierKeyBatchReference
+from uncountable.types.recipe_identifiers import (
+    RecipeIdentifierEditableName,
+    RecipeIdentifiers,
+)
+
+
+client = Client(
+    base_url="https://app.uncountable.com",
+    auth_details=AuthDetailsApiKey(
+        api_id="X",
+        api_secret_key="X",
+    ),
+)
+batch_loader = AsyncBatchProcessor(client=client)
+recipe_identifiers: RecipeIdentifiers = []
+recipe_identifiers.append(
+    RecipeIdentifierEditableName(editable_name="My recipe from API")
+)
+req = batch_loader.create_recipe(
+    material_family_id=1, workflow_id=1, identifiers=recipe_identifiers
+)
+created_recipe_reference = req.batch_reference
+batch_loader.set_recipe_metadata(
+    recipe_key=IdentifierKeyBatchReference(reference=created_recipe_reference),
+    recipe_metadata=[
+        recipe_metadata.MetadataValue(metadata_id=7, value_numeric=Decimal(38))
+    ],
+)
+job_id = batch_loader.send()

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/builder.py

@@ -10,7 +10,7 @@ import re
 from collections import defaultdict
 from dataclasses import MISSING, dataclass
 from enum import Enum, StrEnum, auto
-from typing import Any, Optional
+from typing import Any, Optional, Self
 
 from . import util
 from .util import parse_type_str, unused
@@ -86,6 +86,7 @@ class BaseTypeName(StrEnum):
     s_optional = "Optional"
     s_string = "String"
     s_tuple = "Tuple"
+    s_readonly_array = "ReadonlyArray"
     s_union = "Union"
 
     # For a root class that defines properties
@@ -184,6 +185,34 @@ class SpecTypeInstance(SpecType):
         return defn_type + self.parameters
 
 
+@dataclass(kw_only=True)
+class SpecEndpointExample:
+    summary: str
+    description: str
+    arguments: dict[str, object]
+    data: dict[str, object]
+
+
+@dataclass(kw_only=True)
+class SpecGuide:
+    title: str
+    markdown_content: str
+    html_content: str
+
+
+@dataclass(kw_only=True, frozen=True)
+class RootGuideKey:
+    pass
+
+
+@dataclass(kw_only=True, frozen=True)
+class EndpointGuideKey:
+    path: str
+
+
+SpecGuideKey = RootGuideKey | EndpointGuideKey
+
+
 class SpecTypeLiteralWrapper(SpecType):
     def __init__(
         self,
@@ -672,6 +701,32 @@ class ResultType(StrEnum):
 RE_ENDPOINT_ROOT = re.compile(r"\${([_a-z]+)}")
 
 
+@dataclass(kw_only=True, frozen=True)
+class _EndpointPathDetails:
+    root: str
+    root_path: str
+    resolved_path: str
+
+
+def _resolve_endpoint_path(
+    path: str, api_endpoints: dict[str, str]
+) -> _EndpointPathDetails:
+    root_path_source = path.split("/")[0]
+    root_match = RE_ENDPOINT_ROOT.fullmatch(root_path_source)
+    if root_match is None:
+        raise Exception(f"invalid-api-path-root:{root_path_source}")
+
+    root_var = root_match.group(1)
+    root_path = api_endpoints[root_var]
+
+    _, *rest_path = path.split("/", 1)
+    resolved_path = "/".join([root_path] + rest_path)
+
+    return _EndpointPathDetails(
+        root=root_var, root_path=root_path, resolved_path=resolved_path
+    )
+
+
 class SpecEndpoint:
     method: RouteMethod
     root: str
@@ -748,14 +803,10 @@ class SpecEndpoint:
 
         self.result_type = ResultType(data.get("result_type", ResultType.json.value))
 
+        path_details = _resolve_endpoint_path(data["path"], builder.api_endpoints)
+        self.root = path_details.root
+        self.path_root = path_details.root_path
         self.desc = data.get("desc")
-
-        root_match = RE_ENDPOINT_ROOT.fullmatch(path[0])
-        if root_match is None:
-            raise Exception(f"invalid-api-path-root:{path[0]}")
-
-        self.root = root_match.group(1)
-        self.path_root = builder.api_endpoints[self.root]
         # IMPROVE: remove need for is_external flag
         self.is_external = self.path_root == "api/external"
         self.has_attachment = data.get("has_attachment", False)
@@ -764,6 +815,10 @@ class SpecEndpoint:
             not is_sdk or self.desc is not None
         ), f"Endpoint description required for SDK endpoints, missing: {path}"
 
+    @property
+    def resolved_path(self: Self) -> str:
+        return f"{self.path_root}/{self.path_dirname}/{self.path_basename}"
+
 
 def _parse_const(
     builder: SpecBuilder,
@@ -1014,6 +1069,8 @@ class SpecBuilder:
         self.pending: list[NamespaceDataPair] = []
         self.parts: dict[str, dict[str, str]] = defaultdict(dict)
         self.preparts: dict[str, dict[str, str]] = defaultdict(dict)
+        self.examples: dict[str, list[SpecEndpointExample]] = defaultdict(list)
+        self.guides: dict[SpecGuideKey, list[SpecGuide]] = defaultdict(list)
         self.api_endpoints = api_endpoints
         base_namespace = SpecNamespace(name=base_namespace_name)
         for base_type in BaseTypeName:
@@ -1198,5 +1255,53 @@ class SpecBuilder:
     def add_prepart_file(self, target: str, name: str, data: str) -> None:
         self.preparts[target][name] = data
 
+    def add_example_file(self, data: dict[str, object]) -> None:
+        path_details = _resolve_endpoint_path(str(data["path"]), self.api_endpoints)
+
+        examples_data = data["examples"]
+        if not isinstance(examples_data, list):
+            raise Exception(
+                f"'examples' in example files are expected to be a list, endpoint_path={path_details.resolved_path}"
+            )
+        for example in examples_data:
+            arguments = example["arguments"]
+            data_example = example["data"]
+            if not isinstance(arguments, dict) or not isinstance(data_example, dict):
+                raise Exception(
+                    f"'arguments' and 'data' fields must be dictionaries for each endpoint example, endpoint={path_details.resolved_path}"
+                )
+            self.examples[path_details.resolved_path].append(
+                SpecEndpointExample(
+                    summary=str(example["summary"]),
+                    description=str(example["description"]),
+                    arguments=arguments,
+                    data=data_example,
+                )
+            )
+
+    def add_guide_file(self, file_content: str) -> None:
+        import markdown
+
+        md = markdown.Markdown(extensions=["meta"])
+        html = md.convert(file_content)
+        meta: dict[str, list[str]] = md.Meta  # type: ignore[attr-defined]
+        title_meta: list[str] | None = meta.get("title")
+        if title_meta is None:
+            raise Exception("guides requier a title in the meta section")
+
+        path_meta: list[str] | None = meta.get("path")
+        guide_key: SpecGuideKey = RootGuideKey()
+        if path_meta is not None:
+            path_details = _resolve_endpoint_path("".join(path_meta), self.api_endpoints)
+            guide_key = EndpointGuideKey(path=path_details.resolved_path)
+
+        self.guides[guide_key].append(
+            SpecGuide(
+                title="".join(title_meta),
+                html_content=html,
+                markdown_content=file_content,
+            )
+        )
+
     def resolve_proper_name(self, stype: SpecTypeDefn) -> str:
         return f"{'.'.join(stype.namespace.path)}.{stype.name}"

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/emit_io_ts.py

@@ -118,7 +118,10 @@ def refer_to_io_ts(
     stype: builder.SpecType,
 ) -> str:
     if isinstance(stype, builder.SpecTypeInstance):
-        if stype.defn_type.name == builder.BaseTypeName.s_list:
+        if (
+            stype.defn_type.name == builder.BaseTypeName.s_list
+            or stype.defn_type.name == builder.BaseTypeName.s_readonly_array
+        ):
             spec = refer_to_io_ts(ctx, stype.parameters[0])
             return f"IO.array({spec})"
         if stype.defn_type.name == builder.BaseTypeName.s_union:

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/emit_open_api.py

@@ -5,18 +5,22 @@ WORK-IN-PROGRESS, DON'T USE!
 """
 
 import dataclasses
+import json
 import re
-from typing import cast
+from typing import Collection, cast
 
 import yaml
 
 from . import builder, util
+from .builder import EndpointGuideKey, RootGuideKey
 from .config import OpenAPIConfig
 from .emit_open_api_util import (
     MODIFY_NOTICE,
     EmitOpenAPIContext,
     EmitOpenAPIEndpoint,
+    EmitOpenAPIEndpointExample,
     EmitOpenAPIGlobalContext,
+    EmitOpenAPIGuide,
     EmitOpenAPIPath,
     EmitOpenAPIServer,
     EmitOpenAPITag,
@@ -74,12 +78,23 @@ def _rewrite_with_notice(
     return util.rewrite_file(file_path, f"{notice}\n{modified_file_content}")
 
 
-def _open_api_info(config: OpenAPIConfig) -> GlobalContextInfo:
-    description = config.description
+def _write_guide_as_html(guide: EmitOpenAPIGuide) -> str:
+    return f"""
+        <details>
+        <summary>{guide.title}</summary>
+        {guide.html_content}
+        </details>"""
+
+
+def _open_api_info(
+    config: OpenAPIConfig, guides: list[EmitOpenAPIGuide]
+) -> GlobalContextInfo:
+    full_guides = "<br/>".join([_write_guide_as_html(guide) for guide in guides])
+    full_description = f"{config.description}<br/>{full_guides}"
     info: GlobalContextInfo = dict()
     info["version"] = "1.0.0"
     info["title"] = "Uncountable API Documentation"
-    info["description"] = description
+    info["description"] = full_description
     info["x-logo"] = {"url": "../static/images/logo_blue.png", "altText": "Logo"}
     return info
 
@@ -90,9 +105,14 @@ def _open_api_servers(config: OpenAPIConfig) -> list[EmitOpenAPIServer]:
 
 
 def emit_open_api(builder: builder.SpecBuilder, *, config: OpenAPIConfig) -> None:
+    root_guides = builder.guides.get(RootGuideKey(), [])
+    openapi_guides = [
+        EmitOpenAPIGuide(title=guide.title, html_content=guide.html_content)
+        for guide in root_guides
+    ]
     gctx = EmitOpenAPIGlobalContext(
         version="3.0.0",
-        info=_open_api_info(config),
+        info=_open_api_info(config, openapi_guides),
         servers=_open_api_servers(config),
     )
 
@@ -112,6 +132,8 @@ def emit_open_api(builder: builder.SpecBuilder, *, config: OpenAPIConfig) -> Non
             ctx,
             namespace=namespace,
             config=config,
+            examples=builder.examples,
+            guides=builder.guides,
         )
 
     _rewrite_with_notice(
@@ -144,52 +166,183 @@ def _serialize_global_context(ctx: EmitOpenAPIGlobalContext) -> str:
     return yaml.dump(oa_root, sort_keys=False)
 
 
-def _emit_endpoint_parameters(typ: OpenAPIType | None) -> dict[str, list[dict[str, str]]]:
+def _is_empty_object_type(typ: OpenAPIType) -> bool:
     if not isinstance(typ, OpenAPIObjectType):
+        return False
+    return len(typ.properties) == 0
+
+
+_QUERY_PARM_METHODS = ("get", "head", "options")
+_REQUEST_BODY_METHODS = ("put", "post", "patch", "delete")
+
+ApiSchema = dict[str, "ApiSchema"] | Collection["ApiSchema"] | str | bool
+DictApiSchema = dict[str, ApiSchema]
+
+
+def _emit_endpoint_argument_examples(
+    examples: list[EmitOpenAPIEndpointExample],
+) -> DictApiSchema:
+    if len(examples) == 0:
+        return {}
+
+    response_examples = {}
+    for example in examples:
+        response_examples[example.ref_name] = {
+            "summary": example.summary,
+            "description": example.description,
+            "value": example.arguments,
+        }
+    return {"examples": response_examples}
+
+
+def _emit_endpoint_parameter_examples(
+    examples: list[EmitOpenAPIEndpointExample],
+) -> DictApiSchema:
+    if len(examples) == 0:
+        return {}
+
+    paramater_examples = []
+    comment_new_line = "\n// "
+    new_line = "\n"
+    for example in examples:
+        javascript_description = (
+            f"// {comment_new_line.join(example.description.split(new_line))}"
+        )
+        javascript_json_payload = f"{json.dumps(example.arguments, indent=2)}"
+        paramater_examples.append({
+            "lang": "JavaScript",
+            "label": f"Payload - {example.summary}",
+            "source": f"{javascript_description}\n{javascript_json_payload}",
+        })
+    return {"x-codeSamples": paramater_examples}
+
+
+def _emit_endpoint_parameters(
+    endpoint: EmitOpenAPIEndpoint,
+    argument_type: OpenAPIType | None,
+    examples: list[EmitOpenAPIEndpointExample],
+) -> DictApiSchema:
+    if (
+        endpoint.method.lower() not in _QUERY_PARM_METHODS
+        or argument_type is None
+        or _is_empty_object_type(argument_type)
+    ):
         return {}
 
     return {
         "parameters": [
-            {"$ref": f"#/components/schema/Arguments/{prop_name}"}
-            for prop_name in typ.properties
+            {
+                "name": "data",
+                "required": True,
+                "in": "query",
+                "content": {
+                    "application/json": {
+                        "schema": {"$ref": "#/components/schema/Arguments"}
+                    }
+                },
+            }
         ]
-    }
+    } | _emit_endpoint_parameter_examples(examples)
 
 
-def _emit_is_beta(is_beta: bool) -> dict[str, bool]:
+def _emit_is_beta(is_beta: bool) -> DictApiSchema:
     if is_beta:
         return {"x-beta": True}
     return {}
 
 
+def _emit_endpoint_request_body(
+    endpoint: EmitOpenAPIEndpoint,
+    arguments_type: OpenAPIType | None,
+    examples: list[EmitOpenAPIEndpointExample],
+) -> DictApiSchema:
+    if (
+        endpoint.method.lower() not in _REQUEST_BODY_METHODS
+        or arguments_type is None
+        or _is_empty_object_type(arguments_type)
+    ):
+        return {}
+
+    return {
+        "requestBody": {
+            "content": {
+                "application/json": {
+                    "schema": {
+                        "type": "object",
+                        "title": "Body",
+                        "required": ["data"],
+                        "properties": {"data": {"$ref": "#/components/schema/Arguments"}},
+                    }
+                }
+                | _emit_endpoint_argument_examples(examples)
+            },
+        }
+    }
+
+
+def _emit_endpoint_response_examples(
+    examples: list[EmitOpenAPIEndpointExample],
+) -> dict[str, dict[str, object]]:
+    if len(examples) == 0:
+        return {}
+
+    response_examples: dict[str, object] = {}
+    for example in examples:
+        response_examples[example.ref_name] = {
+            "summary": example.summary,
+            "description": example.description,
+            "value": example.data,
+        }
+    return {"examples": response_examples}
+
+
+def _emit_endpoint_description(
+    description: str, guides: list[EmitOpenAPIGuide]
+) -> dict[str, str]:
+    full_guides = "<br/>".join([_write_guide_as_html(guide) for guide in guides])
+    return {
+        "description": description
+        if len(guides) == 0
+        else f"{description}<br/>{full_guides}"
+    }
+
+
 def _emit_namespace(
     gctx: EmitOpenAPIGlobalContext,
     ctx: EmitOpenAPIContext,
     namespace: builder.SpecNamespace,
     *,
     config: OpenAPIConfig,
+    examples: dict[str, list[builder.SpecEndpointExample]],
+    guides: dict[builder.SpecGuideKey, list[builder.SpecGuide]],
 ) -> None:
     for stype in namespace.types.values():
         _emit_type(ctx, stype, config=config)
 
     if namespace.endpoint is not None:
-        _emit_endpoint(gctx, ctx, namespace, namespace.endpoint)
+        endpoint_examples = examples.get(namespace.endpoint.resolved_path, [])
+        endpoint_guides = guides.get(
+            EndpointGuideKey(path=namespace.endpoint.resolved_path), []
+        )
+        _emit_endpoint(
+            gctx, ctx, namespace, namespace.endpoint, endpoint_examples, endpoint_guides
+        )
 
     oa_components: dict[str, object] = dict()
 
     if ctx.endpoint is not None:
         endpoint = ctx.endpoint
-
         argument_type = ctx.types.get("Arguments")
         oa_endpoint = dict()
         oa_endpoint[endpoint.method] = (
             {
                 "tags": endpoint.tags,
                 "summary": endpoint.summary,
-                "description": endpoint.description,
             }
+            | _emit_endpoint_description(endpoint.description, ctx.endpoint.guides)
             | _emit_is_beta(endpoint.is_beta)
-            | _emit_endpoint_parameters(argument_type)
+            | _emit_endpoint_parameters(endpoint, argument_type, ctx.endpoint.examples)
+            | _emit_endpoint_request_body(endpoint, argument_type, ctx.endpoint.examples)
             | {
                 "responses": {
                     "200": {
@@ -198,6 +351,7 @@ def _emit_namespace(
                             "application/json": {
                                 "schema": {"$ref": "#/components/schema/Data"}
                             }
+                            | _emit_endpoint_response_examples(ctx.endpoint.examples)
                         },
                     }
                 },
@@ -236,10 +390,7 @@ def _emit_namespace(
 
     oa_components["schema"] = cast(
         object,
-        {
-            name: (value.asdict() if name != "Arguments" else value.asarguments())
-            for name, value in types.items()
-        },
+        {name: value.asdict() for name, value in types.items()},
     )
 
     path = f"{config.types_output}/common/{'/'.join(namespace.path)}.yaml"
@@ -348,6 +499,8 @@ def _emit_endpoint(
     ctx: EmitOpenAPIContext,
     namespace: builder.SpecNamespace,
     endpoint: builder.SpecEndpoint,
+    endpoint_examples: list[builder.SpecEndpointExample],
+    endpoint_guides: list[builder.SpecGuide],
 ) -> None:
     assert namespace.endpoint is not None
     assert namespace.path[0] == "api"
@@ -397,6 +550,23 @@ def _emit_endpoint(
         summary=f"{'/'.join(namespace.path[path_cutoff:])}",
         description=description,
         is_beta=namespace.endpoint.is_beta,
+        examples=[
+            EmitOpenAPIEndpointExample(
+                ref_name=f"ex_{i}",
+                summary=example.summary,
+                description=example.description,
+                arguments=example.arguments,
+                data=example.data,
+            )
+            for i, example in enumerate(endpoint_examples)
+        ],
+        guides=[
+            EmitOpenAPIGuide(
+                title=guide.title,
+                html_content=guide.html_content,
+            )
+            for guide in endpoint_guides
+        ],
     )
 
 
@@ -464,6 +634,10 @@ def open_api_type(
                 [open_api_type(ctx, p, config=config) for p in stype.parameters],
                 description="TupleType",
             )
+        if stype.defn_type.name == builder.BaseTypeName.s_readonly_array:
+            return OpenAPIArrayType(
+                open_api_type(ctx, stype.parameters[0], config=config)
+            )
 
         # TODO: generics are not supported by OpenAPI
         # map to Free-Form Object and add description

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/emit_open_api_util.py

@@ -43,6 +43,12 @@ class EmitOpenAPIServer:
     url: str
 
 
+@dataclass(kw_only=True)
+class EmitOpenAPIGuide:
+    title: str
+    html_content: str
+
+
 @dataclass
 class EmitOpenAPIGlobalContext:
     version: str
@@ -56,6 +62,15 @@ class EmitOpenAPIGlobalContext:
     paths: list[EmitOpenAPIPath] = field(default_factory=list)
 
 
+@dataclass(kw_only=True)
+class EmitOpenAPIEndpointExample:
+    ref_name: str
+    summary: str
+    description: str
+    arguments: dict[str, object]
+    data: dict[str, object]
+
+
 @dataclass
 class EmitOpenAPIEndpoint:
     method: str
@@ -63,6 +78,8 @@ class EmitOpenAPIEndpoint:
     summary: str
     description: str
     is_beta: bool
+    examples: list[EmitOpenAPIEndpointExample]
+    guides: list[EmitOpenAPIGuide]
 
 
 @dataclass

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/emit_python.py

@@ -29,7 +29,7 @@ ASYNC_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
     namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="AsyncBatchRequest"
 )
 QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
-    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedBatchRequest"
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedAsyncBatchRequest"
 )
 
 
@@ -819,6 +819,7 @@ base_name_map = {
     builder.BaseTypeName.s_opaque_key: "OpaqueKey",
     builder.BaseTypeName.s_string: "str",
     builder.BaseTypeName.s_tuple: "tuple",
+    builder.BaseTypeName.s_readonly_array: "tuple",
     builder.BaseTypeName.s_union: "typing.Union",
     builder.BaseTypeName.s_literal: "typing.Literal",
 }
@@ -827,6 +828,11 @@ base_name_map = {
 def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
     if isinstance(stype, builder.SpecTypeInstance):
         params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_readonly_array):
+            assert len(stype.parameters) == 1, "Read Only Array takes one parameter"
+            params = f"{params}, ..."
+
         return f"{refer_to(ctx, stype.defn_type)}[{params}]"
 
     if isinstance(stype, builder.SpecTypeLiteralWrapper):

{uncountablepythonsdk-0.0.21 → uncountablepythonsdk-0.0.23}/pkgs/type_spec/emit_typescript.py

@@ -394,6 +394,9 @@ def refer_to_impl(
         if stype.defn_type.name == builder.BaseTypeName.s_list:
             spec, multi = refer_to_impl(ctx, stype.parameters[0])
             return f"({spec})[]" if multi else f"{spec}[]", False
+        if stype.defn_type.name == builder.BaseTypeName.s_readonly_array:
+            spec, multi = refer_to_impl(ctx, stype.parameters[0])
+            return f"readonly ({spec})[]" if multi else f"readonly {spec}[]", False
         if stype.defn_type.name == builder.BaseTypeName.s_union:
             return f'({" | ".join([refer_to(ctx, p) for p in stype.parameters])})', False
         if stype.defn_type.name == builder.BaseTypeName.s_literal: