Skip to content

Client Resources

Resource namespaces mounted on Client and AsyncClient. Each section lists the sync and async classes and their response models.

Embeddings

client.embeddings — text embedding calls and batch jobs.

Embeddings

Embeddings(client)
Source code in dashscope/resources/embeddings.py
814
815
816
def __init__(self, client) -> None:
    self._client = client
    self.jobs = EmbeddingJobs(client)

jobs instance-attribute

jobs = EmbeddingJobs(client)

create

create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> EmbeddingResponse
create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[EmbeddingResponse, "APIResponse"]
Source code in dashscope/resources/embeddings.py
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
def create(
    self,
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[EmbeddingResponse, "APIResponse"]:
    body = _build_body(
        model=model,
        input=input,
        text_type=text_type,
        dimension=dimension,
        output_type=output_type,
        instruct=instruct,
        parameters=parameters,
    )
    resp = self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        parse_embedding_response(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncEmbeddings

AsyncEmbeddings(client)
Source code in dashscope/resources/embeddings.py
920
921
922
def __init__(self, client) -> None:
    self._client = client
    self.jobs = AsyncEmbeddingJobs(client)

jobs instance-attribute

jobs = AsyncEmbeddingJobs(client)

create async

create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> EmbeddingResponse
create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[EmbeddingResponse, "APIResponse"]
Source code in dashscope/resources/embeddings.py
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
async def create(
    self,
    *,
    model: str,
    input: Union[str, List[str]],
    text_type: Optional[str] = None,
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[EmbeddingResponse, "APIResponse"]:
    body = _build_body(
        model=model,
        input=input,
        text_type=text_type,
        dimension=dimension,
        output_type=output_type,
        instruct=instruct,
        parameters=parameters,
    )
    resp = await self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        parse_embedding_response(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

EmbeddingJobs

EmbeddingJobs(client)

Async batch embedding task facade over the Jobs infra.

Source code in dashscope/resources/embeddings.py
156
157
def __init__(self, client) -> None:
    self._jobs = Jobs(client, _BATCH_SERVICE, MODULE)

create

create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit a batch task over one file whose lines are the texts.

Singular, unlike asr.transcribe(file_urls=): this endpoint accepts exactly one file.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
def create(
    self,
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit a batch task over one file whose lines are the texts.

    Singular, unlike ``asr.transcribe(file_urls=)``: this endpoint
    accepts exactly one file.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    if not file_url:
        raise ValueError("file_url must not be empty")
    merged = dict(parameters or {})
    if text_type is not None:
        merged["text_type"] = text_type
    return self._jobs.create(
        model=model,
        input={"url": file_url},
        parameters=merged or None,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return self._jobs.fetch(
        task_id,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return self._jobs.cancel(
        task_id,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return self._jobs.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None
) -> Job
Source code in dashscope/resources/embeddings.py
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None,
) -> Job:
    return self._jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

AsyncEmbeddingJobs

AsyncEmbeddingJobs(client)
Source code in dashscope/resources/embeddings.py
485
486
def __init__(self, client) -> None:
    self._jobs = AsyncJobs(client, _BATCH_SERVICE, MODULE)

create async

create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit a batch task over one file whose lines are the texts.

Singular, unlike asr.transcribe(file_urls=): this endpoint accepts exactly one file.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
async def create(
    self,
    *,
    model: str,
    file_url: str,
    text_type: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit a batch task over one file whose lines are the texts.

    Singular, unlike ``asr.transcribe(file_urls=)``: this endpoint
    accepts exactly one file.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    if not file_url:
        raise ValueError("file_url must not be empty")
    merged = dict(parameters or {})
    if text_type is not None:
        merged["text_type"] = text_type
    return await self._jobs.create(
        model=model,
        input={"url": file_url},
        parameters=merged or None,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch async

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
async def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return await self._jobs.fetch(
        task_id,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel async

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
async def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return await self._jobs.cancel(
        task_id,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list async

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying call before any error check.

Source code in dashscope/resources/embeddings.py
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
async def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying call before any error check.
    """
    return await self._jobs.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait async

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[
        Callable[[float], Awaitable[None]]
    ] = None
) -> Job
Source code in dashscope/resources/embeddings.py
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
async def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Awaitable[None]]] = None,
) -> Job:
    return await self._jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

Embedding

Bases: BaseModel

One embedding vector; type says which modality produced it.

index class-attribute instance-attribute

index: int = Field(
    0, validation_alias=AliasChoices("index", "text_index")
)

type class-attribute instance-attribute

type: Optional[str] = None

embedding class-attribute instance-attribute

embedding: List[float] = []

EmbeddingResponse

Bases: ResponseBase

embeddings class-attribute instance-attribute

embeddings: List[Embedding] = []

usage class-attribute instance-attribute

usage: Optional[Usage] = None

Multimodal

client.multimodal — multimodal chat and embeddings.

Multimodal

Multimodal(client)
Source code in dashscope/resources/multimodal/__init__.py
23
24
25
def __init__(self, client) -> None:
    self.chat = MultimodalChat(client)
    self.embeddings = MultimodalEmbeddings(client)

chat instance-attribute

chat = MultimodalChat(client)

embeddings instance-attribute

embeddings = MultimodalEmbeddings(client)

AsyncMultimodal

AsyncMultimodal(client)
Source code in dashscope/resources/multimodal/__init__.py
29
30
31
def __init__(self, client) -> None:
    self.chat = AsyncMultimodalChat(client)
    self.embeddings = AsyncMultimodalEmbeddings(client)

chat instance-attribute

chat = AsyncMultimodalChat(client)

embeddings instance-attribute

embeddings = AsyncMultimodalEmbeddings(client)

MultimodalChat

MultimodalChat(client)
Source code in dashscope/resources/multimodal/chat.py
53
54
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[True],
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> ChatStream
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[False] = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> ChatCompletion
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[False] = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: bool = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[ChatCompletion, ChatStream, "APIResponse"]

Run one multimodal-generation chat call.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It is only available with stream=False: a streaming response body is never materialized, so there is nothing to hand back. Combining the two raises ValueError.

Source code in dashscope/resources/multimodal/chat.py
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
def create(
    self,
    *,
    model: str,
    messages: Optional[Union[str, List[MessageInput]]] = None,
    stream: bool = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[ChatCompletion, ChatStream, "APIResponse"]:
    """Run one multimodal-generation chat call.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It is only
    available with ``stream=False``: a streaming response body is never
    materialized, so there is nothing to hand back. Combining the two
    raises ``ValueError``.
    """
    built = _build_request(
        self._client,
        multimodal=True,
        model=model,
        messages=messages,
        stream=stream,
        tools=tools,
        temperature=temperature,
        top_p=top_p,
        max_tokens=max_tokens,
        stop=stop,
        seed=seed,
        repetition_penalty=repetition_penalty,
        presence_penalty=presence_penalty,
        enable_thinking=enable_thinking,
        response_format=response_format,
        top_k=top_k,
        tool_choice=tool_choice,
        n=n,
        logprobs=logprobs,
        top_logprobs=top_logprobs,
        thinking_budget=thinking_budget,
        enable_search=enable_search,
        search_options=search_options,
        parallel_tool_calls=parallel_tool_calls,
        incremental_output=incremental_output,
        parameters=parameters,
        extra_input=extra_input,
        api_key=api_key,
        workspace=workspace,
    )
    request, module, merge_incremental, server_cumulative = built
    return _send(
        self._client,
        request,
        stream=stream,
        module=module,
        merge_incremental=merge_incremental,
        server_cumulative=server_cumulative,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        raw=raw,
    )

AsyncMultimodalChat

AsyncMultimodalChat(client)
Source code in dashscope/resources/multimodal/chat.py
275
276
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[True],
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> AsyncChatStream
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[False] = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> ChatCompletion
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: Literal[False] = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    messages: Optional[
        Union[str, List[MessageInput]]
    ] = None,
    stream: bool = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[ChatCompletion, AsyncChatStream, "APIResponse"]

Run one multimodal-generation chat call.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It is only available with stream=False: a streaming response body is never materialized, so there is nothing to hand back. Combining the two raises ValueError.

Source code in dashscope/resources/multimodal/chat.py
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
async def create(
    self,
    *,
    model: str,
    messages: Optional[Union[str, List[MessageInput]]] = None,
    stream: bool = False,
    tools: Optional[List[Dict[str, Any]]] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Union[str, List[str], None] = None,
    seed: Optional[int] = None,
    repetition_penalty: Optional[float] = None,
    presence_penalty: Optional[float] = None,
    enable_thinking: Optional[bool] = None,
    response_format: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    tool_choice: Union[str, Dict[str, Any], None] = None,
    n: Optional[int] = None,
    logprobs: Optional[bool] = None,
    top_logprobs: Optional[int] = None,
    thinking_budget: Optional[int] = None,
    enable_search: Optional[bool] = None,
    search_options: Optional[Dict[str, Any]] = None,
    parallel_tool_calls: Optional[bool] = None,
    incremental_output: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[ChatCompletion, AsyncChatStream, "APIResponse"]:
    """Run one multimodal-generation chat call.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It is only
    available with ``stream=False``: a streaming response body is never
    materialized, so there is nothing to hand back. Combining the two
    raises ``ValueError``.
    """
    # The upload path is blocking (file post + getPolicy), so the whole
    # request build runs in a worker thread -- over a transport bridged
    # back to this loop, which is what lets it serve the policy fetch.
    built = await run_blocking(
        self._client,
        _build_request,
        multimodal=True,
        model=model,
        messages=messages,
        stream=stream,
        tools=tools,
        temperature=temperature,
        top_p=top_p,
        max_tokens=max_tokens,
        stop=stop,
        seed=seed,
        repetition_penalty=repetition_penalty,
        presence_penalty=presence_penalty,
        enable_thinking=enable_thinking,
        response_format=response_format,
        top_k=top_k,
        tool_choice=tool_choice,
        n=n,
        logprobs=logprobs,
        top_logprobs=top_logprobs,
        thinking_budget=thinking_budget,
        enable_search=enable_search,
        search_options=search_options,
        parallel_tool_calls=parallel_tool_calls,
        incremental_output=incremental_output,
        parameters=parameters,
        extra_input=extra_input,
        api_key=api_key,
        workspace=workspace,
    )
    request, module, merge_incremental, server_cumulative = built
    return await _asend(
        self._client,
        request,
        stream=stream,
        module=module,
        merge_incremental=merge_incremental,
        server_cumulative=server_cumulative,
        api_key=api_key,
        workspace=workspace,
        timeout=timeout,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        raw=raw,
    )

MultimodalEmbeddings

MultimodalEmbeddings(client)

Embed text, image, audio and video into one shared vector space.

Source code in dashscope/resources/multimodal/embeddings.py
120
121
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    input: Union[Dict[str, Any], EmbeddingItem, List[Any]],
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    fps: Optional[float] = None,
    instruct: Optional[str] = None,
    enable_fusion: Optional[bool] = None,
    res_level: Optional[int] = None,
    max_video_frames: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> EmbeddingResponse

Embed one item, or a list of them, into one vector space.

Each item sets exactly one of text / image / audio / video (plus an optional factor). fps, res_level (resolution tier 0-3) and max_video_frames apply to snapshot models only; anything this signature does not name goes in parameters. Local paths and file:// URIs upload to OSS first; oss:// inputs are resolved by the service without any extra opt-in.

Source code in dashscope/resources/multimodal/embeddings.py
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
def create(  # pylint: disable=too-many-arguments
    self,
    *,
    model: str,
    input: Union[Dict[str, Any], EmbeddingItem, List[Any]],
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    fps: Optional[float] = None,
    instruct: Optional[str] = None,
    enable_fusion: Optional[bool] = None,
    res_level: Optional[int] = None,
    max_video_frames: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> EmbeddingResponse:
    """Embed one item, or a list of them, into one vector space.

    Each item sets exactly one of ``text`` / ``image`` / ``audio`` /
    ``video`` (plus an optional ``factor``). ``fps``, ``res_level``
    (resolution tier 0-3) and ``max_video_frames`` apply to snapshot
    models only; anything this signature does not name goes in
    ``parameters``. Local paths and ``file://`` URIs upload to OSS
    first; ``oss://`` inputs are resolved by the service without any
    extra opt-in.
    """
    contents = _contents(input)
    upload_embedding_media(
        self._client,
        contents,
        model,
        api_key,
        workspace,
    )
    body = _build_body(
        model=model,
        contents=contents,
        dimension=dimension,
        output_type=output_type,
        fps=fps,
        instruct=instruct,
        enable_fusion=enable_fusion,
        res_level=res_level,
        max_video_frames=max_video_frames,
        parameters=parameters,
    )
    response = self._client.transport.request(
        "POST",
        _PATH,
        json=body,
        headers=_OSS_RESOLVE_HEADERS if _uses_oss(contents) else None,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        parse_embedding_response(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

AsyncMultimodalEmbeddings

AsyncMultimodalEmbeddings(client)
Source code in dashscope/resources/multimodal/embeddings.py
202
203
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    input: Union[Dict[str, Any], EmbeddingItem, List[Any]],
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    fps: Optional[float] = None,
    instruct: Optional[str] = None,
    enable_fusion: Optional[bool] = None,
    res_level: Optional[int] = None,
    max_video_frames: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> EmbeddingResponse
Source code in dashscope/resources/multimodal/embeddings.py
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
async def create(  # pylint: disable=too-many-arguments
    self,
    *,
    model: str,
    input: Union[Dict[str, Any], EmbeddingItem, List[Any]],
    dimension: Optional[int] = None,
    output_type: Optional[str] = None,
    fps: Optional[float] = None,
    instruct: Optional[str] = None,
    enable_fusion: Optional[bool] = None,
    res_level: Optional[int] = None,
    max_video_frames: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> EmbeddingResponse:
    contents = _contents(input)
    # The upload path is blocking (file post + getPolicy), so it runs in
    # a worker thread -- over a transport bridged back to this loop,
    # which is what lets it serve the policy fetch.
    await run_blocking(
        self._client,
        upload_embedding_media,
        contents,
        model,
        api_key,
        workspace,
    )
    body = _build_body(
        model=model,
        contents=contents,
        dimension=dimension,
        output_type=output_type,
        fps=fps,
        instruct=instruct,
        enable_fusion=enable_fusion,
        res_level=res_level,
        max_video_frames=max_video_frames,
        parameters=parameters,
    )
    response = await self._client.transport.request(
        "POST",
        _PATH,
        json=body,
        headers=_OSS_RESOLVE_HEADERS if _uses_oss(contents) else None,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        parse_embedding_response(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

EmbeddingItem

Bases: BaseModel

One multimodal input element; exactly one modality field is set.

text class-attribute instance-attribute

text: Optional[str] = None

image class-attribute instance-attribute

image: Optional[str] = None

audio class-attribute instance-attribute

audio: Optional[str] = None

video class-attribute instance-attribute

video: Optional[str] = None

factor class-attribute instance-attribute

factor: Optional[float] = None

Rerank

client.rerank — document reranking.

Rerank

Rerank(client)
Source code in dashscope/resources/rerank.py
122
123
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> RerankResponse
create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[RerankResponse, "APIResponse"]

Rerank documents against query.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/rerank.py
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
def create(
    self,
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[RerankResponse, "APIResponse"]:
    """Rerank ``documents`` against ``query``.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_body(
        model=model,
        query=query,
        documents=documents,
        top_n=top_n,
        return_documents=return_documents,
        instruct=instruct,
        parameters=parameters,
    )
    resp = self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncRerank

AsyncRerank(client)
Source code in dashscope/resources/rerank.py
233
234
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> RerankResponse
create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[RerankResponse, "APIResponse"]

Rerank documents against query.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/rerank.py
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
async def create(
    self,
    *,
    model: str,
    query: str,
    documents: List[str],
    top_n: Optional[int] = None,
    return_documents: Optional[bool] = None,
    instruct: Optional[str] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[RerankResponse, "APIResponse"]:
    """Rerank ``documents`` against ``query``.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_body(
        model=model,
        query=query,
        documents=documents,
        top_n=top_n,
        return_documents=return_documents,
        instruct=instruct,
        parameters=parameters,
    )
    resp = await self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

RerankResponse

Bases: ResponseBase

results class-attribute instance-attribute

results: List[RerankResult] = []

usage class-attribute instance-attribute

usage: Optional[Usage] = None

RerankResult

Bases: BaseModel

index instance-attribute

index: int

relevance_score instance-attribute

relevance_score: float

document class-attribute instance-attribute

document: Optional[RerankDocument] = None

RerankDocument

Bases: BaseModel

text class-attribute instance-attribute

text: Optional[str] = None

Images

client.images — image generation jobs.

Images

Images(client)

Text-to-image: one-shot generate + jobs.create/fetch/wait.

Source code in dashscope/resources/images.py
714
715
716
def __init__(self, client) -> None:
    self._client = client
    self.jobs = ImageJobs(client)

jobs instance-attribute

jobs = ImageJobs(client)

generate

generate(
    *,
    model: str,
    prompt: str,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Job

Submit and wait; returns the finished Job (image_urls).

timeout is the wait budget — the same timeout as jobs.wait. submit_timeout caps only the submit request.

Multimodal-protocol models (wan2.6-t2i / wan2.6-image) answer synchronously: the call is a single request capped by submit_timeout and the polling knobs do not apply. image_urls carries reference images for wan2.6-image.

Source code in dashscope/resources/images.py
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
def generate(
    self,
    *,
    model: str,
    prompt: str,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Job:
    """Submit and wait; returns the finished Job (``image_urls``).

    ``timeout`` is the wait budget — the same ``timeout`` as
    ``jobs.wait``. ``submit_timeout`` caps only the submit request.

    Multimodal-protocol models (wan2.6-t2i / wan2.6-image) answer
    synchronously: the call is a single request capped by
    ``submit_timeout`` and the polling knobs do not apply.
    ``image_urls`` carries reference images for wan2.6-image.
    """
    options = request_options(
        extra_headers,
        extra_query,
        extra_body,
        max_retries=max_retries,
    )
    if _uses_multimodal_protocol(model):
        image_urls, extra_input, has_upload = _upload_inputs(
            self._client,
            model,
            image_urls,
            extra_input,
            api_key,
            workspace,
        )
        response = self._client.transport.request(
            "POST",
            f"/services/{MULTIMODAL_SERVICE}",
            json=_build_multimodal_body(
                model,
                prompt,
                negative_prompt,
                n,
                size,
                image_urls,
                extra_input,
                parameters,
                seed=seed,
                style=style,
                prompt_extend=prompt_extend,
                watermark=watermark,
                function=function,
            ),
            headers=OSS_RESOLVE_HEADERS if has_upload else None,
            timeout=submit_timeout,
            sdk_module=MODULE,
            api_key=api_key,
            workspace=workspace,
            options=options,
        )
        check_response(
            response,
            raise_on_error=self._client.raise_on_error,
        )
        return with_headers(
            _parse_sync_job(
                response_json(response),
                strict=self._client.config.strict_validation,
                response=response,
            ),
            response,
        )
    job = self.jobs.create(
        model=model,
        prompt=prompt,
        negative_prompt=negative_prompt,
        n=n,
        size=size,
        image_urls=image_urls,
        extra_input=extra_input,
        function=function,
        seed=seed,
        style=style,
        prompt_extend=prompt_extend,
        watermark=watermark,
        parameters=parameters,
        timeout=submit_timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )
    return self.jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )

AsyncImages

AsyncImages(client)

Async counterpart of :class:Images.

Source code in dashscope/resources/images.py
1249
1250
1251
def __init__(self, client) -> None:
    self._client = client
    self.jobs = AsyncImageJobs(client)

jobs instance-attribute

jobs = AsyncImageJobs(client)

generate async

generate(
    *,
    model: str,
    prompt: str,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Job

See :meth:Images.generate.

Source code in dashscope/resources/images.py
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
async def generate(
    self,
    *,
    model: str,
    prompt: str,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Job:
    """See :meth:`Images.generate`."""
    options = request_options(
        extra_headers,
        extra_query,
        extra_body,
        max_retries=max_retries,
    )
    if _uses_multimodal_protocol(model):
        # The upload path is blocking (file post + getPolicy), so it runs
        # in a worker thread -- over a transport bridged back to this
        # loop, which is what lets it serve the policy fetch.
        image_urls, extra_input, has_upload = await run_blocking(
            self._client,
            _upload_inputs,
            model,
            image_urls,
            extra_input,
            api_key,
            workspace,
        )
        response = await self._client.transport.request(
            "POST",
            f"/services/{MULTIMODAL_SERVICE}",
            json=_build_multimodal_body(
                model,
                prompt,
                negative_prompt,
                n,
                size,
                image_urls,
                extra_input,
                parameters,
                seed=seed,
                style=style,
                prompt_extend=prompt_extend,
                watermark=watermark,
                function=function,
            ),
            headers=OSS_RESOLVE_HEADERS if has_upload else None,
            timeout=submit_timeout,
            sdk_module=MODULE,
            api_key=api_key,
            workspace=workspace,
            options=options,
        )
        check_response(
            response,
            raise_on_error=self._client.raise_on_error,
        )
        return with_headers(
            _parse_sync_job(
                response_json(response),
                strict=self._client.config.strict_validation,
                response=response,
            ),
            response,
        )
    job = await self.jobs.create(
        model=model,
        prompt=prompt,
        negative_prompt=negative_prompt,
        n=n,
        size=size,
        image_urls=image_urls,
        extra_input=extra_input,
        function=function,
        seed=seed,
        style=style,
        prompt_extend=prompt_extend,
        watermark=watermark,
        parameters=parameters,
        timeout=submit_timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )
    return await self.jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )

ImageJobs

ImageJobs(client)

Async task facade: create/fetch/wait over the image services.

create submits legacy models to the text2image endpoint and multimodal-protocol models to the image-generation task endpoint; fetch / wait poll /tasks/{task_id} either way.

Source code in dashscope/resources/images.py
315
316
317
318
def __init__(self, client) -> None:
    self._client = client
    self._synthesis = Jobs(client, SERVICE, MODULE)
    self._generation = Jobs(client, TASK_SERVICE, MODULE)

create

create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit an image task; returns a PENDING/RUNNING Job.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying submit call before any error check.

Source code in dashscope/resources/images.py
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
def create(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit an image task; returns a PENDING/RUNNING Job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying submit call before any error check.
    """
    image_urls, extra_input, has_upload = _upload_inputs(
        self._client,
        model,
        image_urls,
        extra_input,
        api_key,
        workspace,
    )
    resolve = OSS_RESOLVE_HEADERS if has_upload else None
    if _uses_multimodal_protocol(model):
        return self._generation.create(
            model=model,
            input=_build_multimodal_input(
                prompt,
                image_urls,
                extra_input,
                function,
            ),
            parameters=_build_multimodal_parameters(
                negative_prompt,
                n,
                size,
                parameters,
                seed=seed,
                style=style,
                prompt_extend=prompt_extend,
                watermark=watermark,
            ),
            headers=resolve,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
            raw=raw,
        )
    return self._synthesis.create(
        model=model,
        input=_build_input(prompt, negative_prompt, extra_input, function),
        parameters=_build_parameters(
            n,
            size,
            parameters,
            seed=seed,
            style=style,
            prompt_extend=prompt_extend,
            watermark=watermark,
        ),
        headers=resolve,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one image task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying fetch call before any error check.

Source code in dashscope/resources/images.py
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one image task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying fetch call before any error check.
    """
    return self._synthesis.fetch(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying cancel call before any error check.

Source code in dashscope/resources/images.py
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying cancel call before any error check.
    """
    return self._synthesis.cancel(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying list call before any error check.

Source code in dashscope/resources/images.py
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying list call before any error check.
    """
    return self._synthesis.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None
) -> Job
Source code in dashscope/resources/images.py
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None,
) -> Job:
    return self._synthesis.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

AsyncImageJobs

AsyncImageJobs(client)

Async counterpart of :class:ImageJobs.

Source code in dashscope/resources/images.py
846
847
848
849
def __init__(self, client) -> None:
    self._client = client
    self._synthesis = AsyncJobs(client, SERVICE, MODULE)
    self._generation = AsyncJobs(client, TASK_SERVICE, MODULE)

create async

create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit an image task; returns a PENDING/RUNNING Job.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying submit call before any error check.

Source code in dashscope/resources/images.py
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
async def create(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    negative_prompt: Optional[str] = None,
    n: Optional[int] = None,
    size: Optional[str] = None,
    image_urls: Optional[List[str]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    style: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit an image task; returns a PENDING/RUNNING Job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying submit call before any error check.
    """
    # The upload path is blocking (file post + getPolicy), so it runs in
    # a worker thread -- over a transport bridged back to this loop,
    # which is what lets it serve the policy fetch.
    image_urls, extra_input, has_upload = await run_blocking(
        self._client,
        _upload_inputs,
        model,
        image_urls,
        extra_input,
        api_key,
        workspace,
    )
    resolve = OSS_RESOLVE_HEADERS if has_upload else None
    if _uses_multimodal_protocol(model):
        return await self._generation.create(
            model=model,
            input=_build_multimodal_input(
                prompt,
                image_urls,
                extra_input,
                function,
            ),
            parameters=_build_multimodal_parameters(
                negative_prompt,
                n,
                size,
                parameters,
                seed=seed,
                style=style,
                prompt_extend=prompt_extend,
                watermark=watermark,
            ),
            headers=resolve,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
            raw=raw,
        )
    return await self._synthesis.create(
        model=model,
        input=_build_input(prompt, negative_prompt, extra_input, function),
        parameters=_build_parameters(
            n,
            size,
            parameters,
            seed=seed,
            style=style,
            prompt_extend=prompt_extend,
            watermark=watermark,
        ),
        headers=resolve,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch async

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one image task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying fetch call before any error check.

Source code in dashscope/resources/images.py
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
async def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one image task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying fetch call before any error check.
    """
    return await self._synthesis.fetch(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel async

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying cancel call before any error check.

Source code in dashscope/resources/images.py
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
async def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying cancel call before any error check.
    """
    return await self._synthesis.cancel(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list async

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying list call before any error check.

Source code in dashscope/resources/images.py
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
async def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying list call before any error check.
    """
    return await self._synthesis.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait async

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[
        Callable[[float], Awaitable[None]]
    ] = None
) -> Job
Source code in dashscope/resources/images.py
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
async def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Awaitable[None]]] = None,
) -> Job:
    return await self._synthesis.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

Videos

client.videos — video generation jobs.

Videos

Videos(client)

Text/image-to-video: one-shot generate + jobs.create/fetch/wait.

Source code in dashscope/resources/videos.py
570
571
572
def __init__(self, client) -> None:
    self._client = client
    self.jobs = VideoJobs(client)

jobs instance-attribute

jobs = VideoJobs(client)

generate

generate(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Job

Submit and wait; returns the finished Job (output.video_url).

timeout is the wait budget — the same timeout as jobs.wait. submit_timeout caps only the submit request.

Media-protocol models (wan2.7-i2v) require media — one item per asset type (first_frame / last_frame / driving_audio / first_clip); image_url still works as a first-frame shorthand. Older models take image_url (wire: img_url) or a bare prompt.

Source code in dashscope/resources/videos.py
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
def generate(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Job:
    """Submit and wait; returns the finished Job (output.video_url).

    ``timeout`` is the wait budget — the same ``timeout`` as
    ``jobs.wait``. ``submit_timeout`` caps only the submit request.

    Media-protocol models (wan2.7-i2v) require ``media`` — one
    item per asset type (``first_frame`` / ``last_frame`` /
    ``driving_audio`` / ``first_clip``); ``image_url`` still works
    as a first-frame shorthand. Older models take ``image_url``
    (wire: ``img_url``) or a bare ``prompt``.
    """
    job = self.jobs.create(
        model=model,
        prompt=prompt,
        image_url=image_url,
        media=media,
        extra_input=extra_input,
        function=function,
        seed=seed,
        size=size,
        duration=duration,
        resolution=resolution,
        ratio=ratio,
        prompt_extend=prompt_extend,
        watermark=watermark,
        parameters=parameters,
        timeout=submit_timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )
    return self.jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )

AsyncVideos

AsyncVideos(client)
Source code in dashscope/resources/videos.py
1033
1034
1035
def __init__(self, client) -> None:
    self._client = client
    self.jobs = AsyncVideoJobs(client)

jobs instance-attribute

jobs = AsyncVideoJobs(client)

generate async

generate(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Job

See :meth:Videos.generate.

Source code in dashscope/resources/videos.py
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
async def generate(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    submit_timeout: Optional[float] = None,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Job:
    """See :meth:`Videos.generate`."""
    job = await self.jobs.create(
        model=model,
        prompt=prompt,
        image_url=image_url,
        media=media,
        extra_input=extra_input,
        function=function,
        seed=seed,
        size=size,
        duration=duration,
        resolution=resolution,
        ratio=ratio,
        prompt_extend=prompt_extend,
        watermark=watermark,
        parameters=parameters,
        timeout=submit_timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )
    return await self.jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
    )

VideoJobs

VideoJobs(client)

Async task facade: create/fetch/wait over the video service.

Source code in dashscope/resources/videos.py
190
191
192
def __init__(self, client) -> None:
    self._client = client
    self._jobs = Jobs(client, SERVICE, MODULE)

create

create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit a video task; returns a PENDING/RUNNING Job.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying submit call before any error check.

Source code in dashscope/resources/videos.py
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
def create(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit a video task; returns a PENDING/RUNNING Job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying submit call before any error check.
    """
    image_url, media, extra_input, has_upload = _upload_inputs(
        self._client,
        model,
        image_url,
        media,
        extra_input,
        api_key,
        workspace,
    )
    return self._jobs.create(
        model=model,
        input=_build_input(
            model,
            prompt,
            image_url,
            media,
            extra_input,
            function,
        ),
        parameters=_build_parameters(
            seed=seed,
            size=size,
            duration=duration,
            resolution=resolution,
            ratio=ratio,
            prompt_extend=prompt_extend,
            watermark=watermark,
            parameters=parameters,
        ),
        headers=OSS_RESOLVE_HEADERS if has_upload else None,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one video task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying fetch call before any error check.

Source code in dashscope/resources/videos.py
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one video task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying fetch call before any error check.
    """
    return self._jobs.fetch(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying cancel call before any error check.

Source code in dashscope/resources/videos.py
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying cancel call before any error check.
    """
    return self._jobs.cancel(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying list call before any error check.

Source code in dashscope/resources/videos.py
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying list call before any error check.
    """
    return self._jobs.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None
) -> Job
Source code in dashscope/resources/videos.py
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None,
) -> Job:
    return self._jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

AsyncVideoJobs

AsyncVideoJobs(client)
Source code in dashscope/resources/videos.py
651
652
653
def __init__(self, client) -> None:
    self._client = client
    self._jobs = AsyncJobs(client, SERVICE, MODULE)

create async

create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Submit a video task; returns a PENDING/RUNNING Job.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying submit call before any error check.

Source code in dashscope/resources/videos.py
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
async def create(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    image_url: Optional[str] = None,
    media: Optional[List[Dict[str, Any]]] = None,
    extra_input: Optional[Dict[str, Any]] = None,
    function: Optional[str] = None,
    seed: Optional[int] = None,
    size: Optional[str] = None,
    duration: Optional[int] = None,
    resolution: Optional[str] = None,
    ratio: Optional[str] = None,
    prompt_extend: Optional[bool] = None,
    watermark: Optional[bool] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Submit a video task; returns a PENDING/RUNNING Job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying submit call before any error check.
    """
    # The upload path is blocking (file post + getPolicy), so it runs in
    # a worker thread -- over a transport bridged back to this loop,
    # which is what lets it serve the policy fetch.
    image_url, media, extra_input, has_upload = await run_blocking(
        self._client,
        _upload_inputs,
        model,
        image_url,
        media,
        extra_input,
        api_key,
        workspace,
    )
    return await self._jobs.create(
        model=model,
        input=_build_input(
            model,
            prompt,
            image_url,
            media,
            extra_input,
            function,
        ),
        parameters=_build_parameters(
            seed=seed,
            size=size,
            duration=duration,
            resolution=resolution,
            ratio=ratio,
            prompt_extend=prompt_extend,
            watermark=watermark,
            parameters=parameters,
        ),
        headers=OSS_RESOLVE_HEADERS if has_upload else None,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

fetch async

fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
fetch(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Fetch one video task snapshot.

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying fetch call before any error check.

Source code in dashscope/resources/videos.py
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
async def fetch(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Fetch one video task snapshot.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying fetch call before any error check.
    """
    return await self._jobs.fetch(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

cancel async

cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Job
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Job, "APIResponse"]

Cancel a PENDING task (POST /tasks/{task_id}/cancel).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying cancel call before any error check.

Source code in dashscope/resources/videos.py
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
async def cancel(
    self,
    task_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Job, "APIResponse"]:
    """Cancel a PENDING task (``POST /tasks/{task_id}/cancel``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying cancel call before any error check.
    """
    return await self._jobs.cancel(
        task_id,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

list async

list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobList
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobList, "APIResponse"]

List async tasks (GET /tasks).

raw=True returns the :class:~dashscope.transport.APIResponse of the underlying list call before any error check.

Source code in dashscope/resources/videos.py
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
async def list(  # pylint: disable=redefined-builtin
    self,
    *,
    start_time: Optional[str] = None,
    end_time: Optional[str] = None,
    model_name: Optional[str] = None,
    api_key_id: Optional[str] = None,
    region: Optional[str] = None,
    status: Optional[str] = None,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobList, "APIResponse"]:
    """List async tasks (``GET /tasks``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    of the underlying list call before any error check.
    """
    return await self._jobs.list(
        start_time=start_time,
        end_time=end_time,
        model_name=model_name,
        api_key_id=api_key_id,
        region=region,
        status=status,
        page_no=page_no,
        page_size=page_size,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        raw=raw,
    )

wait async

wait(
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[
        Callable[[float], Awaitable[None]]
    ] = None
) -> Job
Source code in dashscope/resources/videos.py
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
async def wait(
    self,
    job: Union[Job, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Awaitable[None]]] = None,
) -> Job:
    return await self._jobs.wait(
        job,
        poll_interval=poll_interval,
        max_interval=max_interval,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        extra_headers=extra_headers,
        extra_query=extra_query,
        extra_body=extra_body,
        max_retries=max_retries,
        _sleep=_sleep,
    )

Files

client.files — file upload, listing and deletion.

Files

Files(client)
Source code in dashscope/resources/files.py
295
296
def __init__(self, client) -> None:
    self._client = client

upload

upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> File
upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[File, "APIResponse"]

Upload a JSONL file for fine-tuning.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/files.py
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
def upload(
    self,
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[File, "APIResponse"]:
    """Upload a JSONL file for fine-tuning.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    _validate_upload(file_path, purpose)
    data, files = _upload_form(file_path, description)
    resp = self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        data=data,
        files=files,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_upload(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FileList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FileList, "APIResponse"]

List uploaded files, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. A raw response carries no pagination callback -- use FileList.iter_pages() on the parsed result to cross pages.

Source code in dashscope/resources/files.py
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
def list(  # pylint: disable=redefined-builtin
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FileList, "APIResponse"]:
    """List uploaded files, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. A raw response
    carries no pagination callback -- use ``FileList.iter_pages()`` on the
    parsed result to cross pages.
    """
    resp = self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    result = _parse_list(
        resp.json(),
        strict=self._client.config.strict_validation,
        response=resp.http_response,
    )
    result.bind_pagination(
        lambda next_no, next_size: self.list(
            page_no=next_no,
            page_size=next_size,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        ),
        requested_page_no=page_no,
        requested_page_size=page_size,
    )
    return with_headers(result, resp.http_response)

get

get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> File
get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[File, "APIResponse"]

Fetch one uploaded file's metadata.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It also skips the NotFoundError refinement documented on :func:_check_by_id_response: a missing file comes back as the gateway's own 400 body rather than raising.

Source code in dashscope/resources/files.py
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
def get(
    self,
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[File, "APIResponse"]:
    """Fetch one uploaded file's metadata.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It also skips the
    ``NotFoundError`` refinement documented on
    :func:`_check_by_id_response`: a missing file comes back as the
    gateway's own 400 body rather than raising.
    """
    _require_file_id(file_id)
    resp = self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{file_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    _check_by_id_response(
        resp.http_response,
        raise_on_error=self._client.raise_on_error,
    )
    return with_headers(
        _parse_file(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete

delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DeletionStatus
delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DeletionStatus, "APIResponse"]

Delete one uploaded file.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It also skips the NotFoundError refinement documented on :func:_check_by_id_response: deleting a file that is already gone comes back as the gateway's own 400 body rather than raising.

Source code in dashscope/resources/files.py
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
def delete(
    self,
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DeletionStatus, "APIResponse"]:
    """Delete one uploaded file.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It also skips the
    ``NotFoundError`` refinement documented on
    :func:`_check_by_id_response`: deleting a file that is already gone
    comes back as the gateway's own 400 body rather than raising.
    """
    _require_file_id(file_id)
    resp = self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{file_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    _check_by_id_response(
        resp.http_response,
        raise_on_error=self._client.raise_on_error,
    )
    return with_headers(
        _parse_delete(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncFiles

AsyncFiles(client)
Source code in dashscope/resources/files.py
655
656
def __init__(self, client) -> None:
    self._client = client

upload async

upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> File
upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
upload(
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[File, "APIResponse"]

Upload a JSONL file for fine-tuning.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/files.py
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
async def upload(
    self,
    *,
    file_path: str,
    purpose: str = "fine-tune",
    description: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[File, "APIResponse"]:
    """Upload a JSONL file for fine-tuning.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    _validate_upload(file_path, purpose)
    data, files = _upload_form(file_path, description)
    resp = await self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        data=data,
        files=files,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_upload(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list async

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FileList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FileList, "APIResponse"]

List uploaded files, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. A raw response carries no pagination callback -- use FileList.iter_pages() on the parsed result to cross pages.

Source code in dashscope/resources/files.py
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
async def list(  # pylint: disable=redefined-builtin
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FileList, "APIResponse"]:
    """List uploaded files, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. A raw response
    carries no pagination callback -- use ``FileList.iter_pages()`` on the
    parsed result to cross pages.
    """
    resp = await self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    result = _parse_list(
        resp.json(),
        strict=self._client.config.strict_validation,
        response=resp.http_response,
    )
    result.bind_pagination(
        lambda next_no, next_size: self.list(
            page_no=next_no,
            page_size=next_size,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        ),
        requested_page_no=page_no,
        requested_page_size=page_size,
    )
    return with_headers(result, resp.http_response)

get async

get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> File
get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[File, "APIResponse"]

Fetch one uploaded file's metadata.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It also skips the NotFoundError refinement documented on :func:_check_by_id_response: a missing file comes back as the gateway's own 400 body rather than raising.

Source code in dashscope/resources/files.py
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
async def get(
    self,
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[File, "APIResponse"]:
    """Fetch one uploaded file's metadata.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It also skips the
    ``NotFoundError`` refinement documented on
    :func:`_check_by_id_response`: a missing file comes back as the
    gateway's own 400 body rather than raising.
    """
    _require_file_id(file_id)
    resp = await self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{file_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    _check_by_id_response(
        resp.http_response,
        raise_on_error=self._client.raise_on_error,
    )
    return with_headers(
        _parse_file(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete async

delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DeletionStatus
delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DeletionStatus, "APIResponse"]

Delete one uploaded file.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It also skips the NotFoundError refinement documented on :func:_check_by_id_response: deleting a file that is already gone comes back as the gateway's own 400 body rather than raising.

Source code in dashscope/resources/files.py
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
async def delete(
    self,
    file_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DeletionStatus, "APIResponse"]:
    """Delete one uploaded file.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It also skips the
    ``NotFoundError`` refinement documented on
    :func:`_check_by_id_response`: deleting a file that is already gone
    comes back as the gateway's own 400 body rather than raising.
    """
    _require_file_id(file_id)
    resp = await self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{file_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    _check_by_id_response(
        resp.http_response,
        raise_on_error=self._client.raise_on_error,
    )
    return with_headers(
        _parse_delete(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

File

Bases: ResponseBase

One uploaded file.

Returned on its own by upload / get and nested in FileList.files; both roles share one shape. The envelope is filled in on the standalone result and stays empty on the nested copies, because the server reports it once per response rather than once per item.

file_id class-attribute instance-attribute

file_id: Optional[str] = None

name class-attribute instance-attribute

name: Optional[str] = None

purpose class-attribute instance-attribute

purpose: Optional[str] = None

size class-attribute instance-attribute

size: Optional[int] = None

uploaded_at class-attribute instance-attribute

uploaded_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "uploaded_at", "upload_time"
    ),
)

FileList

Bases: BasePage[File]

One page of files, from files.list.

Pagination fields come from :class:~dashscope.types.pagination.BasePage; iterate the page directly or cross pages with iter_pages() / next_page().

files class-attribute instance-attribute

files: List[File] = []

items property

items: List[File]

DeletionStatus

Bases: ResponseBase

deleted class-attribute instance-attribute

deleted: bool = False

Models

client.models — the model catalog.

Models

Models(client)
Source code in dashscope/resources/models.py
147
148
def __init__(self, client) -> None:
    self._client = client

list

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> ModelList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[ModelList, "APIResponse"]

List models; provider filters client-side per page.

The server has no provider filter, so total_count is always the pre-filter total of the whole catalog, not of the filtered models slice. Pagination therefore walks the unfiltered catalog: has_next_page() / iter_pages() follow total_count, and the provider filter is applied to each fetched page independently.

raw=True returns the :class:~dashscope.transport.APIResponse instead of a ModelList, before any error check, so callers can read the raw response (status, headers, elapsed) or re-parse it. Note that resp.parse(ModelList) is the generic envelope mapping and does not replay this method's own reshaping: a page delivered as a bare list, or one whose total the gateway omitted, parses through it as an empty catalog. Use resp.json() and _parse_list when the raw path has to agree with this one.

Source code in dashscope/resources/models.py
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[ModelList, "APIResponse"]:
    """List models; ``provider`` filters client-side per page.

    The server has no provider filter, so ``total_count`` is always
    the pre-filter total of the whole catalog, not of the filtered
    ``models`` slice. Pagination therefore walks the unfiltered catalog:
    ``has_next_page()`` / ``iter_pages()`` follow ``total_count``, and the
    ``provider`` filter is applied to each fetched page independently.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    instead of a ``ModelList``, before any error check, so callers can
    read the raw response (status, headers, ``elapsed``) or re-parse it.
    Note that ``resp.parse(ModelList)`` is the generic envelope mapping
    and does not replay this method's own reshaping: a page delivered as
    a bare list, or one whose ``total`` the gateway omitted, parses
    through it as an empty catalog. Use ``resp.json()`` and
    ``_parse_list`` when the raw path has to agree with this one.
    """
    resp = self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    result = _parse_list(
        resp.json(),
        strict=self._client.config.strict_validation,
        response=resp.http_response,
    )
    if provider:
        result.models = [
            m for m in result.models if _match_provider(m, provider)
        ]
    result.bind_pagination(
        lambda next_no, next_size: self.list(
            page_no=next_no,
            page_size=next_size,
            provider=provider,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        ),
        requested_page_no=page_no,
        requested_page_size=page_size,
    )
    return with_headers(result, resp.http_response)

get

get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Model
get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Model, "APIResponse"]
Source code in dashscope/resources/models.py
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
def get(
    self,
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Model, "APIResponse"]:
    # Server filters by model name via query params.
    resp = self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"model": model, "page_no": 1, "page_size": 1},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    body = resp.json()
    models = _parse_get_models(body)
    if not models:
        if self._client.raise_on_error:
            raise error_from_business_code(
                message=f"Model '{model}' not found",
                code=ErrorCode.MODEL_NOT_EXIST.value,
                body=body,
                headers=resp.http_response.headers,
            )
        return with_headers(
            parse_model(
                Model,
                response_envelope(body),
                strict=self._client.config.strict_validation,
                response=resp.http_response,
            ),
            resp.http_response,
        )
    return with_headers(
        parse_model(
            Model,
            # Dict merge, not ``**`` twice: a wire entry carrying an
            # envelope key of its own would otherwise raise a
            # duplicate-keyword TypeError instead of being parsed.
            {**models[0], **response_envelope(body)},
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncModels

AsyncModels(client)
Source code in dashscope/resources/models.py
363
364
def __init__(self, client) -> None:
    self._client = client

list async

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> ModelList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[ModelList, "APIResponse"]
Source code in dashscope/resources/models.py
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
async def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    provider: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[ModelList, "APIResponse"]:
    resp = await self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    result = _parse_list(
        resp.json(),
        strict=self._client.config.strict_validation,
        response=resp.http_response,
    )
    if provider:
        result.models = [
            m for m in result.models if _match_provider(m, provider)
        ]
    result.bind_pagination(
        lambda next_no, next_size: self.list(
            page_no=next_no,
            page_size=next_size,
            provider=provider,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        ),
        requested_page_no=page_no,
        requested_page_size=page_size,
    )
    return with_headers(result, resp.http_response)

get async

get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Model
get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Model, "APIResponse"]
Source code in dashscope/resources/models.py
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
async def get(
    self,
    model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Model, "APIResponse"]:
    # Server filters by model name via query params.
    resp = await self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"model": model, "page_no": 1, "page_size": 1},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    body = resp.json()
    models = _parse_get_models(body)
    if not models:
        if self._client.raise_on_error:
            raise error_from_business_code(
                message=f"Model '{model}' not found",
                code=ErrorCode.MODEL_NOT_EXIST.value,
                body=body,
                headers=resp.http_response.headers,
            )
        return with_headers(
            parse_model(
                Model,
                response_envelope(body),
                strict=self._client.config.strict_validation,
                response=resp.http_response,
            ),
            resp.http_response,
        )
    return with_headers(
        parse_model(
            Model,
            # Dict merge, not ``**`` twice: a wire entry carrying an
            # envelope key of its own would otherwise raise a
            # duplicate-keyword TypeError instead of being parsed.
            {**models[0], **response_envelope(body)},
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

Model

Bases: ResponseBase

One model entry.

Returned on its own by get and nested in ModelList.models; both roles share one shape. The envelope is filled in on the standalone result and stays empty on the nested copies, because the server reports it once per response rather than once per item.

model class-attribute instance-attribute

model: Optional[str] = None

source class-attribute instance-attribute

source: Optional[str] = None

provider class-attribute instance-attribute

provider: Optional[str] = None

open_source class-attribute instance-attribute

open_source: Optional[bool] = Field(
    None,
    validation_alias=AliasChoices(
        "open_source", "opensource"
    ),
)

ModelList

Bases: BasePage[Model]

One page of the model catalog, from models.list.

page_no / page_size / total_count come from :class:~dashscope.types.pagination.BasePage; iterate the page directly (for m in page) or cross pages with iter_pages() / next_page().

models class-attribute instance-attribute

models: List[Model] = []

items property

items: List[Model]

Fine-tunes

client.fine_tunes — fine-tuning jobs, logs and events.

FineTunes

FineTunes(client)
Source code in dashscope/resources/fine_tunes.py
319
320
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTune
create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTune, "APIResponse"]

Create a fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
def create(
    self,
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTune, "APIResponse"]:
    """Create a fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_create_body(
        model,
        training_file_ids,
        validation_file_ids,
        mode,
        hyper_parameters,
        finetuned_model,
    )
    resp = self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_job(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

get

get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTune
get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTune, "APIResponse"]

Fetch one fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
def get(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTune, "APIResponse"]:
    """Fetch one fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_job(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTuneList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTuneList, "APIResponse"]

List fine-tune jobs, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTuneList, "APIResponse"]:
    """List fine-tune jobs, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_list(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

cancel

cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Cancel a running fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
def cancel(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Cancel a running fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "POST",
        f"{_BASE_PATH}/{job_id}/cancel",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete

delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Delete a fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
def delete(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Delete a fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

logs

logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobLogs
logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobLogs, "APIResponse"]

Fetch training logs of one fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
def logs(
    self,
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobLogs, "APIResponse"]:
    """Fetch training logs of one fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{job_id}/logs",
        # The wire parameter is singular "line".
        params={"offset": offset, "line": lines},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_logs(
            job_id,
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

stream_events

stream_events(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Iterator[FineTuneEvent]
Source code in dashscope/resources/fine_tunes.py
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
def stream_events(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Iterator[FineTuneEvent]:
    response = self._client.transport.open_stream(
        "GET",
        f"{_BASE_PATH}/{job_id}/stream",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    try:
        for is_error, status_code, data in _iter_sse(response):
            if is_error:
                if self._client.raise_on_error:
                    raise _stream_error(
                        status_code,
                        data,
                        response.headers,
                    )
                _log_stream_error(data, response.headers)
                yield _parse_event(
                    data,
                    is_error=True,
                    strict=self._client.config.strict_validation,
                    response=response,
                )
                return
            yield _parse_event(
                data,
                strict=self._client.config.strict_validation,
                response=response,
            )
    finally:
        response.close()

wait

wait(
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None
) -> FineTune

Poll until the job reaches a terminal status.

With raise_on_error=False a transport-level failure comes back as the :class:FineTune envelope instead of raising. _sleep is a test seam — it replaces the pause between polls.

Source code in dashscope/resources/fine_tunes.py
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
def wait(
    self,
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None,
) -> FineTune:
    """Poll until the job reaches a terminal status.

    With ``raise_on_error=False`` a transport-level failure comes
    back as the :class:`FineTune` envelope instead of raising.
    ``_sleep`` is a test seam — it replaces the pause between polls.
    """
    job_id = _job_id(job)
    sleep_fn = _sleep or time.sleep
    deadline = time.monotonic() + timeout
    current = (
        job
        if isinstance(job, FineTune)
        else self.get(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    )
    interval = poll_interval
    while not current.finished:
        # Compat mode (raise_on_error=False): a transport-level failure
        # comes back as an error envelope with no job status, which
        # would otherwise poll until the timeout.
        if current.is_error:
            return current
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise DashScopeError(
                f"timed out after {timeout}s waiting for"
                f" fine-tune job {job_id}",
            )
        sleep_fn(min(interval, remaining))
        interval = min(interval * 2, max_interval)
        current = self.get(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    return self._check_terminal(current, job_id)

AsyncFineTunes

AsyncFineTunes(client)
Source code in dashscope/resources/fine_tunes.py
959
960
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTune
create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTune, "APIResponse"]

Create a fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
async def create(
    self,
    *,
    model: str,
    training_file_ids: Union[List[str], str],
    validation_file_ids: Union[List[str], str, None] = None,
    mode: Optional[str] = None,
    hyper_parameters: Optional[Dict[str, Any]] = None,
    finetuned_model: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTune, "APIResponse"]:
    """Create a fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_create_body(
        model,
        training_file_ids,
        validation_file_ids,
        mode,
        hyper_parameters,
        finetuned_model,
    )
    resp = await self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_job(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

get async

get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTune
get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTune, "APIResponse"]

Fetch one fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
async def get(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTune, "APIResponse"]:
    """Fetch one fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_job(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list async

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> FineTuneList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[FineTuneList, "APIResponse"]

List fine-tune jobs, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
async def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[FineTuneList, "APIResponse"]:
    """List fine-tune jobs, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_list(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

cancel async

cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Cancel a running fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
async def cancel(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Cancel a running fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "POST",
        f"{_BASE_PATH}/{job_id}/cancel",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete async

delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Delete a fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
async def delete(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Delete a fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

logs async

logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobLogs
logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobLogs, "APIResponse"]

Fetch training logs of one fine-tune job.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/fine_tunes.py
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
async def logs(
    self,
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobLogs, "APIResponse"]:
    """Fetch training logs of one fine-tune job.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{job_id}/logs",
        # The wire parameter is singular "line".
        params={"offset": offset, "line": lines},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_logs(
            job_id,
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

stream_events async

stream_events(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> AsyncIterator[FineTuneEvent]
Source code in dashscope/resources/fine_tunes.py
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
async def stream_events(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> AsyncIterator[FineTuneEvent]:
    response = await self._client.transport.open_stream(
        "GET",
        f"{_BASE_PATH}/{job_id}/stream",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    try:
        async for is_error, status_code, data in _aiter_sse(response):
            if is_error:
                if self._client.raise_on_error:
                    raise _stream_error(
                        status_code,
                        data,
                        response.headers,
                    )
                _log_stream_error(data, response.headers)
                yield _parse_event(
                    data,
                    is_error=True,
                    strict=self._client.config.strict_validation,
                    response=response,
                )
                return
            yield _parse_event(
                data,
                strict=self._client.config.strict_validation,
                response=response,
            )
    finally:
        await response.aclose()

wait async

wait(
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[
        Callable[[float], Awaitable[None]]
    ] = None
) -> FineTune
Source code in dashscope/resources/fine_tunes.py
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
async def wait(
    self,
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Awaitable[None]]] = None,
) -> FineTune:
    job_id = _job_id(job)
    sleep_fn = _sleep or asyncio.sleep
    deadline = time.monotonic() + timeout
    current = (
        job
        if isinstance(job, FineTune)
        else await self.get(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    )
    interval = poll_interval
    while not current.finished:
        # Compat mode (raise_on_error=False): a transport-level failure
        # comes back as an error envelope with no job status, which
        # would otherwise poll until the timeout.
        if current.is_error:
            return current
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise DashScopeError(
                f"timed out after {timeout}s waiting for"
                f" fine-tune job {job_id}",
            )
        await sleep_fn(min(interval, remaining))
        interval = min(interval * 2, max_interval)
        current = await self.get(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    return self._check_terminal(current, job_id)

FineTune

Bases: ResponseBase

One fine-tune job.

The same type comes back from create / get and is nested in FineTuneList.jobs, so there is one shape to learn. The server reports a failure code per job, so the envelope is meaningful in both roles: a failed job in a list flags itself through is_error as well.

job_id class-attribute instance-attribute

job_id: Optional[str] = None

job_name class-attribute instance-attribute

job_name: Optional[str] = None

status class-attribute instance-attribute

status: Optional[str] = None

model class-attribute instance-attribute

model: Optional[str] = None

base_model class-attribute instance-attribute

base_model: Optional[str] = None

finetuned_model class-attribute instance-attribute

finetuned_model: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "finetuned_model", "finetuned_output"
    ),
)

training_file_ids class-attribute instance-attribute

training_file_ids: List[str] = []

validation_file_ids class-attribute instance-attribute

validation_file_ids: List[str] = []

hyper_parameters class-attribute instance-attribute

hyper_parameters: Dict[str, Any] = {}

training_type class-attribute instance-attribute

training_type: Optional[str] = None

created_at class-attribute instance-attribute

created_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "created_at", "create_time"
    ),
)

finished_at class-attribute instance-attribute

finished_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "finished_at", "end_time"
    ),
)

user_identity class-attribute instance-attribute

user_identity: Optional[str] = None

modifier class-attribute instance-attribute

modifier: Optional[str] = None

creator class-attribute instance-attribute

creator: Optional[str] = None

group class-attribute instance-attribute

group: Optional[str] = None

usage class-attribute instance-attribute

usage: Optional[Usage] = None

task_id property

task_id: Optional[str]

Job spells the same identifier task_id.

succeeded property

succeeded: bool

finished property

finished: bool

FineTuneList

Bases: ResponseBase

page_no class-attribute instance-attribute

page_no: int = 1

page_size class-attribute instance-attribute

page_size: int = 10

total_count class-attribute instance-attribute

total_count: int = 0

jobs class-attribute instance-attribute

jobs: List[FineTune] = []

JobLogs

Bases: ResponseBase

Training logs of one job, from fine_tunes.logs.

job_id class-attribute instance-attribute

job_id: Optional[str] = None

content class-attribute instance-attribute

content: str = ''

FineTuneEvent

Bases: BaseModel

One SSE frame from /fine-tunes/{id}/stream.

output class-attribute instance-attribute

output: Union[Dict[str, Any], str, None] = None

is_error class-attribute instance-attribute

is_error: bool = False

Deployments

client.deployments — model deployments.

Deployments

Deployments(client)
Source code in dashscope/resources/deployments.py
221
222
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Create a deployment of model with capacity instances.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
def create(
    self,
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Create a deployment of ``model`` with ``capacity`` instances.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_create_body(
        model,
        capacity,
        model_version,
        suffix,
        plan,
        template_id,
        deploy_spec,
        billing_method,
    )
    resp = self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

get

get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Fetch one deployment by deployed_model id.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
def get(
    self,
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Fetch one deployment by ``deployed_model`` id.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{deployed_model}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DeploymentList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DeploymentList, "APIResponse"]

List deployments, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DeploymentList, "APIResponse"]:
    """List deployments, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_list(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

scale

scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Resize a deployment to capacity instances.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
def scale(
    self,
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Resize a deployment to ``capacity`` instances.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "PUT",
        f"{_BASE_PATH}/{deployed_model}/scale",
        json={"deployed_model": deployed_model, "capacity": capacity},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete

delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Delete a deployment; the job status reports the teardown.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
def delete(
    self,
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Delete a deployment; the job status reports the teardown.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{deployed_model}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

stream_events

stream_events(
    deployed_model_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> Iterator[DeploymentEvent]
Source code in dashscope/resources/deployments.py
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
def stream_events(
    self,
    deployed_model_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> Iterator[DeploymentEvent]:
    response = self._client.transport.open_stream(
        "GET",
        f"{_BASE_PATH}/{deployed_model_id}/stream",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    try:
        for is_error, status_code, data in _iter_sse(response):
            if is_error:
                if self._client.raise_on_error:
                    raise _stream_error(
                        status_code,
                        data,
                        response.headers,
                    )
                _log_stream_error(data, response.headers)
                yield _parse_event(
                    data,
                    is_error=True,
                    strict=self._client.config.strict_validation,
                    response=response,
                )
                return
            yield _parse_event(
                data,
                strict=self._client.config.strict_validation,
                response=response,
            )
    finally:
        response.close()

AsyncDeployments

AsyncDeployments(client)
Source code in dashscope/resources/deployments.py
707
708
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Create a deployment of model with capacity instances.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
async def create(
    self,
    *,
    model: str,
    capacity: int,
    model_version: Optional[str] = None,
    suffix: Optional[str] = None,
    plan: Optional[str] = None,
    template_id: Optional[str] = None,
    deploy_spec: Optional[Dict[str, Any]] = None,
    billing_method: Optional[str] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Create a deployment of ``model`` with ``capacity`` instances.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_create_body(
        model,
        capacity,
        model_version,
        suffix,
        plan,
        template_id,
        deploy_spec,
        billing_method,
    )
    resp = await self._client.transport.request_api(
        "POST",
        _BASE_PATH,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

get async

get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
get(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Fetch one deployment by deployed_model id.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
async def get(
    self,
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Fetch one deployment by ``deployed_model`` id.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "GET",
        f"{_BASE_PATH}/{deployed_model}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

list async

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DeploymentList
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DeploymentList, "APIResponse"]

List deployments, one page at a time.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
async def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DeploymentList, "APIResponse"]:
    """List deployments, one page at a time.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_list(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

scale async

scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> Deployment
scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
scale(
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[Deployment, "APIResponse"]

Resize a deployment to capacity instances.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
async def scale(
    self,
    deployed_model: str,
    *,
    capacity: int,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[Deployment, "APIResponse"]:
    """Resize a deployment to ``capacity`` instances.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "PUT",
        f"{_BASE_PATH}/{deployed_model}/scale",
        json={"deployed_model": deployed_model, "capacity": capacity},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

delete async

delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> JobStatus
delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
delete(
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[JobStatus, "APIResponse"]

Delete a deployment; the job status reports the teardown.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/deployments.py
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
async def delete(
    self,
    deployed_model: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[JobStatus, "APIResponse"]:
    """Delete a deployment; the job status reports the teardown.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    resp = await self._client.transport.request_api(
        "DELETE",
        f"{_BASE_PATH}/{deployed_model}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_status(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

stream_events async

stream_events(
    deployed_model_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> AsyncIterator[DeploymentEvent]
Source code in dashscope/resources/deployments.py
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
async def stream_events(
    self,
    deployed_model_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> AsyncIterator[DeploymentEvent]:
    response = await self._client.transport.open_stream(
        "GET",
        f"{_BASE_PATH}/{deployed_model_id}/stream",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    try:
        async for is_error, status_code, data in _aiter_sse(response):
            if is_error:
                if self._client.raise_on_error:
                    raise _stream_error(
                        status_code,
                        data,
                        response.headers,
                    )
                _log_stream_error(data, response.headers)
                yield _parse_event(
                    data,
                    is_error=True,
                    strict=self._client.config.strict_validation,
                    response=response,
                )
                return
            yield _parse_event(
                data,
                strict=self._client.config.strict_validation,
                response=response,
            )
    finally:
        await response.aclose()

Deployment

Bases: ResponseBase

One model deployment.

The same type comes back from create / get / scale and is nested in DeploymentList.deployments, so there is one shape to learn; the response envelope therefore rides along on the nested copies too, empty there because the server reports it once per response.

deployed_model class-attribute instance-attribute

deployed_model: Optional[str] = None

model class-attribute instance-attribute

model: Optional[str] = Field(
    None,
    validation_alias=AliasChoices("model", "model_name"),
)

base_model class-attribute instance-attribute

base_model: Optional[str] = None

status class-attribute instance-attribute

status: Optional[str] = None

capacity class-attribute instance-attribute

capacity: Optional[int] = None

base_capacity class-attribute instance-attribute

base_capacity: Optional[int] = None

ready_capacity class-attribute instance-attribute

ready_capacity: Optional[int] = None

workspace_id class-attribute instance-attribute

workspace_id: Optional[str] = None

charge_type class-attribute instance-attribute

charge_type: Optional[str] = None

created_at class-attribute instance-attribute

created_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "created_at", "gmt_create"
    ),
)

updated_at class-attribute instance-attribute

updated_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "updated_at", "gmt_modified"
    ),
)

modifier class-attribute instance-attribute

modifier: Optional[str] = None

creator class-attribute instance-attribute

creator: Optional[str] = None

DeploymentList

Bases: ResponseBase

page_no class-attribute instance-attribute

page_no: int = 1

page_size class-attribute instance-attribute

page_size: int = 10

total_count class-attribute instance-attribute

total_count: int = 0

deployments class-attribute instance-attribute

deployments: List[Deployment] = []

DeploymentEvent

Bases: BaseModel

One SSE frame from /deployments/{id}/stream.

output class-attribute instance-attribute

output: Union[Dict[str, Any], str, None] = None

is_error class-attribute instance-attribute

is_error: bool = False

Apps

client.apps — application completions (agents / workflows).

Apps

Apps(client)

client.apps: Bailian application resources.

Source code in dashscope/resources/apps.py
646
647
def __init__(self, client) -> None:
    self.completions = AppCompletions(client)

completions instance-attribute

completions = AppCompletions(client)

AsyncApps

AsyncApps(client)

Async client.apps.

Source code in dashscope/resources/apps.py
902
903
def __init__(self, client) -> None:
    self.completions = AsyncAppCompletions(client)

completions instance-attribute

completions = AsyncAppCompletions(client)

AppCompletions

AppCompletions(client)

One Bailian application call, at client.apps.completions.

Source code in dashscope/resources/apps.py
395
396
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[True],
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> AppStream
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[False] = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> AppCompletion
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[False] = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: bool = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[AppCompletion, AppStream, "APIResponse"]

Call the application; stream=True returns an AppStream.

Send prompt for one turn, messages for a transcript the caller maintains, or both — prompt is then appended as the latest user turn. session_id and memory_id ask the service to keep the conversation state instead.

biz_params carries the application's own flow and plugin inputs; parameters holds model knobs and anything this signature does not name.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/apps.py
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
def create(  # pylint: disable=too-many-locals
    self,
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: bool = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[AppCompletion, AppStream, "APIResponse"]:
    """Call the application; ``stream=True`` returns an AppStream.

    Send ``prompt`` for one turn, ``messages`` for a transcript the
    caller maintains, or both — ``prompt`` is then appended as the
    latest user turn. ``session_id`` and ``memory_id`` ask the
    service to keep the conversation state instead.

    ``biz_params`` carries the application's own flow and plugin
    inputs; ``parameters`` holds model knobs and anything this
    signature does not name.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    _validate(app_id, prompt, messages)
    if raw and stream:
        raise ValueError("raw=True is not supported with stream=True")
    body = _build_body(
        prompt,
        messages,
        session_id,
        doc_reference_type,
        doc_tag_codes,
        memory_id,
        biz_params,
        image_list,
        file_list,
        temperature,
        top_p,
        top_k,
        seed,
        has_thoughts,
        rag_options,
        incremental_output,
        parameters,
    )
    path = f"/apps/{app_id}/completion"
    transport = self._client.transport
    if stream:
        response = transport.open_stream(
            "POST",
            path,
            json=body,
            headers=_SSE_HEADER,
            sdk_module=MODULE,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            options=request_options(
                extra_headers,
                extra_query,
                extra_body,
                max_retries=max_retries,
            ),
        )
        return AppStream(self._events(response), response)
    resp = transport.request_api(
        "POST",
        path,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncAppCompletions

AsyncAppCompletions(client)

Async client.apps.completions; same contract as the sync one.

Source code in dashscope/resources/apps.py
653
654
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[True],
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> AsyncAppStream
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[False] = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> AppCompletion
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: Literal[False] = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: bool = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[AppCompletion, AsyncAppStream, "APIResponse"]

Async twin of :meth:AppCompletions.create.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/apps.py
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
async def create(  # pylint: disable=too-many-locals
    self,
    *,
    app_id: str,
    prompt: Optional[str] = None,
    messages: Optional[List[Dict[str, Any]]] = None,
    stream: bool = False,
    session_id: Optional[str] = None,
    biz_params: Optional[Dict[str, Any]] = None,
    has_thoughts: Optional[bool] = None,
    doc_tag_codes: Optional[List[str]] = None,
    doc_reference_type: Optional[str] = None,
    memory_id: Optional[str] = None,
    image_list: Optional[List[str]] = None,
    file_list: Optional[List[str]] = None,
    rag_options: Optional[Dict[str, Any]] = None,
    incremental_output: Optional[bool] = None,
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    top_k: Optional[int] = None,
    seed: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[AppCompletion, AsyncAppStream, "APIResponse"]:
    """Async twin of :meth:`AppCompletions.create`.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    _validate(app_id, prompt, messages)
    if raw and stream:
        raise ValueError("raw=True is not supported with stream=True")
    body = _build_body(
        prompt,
        messages,
        session_id,
        doc_reference_type,
        doc_tag_codes,
        memory_id,
        biz_params,
        image_list,
        file_list,
        temperature,
        top_p,
        top_k,
        seed,
        has_thoughts,
        rag_options,
        incremental_output,
        parameters,
    )
    path = f"/apps/{app_id}/completion"
    transport = self._client.transport
    if stream:
        response = await transport.open_stream(
            "POST",
            path,
            json=body,
            headers=_SSE_HEADER,
            sdk_module=MODULE,
            timeout=timeout,
            api_key=api_key,
            workspace=workspace,
            options=request_options(
                extra_headers,
                extra_query,
                extra_body,
                max_retries=max_retries,
            ),
        )
        return AsyncAppStream(self._events(response), response)
    resp = await transport.request_api(
        "POST",
        path,
        json=body,
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AppCompletion

Bases: ResponseBase

text class-attribute instance-attribute

text: Optional[str] = None

finish_reason class-attribute instance-attribute

finish_reason: Optional[str] = None

session_id class-attribute instance-attribute

session_id: Optional[str] = None

thoughts class-attribute instance-attribute

thoughts: Optional[List[Thought]] = None

doc_references class-attribute instance-attribute

doc_references: Optional[List[DocReference]] = None

workflow_message class-attribute instance-attribute

workflow_message: Optional[WorkflowMessage] = None

usage class-attribute instance-attribute

usage: Optional[AppUsage] = None

AppStream

AppStream(inner: Iterator[AppCompletion], response: Any)

Typed iterator over app completion events, mirroring ChatStream.

Source code in dashscope/resources/apps.py
340
341
342
def __init__(self, inner: Iterator[AppCompletion], response: Any) -> None:
    self._inner = inner
    self._response = response

headers property

headers: Dict[str, str]

Raw HTTP response headers of the stream's envelope.

text_stream property

text_stream: Iterator[str]

close

close() -> None
Source code in dashscope/resources/apps.py
358
359
def close(self) -> None:
    self._inner.close()

AsyncAppStream

AsyncAppStream(
    inner: AsyncIterator[AppCompletion], response: Any
)
Source code in dashscope/resources/apps.py
363
364
365
366
367
368
369
def __init__(
    self,
    inner: AsyncIterator[AppCompletion],
    response: Any,
) -> None:
    self._inner = inner
    self._response = response

headers property

headers: Dict[str, str]

Raw HTTP response headers of the stream's envelope.

text_stream property

text_stream

aclose async

aclose() -> None
Source code in dashscope/resources/apps.py
388
389
async def aclose(self) -> None:
    await self._inner.aclose()

AppUsage

Bases: Usage

App usage: the shared counters plus per-model detail.

models class-attribute instance-attribute

models: List[AppModelUsage] = []

Thought

Bases: BaseModel

One planning or tool-call step; set has_thoughts to get them.

thought class-attribute instance-attribute

thought: Optional[str] = None

action_type class-attribute instance-attribute

action_type: Optional[str] = None

action_name class-attribute instance-attribute

action_name: Optional[str] = None

action class-attribute instance-attribute

action: Optional[str] = None

action_input class-attribute instance-attribute

action_input: Optional[Dict[str, Any]] = None

action_input_stream class-attribute instance-attribute

action_input_stream: Optional[str] = None

response class-attribute instance-attribute

response: Optional[str] = None

observation class-attribute instance-attribute

observation: Optional[str] = None

DocReference

Bases: BaseModel

One retrieved document behind the answer (RAG citation).

index_id class-attribute instance-attribute

index_id: Optional[str] = None

doc_id class-attribute instance-attribute

doc_id: Optional[str] = None

doc_name class-attribute instance-attribute

doc_name: Optional[str] = None

doc_url class-attribute instance-attribute

doc_url: Optional[str] = None

title class-attribute instance-attribute

title: Optional[str] = None

text class-attribute instance-attribute

text: Optional[str] = None

biz_id class-attribute instance-attribute

biz_id: Optional[str] = None

images class-attribute instance-attribute

images: List[str] = []

page_number class-attribute instance-attribute

page_number: List[int] = []

WorkflowMessage

Bases: BaseModel

Workflow node progress, from output.workflow_message.

node_id class-attribute instance-attribute

node_id: Optional[str] = None

node_name class-attribute instance-attribute

node_name: Optional[str] = None

node_type class-attribute instance-attribute

node_type: Optional[str] = None

node_status class-attribute instance-attribute

node_status: Optional[str] = None

node_is_completed class-attribute instance-attribute

node_is_completed: Optional[str] = None

node_msg_seq_id class-attribute instance-attribute

node_msg_seq_id: Optional[int] = None

message class-attribute instance-attribute

message: Optional[Message] = None

Message

Bases: BaseModel

role class-attribute instance-attribute
role: Optional[str] = None
content class-attribute instance-attribute
content: Optional[str] = None

TingWu

client.tingwu — meeting transcription and analysis.

TingWu

TingWu(client)

client.tingwu: offline summarization + realtime understanding.

Source code in dashscope/resources/tingwu.py
267
268
def __init__(self, client) -> None:
    self._client = client

call

call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> TingWuResult
call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[TingWuResult, "APIResponse"]

Run one offline TingWu request (1.x TingWu.call).

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/tingwu.py
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
def call(
    self,
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[TingWuResult, "APIResponse"]:
    """Run one offline TingWu request (1.x ``TingWu.call``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body: Dict[str, Any] = {"model": model, "input": dict(input)}
    if parameters:
        body["parameters"] = dict(parameters)
    resp = self._client.transport.request_api(
        "POST",
        f"/services/{SERVICE}",
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_result(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

realtime

realtime(
    *,
    model: str,
    app_id: str,
    format: str = "pcm",
    sample_rate: int = 16000,
    terminology: Optional[str] = None,
    max_end_silence: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    workspace_id: Optional[str] = None,
    data_id: Optional[str] = None,
    ws_url: Optional[str] = None,
    connector: Optional[Connector] = None,
    connection: Optional[WsConnection] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None
) -> TingWuRealtime

Open a realtime TingWu session (use as a context manager).

With connection= the session runs as one task on the shared socket (binary uplink is single-owner per connection).

Source code in dashscope/resources/tingwu.py
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
def realtime(
    self,
    *,
    model: str,
    app_id: str,
    format: str = "pcm",  # pylint: disable=redefined-builtin
    sample_rate: int = 16000,
    terminology: Optional[str] = None,
    max_end_silence: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    workspace_id: Optional[str] = None,
    data_id: Optional[str] = None,
    ws_url: Optional[str] = None,
    connector: Optional[Connector] = None,
    connection: Optional[WsConnection] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> TingWuRealtime:
    """Open a realtime TingWu session (use as a context manager).

    With ``connection=`` the session runs as one task on the shared
    socket (binary uplink is single-owner per connection).
    """
    return TingWuRealtime(
        self._client,
        model=model,
        app_id=app_id,
        format=format,
        sample_rate=sample_rate,
        terminology=terminology,
        max_end_silence=max_end_silence,
        parameters=parameters,
        workspace_id=workspace_id,
        data_id=data_id,
        ws_url=ws_url,
        connector=connector,
        connection=connection,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
    )

AsyncTingWu

AsyncTingWu(client)

Async client.tingwu.

Realtime sessions stay sync-only, matching the rest of v2 (design doc M3 3.5).

Source code in dashscope/resources/tingwu.py
409
410
def __init__(self, client) -> None:
    self._client = client

call async

call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> TingWuResult
call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
call(
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[TingWuResult, "APIResponse"]

Run one offline TingWu request (1.x TingWu.async_call).

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/tingwu.py
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
async def call(
    self,
    *,
    model: str,
    input: Dict[str, Any],
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[TingWuResult, "APIResponse"]:
    """Run one offline TingWu request (1.x ``TingWu.async_call``).

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body: Dict[str, Any] = {"model": model, "input": dict(input)}
    if parameters:
        body["parameters"] = dict(parameters)
    resp = await self._client.transport.request_api(
        "POST",
        f"/services/{SERVICE}",
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse_result(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

TingWuRealtime

TingWuRealtime(
    client,
    *,
    model: str,
    app_id: str,
    format: str = "pcm",
    sample_rate: int = 16000,
    terminology: Optional[str] = None,
    max_end_silence: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    workspace_id: Optional[str] = None,
    data_id: Optional[str] = None,
    ws_url: Optional[str] = None,
    connector: Optional[Connector] = None,
    connection: Optional[WsConnection] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None
)

Realtime TingWu session over one duplex websocket connection.

Usage::

with client.tingwu.realtime(
    model="tingwu-turbo",
    app_id="your-app-id",
) as session:
    session.send_audio_frame(chunk)
    ...
    session.stop()
    for event in session.events():
        ...
Source code in dashscope/resources/tingwu.py
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
def __init__(
    self,
    client,
    *,
    model: str,
    app_id: str,
    format: str = "pcm",  # pylint: disable=redefined-builtin
    sample_rate: int = 16000,
    terminology: Optional[str] = None,
    max_end_silence: Optional[int] = None,
    parameters: Optional[Dict[str, Any]] = None,
    workspace_id: Optional[str] = None,
    data_id: Optional[str] = None,
    ws_url: Optional[str] = None,
    connector: Optional[Connector] = None,
    connection: Optional[WsConnection] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
) -> None:
    config = client.config
    self._model = model
    self._app_id = app_id
    merged: Dict[str, Any] = {
        "format": format,
        "sampleRate": sample_rate,
    }
    if parameters:
        merged.update(parameters)
    # Named kwargs win over the ``parameters=`` escape hatch; the keys
    # match the 1.x TingWuRealtime wire names (asr convention).
    if terminology is not None:
        merged["terminology"] = terminology
    if max_end_silence is not None:
        merged["maxEndSilence"] = max_end_silence
    self._parameters = merged
    self._start_input = _realtime_start_input(
        app_id,
        workspace_id,
        data_id,
    )
    # A shared connection runs this session as one task on it;
    # ws_url/connector/api_key/workspace then belong to the
    # connection and the per-session values are ignored.
    self._connection = connection
    self._session_kwargs = {
        "url": ws_url,
        "api_key": api_key or config.api_key,
        "workspace": workspace or config.workspace,
        "region": config.region,
        "connector": connector,
        "module": MODULE,
        "timeout": timeout,
        "headers": with_client_user_agent(client, None),
    }
    self._session: Optional[Union[WsSession, WsTask]] = None

session property

session: Union[WsSession, WsTask]

send_audio_frame

send_audio_frame(data: bytes) -> None

Send one raw audio frame (format/sampleRate as configured).

Source code in dashscope/resources/tingwu.py
223
224
225
def send_audio_frame(self, data: bytes) -> None:
    """Send one raw audio frame (format/sampleRate as configured)."""
    self.session.send_binary(data)

stop

stop() -> None

Signal end of audio; results keep arriving as events.

Source code in dashscope/resources/tingwu.py
227
228
229
230
231
232
233
def stop(self) -> None:
    """Signal end of audio; results keep arriving as events."""
    # 1.x sends appId=None here (tingwu_realtime.py:139 reads the
    # never-assigned ``_Request.app_id``); v2 sends the real app_id.
    self.session.finish_task(
        input={"appId": self._app_id, "directive": "stop"},
    )

events

events() -> Iterator[Dict[str, Any]]

Yield result events until speech-end (or session end).

A payload task-failed action raises through the error catalog, like the header-level task-failed the session itself raises on.

Source code in dashscope/resources/tingwu.py
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
def events(self) -> Iterator[Dict[str, Any]]:
    """Yield result events until ``speech-end`` (or session end).

    A payload ``task-failed`` action raises through the error catalog,
    like the header-level task-failed the session itself raises on.
    """
    session = self.session
    while not session.finished:
        event = session.recv_event()
        output = (event.get("payload") or {}).get("output") or {}
        action = output.get("action")
        if action == "task-failed":
            # The frame's request_id lives in the header; forward it
            # like WsSession does for header-level task-failed.
            header = event.get("header") or {}
            request_id = header.get("request_id")
            raise error_from_business_code(
                message=output.get("errorMessage") or "task failed",
                code=output.get("errorCode"),
                body=event,
                headers=(
                    {"x-request-id": request_id} if request_id else None
                ),
            )
        yield event
        if action == "speech-end":
            break

TingWuResult

Bases: ResponseBase

Parsed offline TingWu response.

output keeps the result dict (TaskId / Result / ...) and usage the token counters, both as sent by the service.

output class-attribute instance-attribute

output: Dict[str, Any] = Field(default_factory=dict)

usage class-attribute instance-attribute

usage: Optional[Usage] = None

Decision

client.decision — structured decision / judging calls.

Decision

Decision(client)

Synchronous decision-model calls (client.decision).

Source code in dashscope/resources/decision.py
250
251
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DecisionResponse
create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DecisionResponse, "APIResponse"]

Run one decision round.

Usage::

resp = client.decision.create(
    model="decision-model-preview",
    state={"ticket_id": "T-1001", "content": "..."},
    questions={
        "department": ChoiceQuestion(
            instructions="Which team should handle this?",
            criteria={"billing": "...", "technical": "..."},
        ),
        "escalate": NoulQuestion(
            instructions="Page the on-call engineer?",
        ),
    },
)
print(resp.answers["department"].choice)

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself. It also bypasses _checked_response, which is what turns this endpoint's nested error envelope into is_error / code / message.

Source code in dashscope/resources/decision.py
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
def create(
    self,
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DecisionResponse, "APIResponse"]:
    """Run one decision round.

    Usage::

        resp = client.decision.create(
            model="decision-model-preview",
            state={"ticket_id": "T-1001", "content": "..."},
            questions={
                "department": ChoiceQuestion(
                    instructions="Which team should handle this?",
                    criteria={"billing": "...", "technical": "..."},
                ),
                "escalate": NoulQuestion(
                    instructions="Page the on-call engineer?",
                ),
            },
        )
        print(resp.answers["department"].choice)

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself. It also bypasses
    ``_checked_response``, which is what turns this endpoint's nested
    ``error`` envelope into ``is_error`` / ``code`` / ``message``.
    """
    body = _build_body(model=model, state=state, questions=questions)
    resp = self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        base_url=_endpoint_base(self._client.config),
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    return _checked_response(self._client, resp.http_response)

AsyncDecision

AsyncDecision(client)

Asynchronous decision-model calls (client.decision).

Source code in dashscope/resources/decision.py
355
356
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> DecisionResponse
create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
create(
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[DecisionResponse, "APIResponse"]

Async twin of :meth:Decision.create.

Source code in dashscope/resources/decision.py
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
async def create(
    self,
    *,
    model: str,
    state: StateInput,
    questions: Dict[str, QuestionInput],
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[DecisionResponse, "APIResponse"]:
    """Async twin of :meth:`Decision.create`."""
    body = _build_body(model=model, state=state, questions=questions)
    resp = await self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        base_url=_endpoint_base(self._client.config),
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    return _checked_response(self._client, resp.http_response)

DecisionResponse

Bases: ResponseBase

One System One decision round; answers keys mirror the request's question ids.

model class-attribute instance-attribute

model: Optional[str] = None

answers class-attribute instance-attribute

answers: Dict[str, DecisionAnswer] = {}

usage class-attribute instance-attribute

usage: Optional[Usage] = None

latency_ms class-attribute instance-attribute

latency_ms: Optional[float] = None

DecisionAnswer

Bases: BaseModel

The answer to one question; the filled field follows type.

choice carries the selected option name, noul P(yes) with 0=no and 1=yes, and score the probability-weighted level index (e.g. 1.43). probabilities gives every option's / level's probability (they sum to 1); confidence is returned for choice / score only, and legend maps a score level index back to its description.

type class-attribute instance-attribute

type: Optional[str] = None

choice class-attribute instance-attribute

choice: Optional[str] = None

noul class-attribute instance-attribute

noul: Optional[float] = None

score class-attribute instance-attribute

score: Optional[float] = None

probabilities class-attribute instance-attribute

probabilities: Optional[Dict[str, float]] = None

confidence class-attribute instance-attribute

confidence: Optional[float] = None

legend class-attribute instance-attribute

legend: Optional[Dict[str, str]] = None

ChoiceQuestion

Bases: BaseModel

A pick-one-of-N question (type="choice").

criteria maps each option name to its description (1-255 options; give the full set and add an other fallback).

type class-attribute instance-attribute

type: Literal['choice'] = 'choice'

instructions class-attribute instance-attribute

instructions: Optional[str] = None

criteria class-attribute instance-attribute

criteria: Dict[str, str] = Field(
    min_length=1, max_length=255
)

NoulQuestion

Bases: BaseModel

A yes/no judgement (type="noul"); the answer is P(yes).

criteria may describe the two outcomes as {"true": ..., "false": ...} and is optional.

type class-attribute instance-attribute

type: Literal['noul'] = 'noul'

instructions class-attribute instance-attribute

instructions: Optional[str] = None

criteria class-attribute instance-attribute

criteria: Optional[Dict[str, str]] = None

ScoreQuestion

Bases: BaseModel

An ordinal-scale rating (type="score").

criteria describes the levels from low to high (2-255 levels; 3-7 clearly distinguishable levels work best). The answer is the probability-weighted level index and may fall between two levels.

type class-attribute instance-attribute

type: Literal['score'] = 'score'

instructions class-attribute instance-attribute

instructions: Optional[str] = None

criteria class-attribute instance-attribute

criteria: List[str] = Field(min_length=2, max_length=255)

Tokenization

client.tokenization — token counting.

Tokenization

Tokenization(client)
Source code in dashscope/resources/tokenization.py
108
109
def __init__(self, client) -> None:
    self._client = client

count

count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> TokenCount
count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[TokenCount, "APIResponse"]

Count tokens for prompt / messages.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/tokenization.py
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
def count(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[TokenCount, "APIResponse"]:
    """Count tokens for ``prompt`` / ``messages``.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_body(
        model=model,
        prompt=prompt,
        messages=messages,
        parameters=parameters,
    )
    resp = self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

AsyncTokenization

AsyncTokenization(client)
Source code in dashscope/resources/tokenization.py
207
208
def __init__(self, client) -> None:
    self._client = client

count async

count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[False] = False
) -> TokenCount
count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: Literal[True]
) -> "APIResponse"
count(
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False
) -> Union[TokenCount, "APIResponse"]

Count tokens for prompt / messages.

raw=True returns the :class:~dashscope.transport.APIResponse before any error check, so a caller can read the status, headers and elapsed of the response or re-parse it itself.

Source code in dashscope/resources/tokenization.py
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
async def count(
    self,
    *,
    model: str,
    prompt: Optional[str] = None,
    messages: Union[str, List[MessageInput], None] = None,
    parameters: Optional[Dict[str, Any]] = None,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    raw: bool = False,
) -> Union[TokenCount, "APIResponse"]:
    """Count tokens for ``prompt`` / ``messages``.

    ``raw=True`` returns the :class:`~dashscope.transport.APIResponse`
    before any error check, so a caller can read the status, headers and
    ``elapsed`` of the response or re-parse it itself.
    """
    body = _build_body(
        model=model,
        prompt=prompt,
        messages=messages,
        parameters=parameters,
    )
    resp = await self._client.transport.request_api(
        "POST",
        _PATH,
        json=body,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        sdk_module=MODULE,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
        client=self._client,
    )
    if raw:
        return resp
    resp.raise_for_status()
    return with_headers(
        _parse(
            resp.json(),
            strict=self._client.config.strict_validation,
            response=resp.http_response,
        ),
        resp.http_response,
    )

TokenCount

Bases: ResponseBase

usage class-attribute instance-attribute

usage: Usage = Usage()

token_ids class-attribute instance-attribute

token_ids: Optional[List[int]] = None

tokens class-attribute instance-attribute

tokens: Optional[List[str]] = None

input_tokens property

input_tokens: int

Reinforcement learning

client.rl — agentic RL datasets, functions and jobs.

Rl

Rl(client)

Sync mount of the agentic-RL workflow.

The workflow methods (register_functions/test_functions/ upload_data/jobs.create) wrap the async implementation with asyncio.run, so they must not be called from a thread that already runs an event loop (Jupyter, FastAPI, pytest-asyncio) — use :class:AsyncRl there instead.

Source code in dashscope/resources/reinforcement_learning.py
532
533
534
def __init__(self, client) -> None:
    self._client = client
    self.jobs = RlJobs(client)

jobs instance-attribute

jobs = RlJobs(client)

register_functions

register_functions(
    *,
    rollout_classpaths: Optional[List[str]] = None,
    reward_classpaths: Optional[List[str]] = None,
    group_reward_classpaths: Optional[List[str]] = None,
    workspace_dir: str = "./",
    lazy_load: bool = True,
    api_key: Optional[str] = None
) -> RegisteredFunctions
Source code in dashscope/resources/reinforcement_learning.py
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
def register_functions(
    self,
    *,
    rollout_classpaths: Optional[List[str]] = None,
    reward_classpaths: Optional[List[str]] = None,
    group_reward_classpaths: Optional[List[str]] = None,
    workspace_dir: str = "./",
    lazy_load: bool = True,
    api_key: Optional[str] = None,
) -> RegisteredFunctions:
    rl = _new_agentic_rl(self._client, api_key=api_key)
    return asyncio.run(
        _register_functions_workflow(
            rl,
            rollout_classpaths,
            reward_classpaths,
            group_reward_classpaths,
            workspace_dir,
            lazy_load,
        ),
    )

test_functions

test_functions(
    *,
    instance_id: str,
    func_type: Union[str, Any],
    input_data: Dict[str, Any],
    pull_logs: bool = False,
    log_page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    api_key: Optional[str] = None
) -> Any

Returns whatever the customer's own function returns.

The pull_logs/log_page_size/start_time/end_time parameters forward to the log-pulling step that runs after verification.

Source code in dashscope/resources/reinforcement_learning.py
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
def test_functions(
    self,
    *,
    instance_id: str,
    func_type: Union[str, Any],
    input_data: Dict[str, Any],
    pull_logs: bool = False,
    log_page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    api_key: Optional[str] = None,
) -> Any:
    """Returns whatever the customer's own function returns.

    The ``pull_logs``/``log_page_size``/``start_time``/``end_time``
    parameters forward to the log-pulling step that runs after
    verification.
    """
    return asyncio.run(
        _agentic_rl.AgenticRL.test_functions(
            instance_id=instance_id,
            functype=_resolve_func_type(func_type),
            input_data=input_data,
            api_key=api_key or self._client.config.api_key or "",
            pull_logs=pull_logs,
            log_page_size=log_page_size,
            start_time=start_time,
            end_time=end_time,
        ),
    )

upload_data

upload_data(
    training_files: Union[List[str], str],
    validation_files: Union[List[str], str, None] = None,
    *,
    api_key: Optional[str] = None
) -> UploadedData
Source code in dashscope/resources/reinforcement_learning.py
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
def upload_data(
    self,
    training_files: Union[List[str], str],
    validation_files: Union[List[str], str, None] = None,
    *,
    api_key: Optional[str] = None,
) -> UploadedData:
    rl = _new_agentic_rl(self._client, api_key=api_key)
    train_ids, val_ids = asyncio.run(
        rl.upload_datasets(
            training_files=training_files,
            validation_files=validation_files,
        ),
    )
    return UploadedData(
        training_file_ids=train_ids,
        validation_file_ids=val_ids or [],
    )

query_function_instance_logs

query_function_instance_logs(
    function_instance_id: str,
    *,
    page_number: int = 1,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None
) -> Dict[str, Any]

One page of function-instance logs (raw log-query API dict).

Wraps asyncio.run, so it must not be called from a running event loop — use :class:AsyncRl there.

Source code in dashscope/resources/reinforcement_learning.py
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
def query_function_instance_logs(
    self,
    function_instance_id: str,
    *,
    page_number: int = 1,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None,
) -> Dict[str, Any]:
    """One page of function-instance logs (raw log-query API dict).

    Wraps ``asyncio.run``, so it must not be called from a running
    event loop — use :class:`AsyncRl` there.
    """
    return asyncio.run(
        _agentic_rl.AgenticRL.query_function_instance_logs(
            function_instance_id=function_instance_id,
            page_number=page_number,
            page_size=page_size,
            start_time=start_time,
            end_time=end_time,
            keywords=keywords,
            api_key=api_key or self._client.config.api_key or "",
        ),
    )

query_all_function_instance_logs

query_all_function_instance_logs(
    function_instance_id: str,
    *,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None
) -> List[str]

All function-instance logs, aggregated across pages.

Wraps asyncio.run, so it must not be called from a running event loop — use :class:AsyncRl there.

Source code in dashscope/resources/reinforcement_learning.py
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
def query_all_function_instance_logs(
    self,
    function_instance_id: str,
    *,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None,
) -> List[str]:
    """All function-instance logs, aggregated across pages.

    Wraps ``asyncio.run``, so it must not be called from a running
    event loop — use :class:`AsyncRl` there.
    """
    return asyncio.run(
        _agentic_rl.AgenticRL.query_all_function_instance_logs(
            function_instance_id=function_instance_id,
            page_size=page_size,
            start_time=start_time,
            end_time=end_time,
            keywords=keywords,
            api_key=api_key or self._client.config.api_key or "",
        ),
    )

delete_function_instance

delete_function_instance(
    function_instance_id: str,
    *,
    api_key: Optional[str] = None
) -> Dict[str, Any]

Delete a function-instance (raw delete API dict).

Wraps asyncio.run, so it must not be called from a running event loop — use :class:AsyncRl there.

Source code in dashscope/resources/reinforcement_learning.py
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
def delete_function_instance(
    self,
    function_instance_id: str,
    *,
    api_key: Optional[str] = None,
) -> Dict[str, Any]:
    """Delete a function-instance (raw delete API dict).

    Wraps ``asyncio.run``, so it must not be called from a running
    event loop — use :class:`AsyncRl` there.
    """
    return asyncio.run(
        _agentic_rl.AgenticRL.delete_function_instance(
            function_instance_id=function_instance_id,
            api_key=api_key or self._client.config.api_key or "",
        ),
    )

AsyncRl

AsyncRl(client)

Async mount of the agentic-RL workflow.

Source code in dashscope/resources/reinforcement_learning.py
965
966
967
def __init__(self, client) -> None:
    self._client = client
    self.jobs = AsyncRlJobs(client)

jobs instance-attribute

jobs = AsyncRlJobs(client)

register_functions async

register_functions(
    *,
    rollout_classpaths: Optional[List[str]] = None,
    reward_classpaths: Optional[List[str]] = None,
    group_reward_classpaths: Optional[List[str]] = None,
    workspace_dir: str = "./",
    lazy_load: bool = True,
    api_key: Optional[str] = None
) -> RegisteredFunctions
Source code in dashscope/resources/reinforcement_learning.py
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
async def register_functions(
    self,
    *,
    rollout_classpaths: Optional[List[str]] = None,
    reward_classpaths: Optional[List[str]] = None,
    group_reward_classpaths: Optional[List[str]] = None,
    workspace_dir: str = "./",
    lazy_load: bool = True,
    api_key: Optional[str] = None,
) -> RegisteredFunctions:
    rl = _new_agentic_rl(self._client, api_key=api_key)
    return await _register_functions_workflow(
        rl,
        rollout_classpaths,
        reward_classpaths,
        group_reward_classpaths,
        workspace_dir,
        lazy_load,
    )

test_functions async

test_functions(
    *,
    instance_id: str,
    func_type: Union[str, Any],
    input_data: Dict[str, Any],
    pull_logs: bool = False,
    log_page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    api_key: Optional[str] = None
) -> Any

Returns whatever the customer's own function returns.

The pull_logs/log_page_size/start_time/end_time parameters forward to the log-pulling step that runs after verification.

Source code in dashscope/resources/reinforcement_learning.py
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
async def test_functions(
    self,
    *,
    instance_id: str,
    func_type: Union[str, Any],
    input_data: Dict[str, Any],
    pull_logs: bool = False,
    log_page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    api_key: Optional[str] = None,
) -> Any:
    """Returns whatever the customer's own function returns.

    The ``pull_logs``/``log_page_size``/``start_time``/``end_time``
    parameters forward to the log-pulling step that runs after
    verification.
    """
    return await _agentic_rl.AgenticRL.test_functions(
        instance_id=instance_id,
        functype=_resolve_func_type(func_type),
        input_data=input_data,
        api_key=api_key or self._client.config.api_key or "",
        pull_logs=pull_logs,
        log_page_size=log_page_size,
        start_time=start_time,
        end_time=end_time,
    )

upload_data async

upload_data(
    training_files: Union[List[str], str],
    validation_files: Union[List[str], str, None] = None,
    *,
    api_key: Optional[str] = None
) -> UploadedData
Source code in dashscope/resources/reinforcement_learning.py
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
async def upload_data(
    self,
    training_files: Union[List[str], str],
    validation_files: Union[List[str], str, None] = None,
    *,
    api_key: Optional[str] = None,
) -> UploadedData:
    rl = _new_agentic_rl(self._client, api_key=api_key)
    train_ids, val_ids = await rl.upload_datasets(
        training_files=training_files,
        validation_files=validation_files,
    )
    return UploadedData(
        training_file_ids=train_ids,
        validation_file_ids=val_ids or [],
    )

query_function_instance_logs async

query_function_instance_logs(
    function_instance_id: str,
    *,
    page_number: int = 1,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None
) -> Dict[str, Any]

One page of function-instance logs (raw log-query API dict).

Source code in dashscope/resources/reinforcement_learning.py
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
async def query_function_instance_logs(
    self,
    function_instance_id: str,
    *,
    page_number: int = 1,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None,
) -> Dict[str, Any]:
    """One page of function-instance logs (raw log-query API dict)."""
    return await _agentic_rl.AgenticRL.query_function_instance_logs(
        function_instance_id=function_instance_id,
        page_number=page_number,
        page_size=page_size,
        start_time=start_time,
        end_time=end_time,
        keywords=keywords,
        api_key=api_key or self._client.config.api_key or "",
    )

query_all_function_instance_logs async

query_all_function_instance_logs(
    function_instance_id: str,
    *,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None
) -> List[str]

All function-instance logs, aggregated across pages.

Source code in dashscope/resources/reinforcement_learning.py
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
async def query_all_function_instance_logs(
    self,
    function_instance_id: str,
    *,
    page_size: int = 100,
    start_time: Optional[int] = None,
    end_time: Optional[int] = None,
    keywords: Optional[List[str]] = None,
    api_key: Optional[str] = None,
) -> List[str]:
    """All function-instance logs, aggregated across pages."""
    return await _agentic_rl.AgenticRL.query_all_function_instance_logs(
        function_instance_id=function_instance_id,
        page_size=page_size,
        start_time=start_time,
        end_time=end_time,
        keywords=keywords,
        api_key=api_key or self._client.config.api_key or "",
    )

delete_function_instance async

delete_function_instance(
    function_instance_id: str,
    *,
    api_key: Optional[str] = None
) -> Dict[str, Any]

Delete a function-instance (raw delete API dict).

Source code in dashscope/resources/reinforcement_learning.py
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
async def delete_function_instance(
    self,
    function_instance_id: str,
    *,
    api_key: Optional[str] = None,
) -> Dict[str, Any]:
    """Delete a function-instance (raw delete API dict)."""
    return await _agentic_rl.AgenticRL.delete_function_instance(
        function_instance_id=function_instance_id,
        api_key=api_key or self._client.config.api_key or "",
    )

RlJobs

RlJobs(client)

client.rl.jobs: the agentic-RL training job lifecycle.

create runs the whole workflow — register functions, upload datasets, submit — and returns the job without blocking; wait polls it to a terminal status. The remaining verbs share the fine_tunes wire contract (RL jobs are fine-tune jobs: same backend, same response models) and ride the v2 client endpoint like every other resource. The workflow/submit path is the exception: it posts to the management-plane host its own constants name, as it always has.

Source code in dashscope/resources/reinforcement_learning.py
244
245
def __init__(self, client) -> None:
    self._client = client

create

create(
    *,
    config_path: Optional[str] = None,
    job_name: Optional[str] = None,
    api_key: Optional[str] = None,
    **kwargs: Any
) -> FineTune

Submit the workflow and return immediately; wait blocks.

kwargs override individual keys of the training config loaded from config_path, which is open-ended by design.

Source code in dashscope/resources/reinforcement_learning.py
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
def create(
    self,
    *,
    config_path: Optional[str] = None,
    job_name: Optional[str] = None,
    api_key: Optional[str] = None,
    **kwargs: Any,
) -> FineTune:
    """Submit the workflow and return immediately; ``wait`` blocks.

    ``kwargs`` override individual keys of the training config loaded
    from ``config_path``, which is open-ended by design.
    """
    rl = _new_agentic_rl(self._client, api_key=api_key)
    if job_name is not None:
        kwargs["job_name"] = job_name
    rl.init(config_path=config_path, **kwargs)
    result = asyncio.run(rl.run())
    return _to_job(
        result,
        strict=self._client.config.strict_validation,
    )

fetch

fetch(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> FineTune
Source code in dashscope/resources/reinforcement_learning.py
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
def fetch(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> FineTune:
    response = self._client.transport.request(
        "GET",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_job(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

wait

wait(
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None
) -> FineTune

Poll until the job reaches a terminal status.

Polls through :meth:fetch on the client endpoint. With raise_on_error=False a transport-level failure comes back as the :class:FineTune envelope instead of raising. _sleep is a test seam — it replaces the pause between polls.

Source code in dashscope/resources/reinforcement_learning.py
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
def wait(
    self,
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Any]] = None,
) -> FineTune:
    """Poll until the job reaches a terminal status.

    Polls through :meth:`fetch` on the client endpoint. With
    ``raise_on_error=False`` a transport-level failure comes back
    as the :class:`FineTune` envelope instead of raising.
    ``_sleep`` is a test seam — it replaces the pause between polls.
    """
    job_id = _job_id(job)
    sleep_fn = _sleep or time.sleep
    deadline = time.monotonic() + timeout
    current = (
        job
        if isinstance(job, FineTune)
        else self.fetch(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    )
    interval = poll_interval
    while not current.finished:
        # Compat mode (raise_on_error=False): a transport-level failure
        # comes back as an error envelope with no job status, which
        # would otherwise poll until the timeout.
        if current.is_error:
            return current
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise DashScopeError(
                f"timed out after {timeout}s waiting for"
                f" fine-tune job {job_id}",
            )
        sleep_fn(min(interval, remaining))
        interval = min(interval * 2, max_interval)
        current = self.fetch(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    return _check_terminal(self._client, current, job_id)

list

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> FineTuneList
Source code in dashscope/resources/reinforcement_learning.py
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> FineTuneList:
    response = self._client.transport.request(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_list(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

cancel

cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobStatus
Source code in dashscope/resources/reinforcement_learning.py
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
def cancel(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobStatus:
    response = self._client.transport.request(
        "POST",
        f"{_BASE_PATH}/{job_id}/cancel",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_status(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

delete

delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobStatus
Source code in dashscope/resources/reinforcement_learning.py
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
def delete(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobStatus:
    response = self._client.transport.request(
        "DELETE",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_status(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

logs

logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobLogs
Source code in dashscope/resources/reinforcement_learning.py
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
def logs(
    self,
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobLogs:
    response = self._client.transport.request(
        "GET",
        f"{_BASE_PATH}/{job_id}/logs",
        # The wire parameter is singular "line".
        params={"offset": offset, "line": lines},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_logs(
            job_id,
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

AsyncRlJobs

AsyncRlJobs(client)

Async client.rl.jobs.

Source code in dashscope/resources/reinforcement_learning.py
684
685
def __init__(self, client) -> None:
    self._client = client

create async

create(
    *,
    config_path: Optional[str] = None,
    job_name: Optional[str] = None,
    api_key: Optional[str] = None,
    **kwargs: Any
) -> FineTune

Submit the workflow and return immediately; wait blocks.

kwargs override individual keys of the training config loaded from config_path, which is open-ended by design.

Source code in dashscope/resources/reinforcement_learning.py
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
async def create(
    self,
    *,
    config_path: Optional[str] = None,
    job_name: Optional[str] = None,
    api_key: Optional[str] = None,
    **kwargs: Any,
) -> FineTune:
    """Submit the workflow and return immediately; ``wait`` blocks.

    ``kwargs`` override individual keys of the training config loaded
    from ``config_path``, which is open-ended by design.
    """
    rl = _new_agentic_rl(self._client, api_key=api_key)
    if job_name is not None:
        kwargs["job_name"] = job_name
    rl.init(config_path=config_path, **kwargs)
    result = await rl.run()
    return _to_job(
        result,
        strict=self._client.config.strict_validation,
    )

fetch async

fetch(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> FineTune
Source code in dashscope/resources/reinforcement_learning.py
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
async def fetch(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> FineTune:
    response = await self._client.transport.request(
        "GET",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_job(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

wait async

wait(
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[
        Callable[[float], Awaitable[None]]
    ] = None
) -> FineTune

Poll until the job reaches a terminal status.

Polls through :meth:fetch on the client endpoint. With raise_on_error=False a transport-level failure comes back as the :class:FineTune envelope instead of raising. _sleep is a test seam — it replaces the pause between polls.

Source code in dashscope/resources/reinforcement_learning.py
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
async def wait(
    self,
    job: Union[FineTune, str],
    *,
    poll_interval: float = DEFAULT_POLL_INTERVAL,
    max_interval: float = DEFAULT_MAX_INTERVAL,
    timeout: float = DEFAULT_WAIT_TIMEOUT,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
    _sleep: Optional[Callable[[float], Awaitable[None]]] = None,
) -> FineTune:
    """Poll until the job reaches a terminal status.

    Polls through :meth:`fetch` on the client endpoint. With
    ``raise_on_error=False`` a transport-level failure comes back
    as the :class:`FineTune` envelope instead of raising.
    ``_sleep`` is a test seam — it replaces the pause between polls.
    """
    job_id = _job_id(job)
    sleep_fn = _sleep or asyncio.sleep
    deadline = time.monotonic() + timeout
    current = (
        job
        if isinstance(job, FineTune)
        else await self.fetch(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    )
    interval = poll_interval
    while not current.finished:
        # Compat mode (raise_on_error=False): a transport-level failure
        # comes back as an error envelope with no job status, which
        # would otherwise poll until the timeout.
        if current.is_error:
            return current
        remaining = deadline - time.monotonic()
        if remaining <= 0:
            raise DashScopeError(
                f"timed out after {timeout}s waiting for"
                f" fine-tune job {job_id}",
            )
        await sleep_fn(min(interval, remaining))
        interval = min(interval * 2, max_interval)
        current = await self.fetch(
            job_id,
            api_key=api_key,
            workspace=workspace,
            extra_headers=extra_headers,
            extra_query=extra_query,
            extra_body=extra_body,
            max_retries=max_retries,
        )
    return _check_terminal(self._client, current, job_id)

list async

list(
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> FineTuneList
Source code in dashscope/resources/reinforcement_learning.py
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
async def list(
    self,
    *,
    page_no: int = 1,
    page_size: int = 10,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> FineTuneList:
    response = await self._client.transport.request(
        "GET",
        _BASE_PATH,
        params={"page_no": page_no, "page_size": page_size},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_list(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

cancel async

cancel(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobStatus
Source code in dashscope/resources/reinforcement_learning.py
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
async def cancel(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobStatus:
    response = await self._client.transport.request(
        "POST",
        f"{_BASE_PATH}/{job_id}/cancel",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_status(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

delete async

delete(
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobStatus
Source code in dashscope/resources/reinforcement_learning.py
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
async def delete(
    self,
    job_id: str,
    *,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobStatus:
    response = await self._client.transport.request(
        "DELETE",
        f"{_BASE_PATH}/{job_id}",
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_status(
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

logs async

logs(
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None
) -> JobLogs
Source code in dashscope/resources/reinforcement_learning.py
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
async def logs(
    self,
    job_id: str,
    *,
    offset: int = 1,
    lines: int = 1000,
    timeout: Optional[float] = None,
    api_key: Optional[str] = None,
    workspace: Optional[str] = None,
    extra_headers: Optional[Mapping[str, str]] = None,
    extra_query: Optional[Mapping[str, Any]] = None,
    extra_body: Optional[Mapping[str, Any]] = None,
    max_retries: Optional[int] = None,
) -> JobLogs:
    response = await self._client.transport.request(
        "GET",
        f"{_BASE_PATH}/{job_id}/logs",
        # The wire parameter is singular "line".
        params={"offset": offset, "line": lines},
        sdk_module=MODULE,
        timeout=timeout,
        api_key=api_key,
        workspace=workspace,
        options=request_options(
            extra_headers,
            extra_query,
            extra_body,
            max_retries=max_retries,
        ),
    )
    check_response(response, raise_on_error=self._client.raise_on_error)
    return with_headers(
        _parse_logs(
            job_id,
            response_json(response),
            strict=self._client.config.strict_validation,
            response=response,
        ),
        response,
    )

RegisteredFunctions

Bases: BaseModel

Ids minted by rl.register_functions.

An entity id names the uploaded component; an instance id is what rl.test_functions runs against.

rollout_entity_ids class-attribute instance-attribute

rollout_entity_ids: List[str] = []

reward_entity_ids class-attribute instance-attribute

reward_entity_ids: List[str] = []

group_reward_entity_ids class-attribute instance-attribute

group_reward_entity_ids: List[str] = []

rollout_instance_ids class-attribute instance-attribute

rollout_instance_ids: List[str] = []

reward_instance_ids class-attribute instance-attribute

reward_instance_ids: List[str] = []

group_reward_instance_ids class-attribute instance-attribute

group_reward_instance_ids: List[str] = []

UploadedData

Bases: BaseModel

Ids minted by rl.upload_data.

Named after the parameters of fine_tunes.create so the result can be forwarded straight through.

training_file_ids class-attribute instance-attribute

training_file_ids: List[str] = []

validation_file_ids class-attribute instance-attribute

validation_file_ids: List[str] = []

Shared async-task models

Long-running services (images, videos, transcription, batch embeddings) share one task contract: jobs.create(...) submits and returns a PENDING/RUNNING Job; jobs.fetch(task_id) reads one snapshot; jobs.wait(job) polls with exponential backoff until a terminal status (SUCCEEDED / FAILED / CANCELED / UNKNOWN) or the wait timeout (default 24 hours) expires; jobs.cancel(task_id) cancels a PENDING task. The one-call generate() helpers submit and wait in one step.

A FAILED task raises by default; with Client(raise_on_error=False) it comes back as the Job envelope instead — check job.status / job.is_error. UNKNOWN is terminal too: the gateway reports it for a task id that does not exist, so check job.succeeded rather than relying on wait() to raise. See Types — raw responses & parsing for how strict_validation, raise_on_error and raw=True interact.

Job

Bases: ResponseBase

One async task snapshot (submit or fetch result).

task_id class-attribute instance-attribute

task_id: str = ''

status class-attribute instance-attribute

status: str = Field(
    "",
    validation_alias=AliasChoices("status", "task_status"),
)

submitted_at class-attribute instance-attribute

submitted_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "submitted_at", "submit_time"
    ),
)

scheduled_at class-attribute instance-attribute

scheduled_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "scheduled_at", "scheduled_time"
    ),
)

finished_at class-attribute instance-attribute

finished_at: Optional[str] = Field(
    None,
    validation_alias=AliasChoices(
        "finished_at", "end_time"
    ),
)

output class-attribute instance-attribute

output: Optional[Dict[str, Any]] = None

usage class-attribute instance-attribute

usage: Optional[Usage] = None

job_id property

job_id: str

FineTune spells the same identifier job_id.

succeeded property

succeeded: bool

finished property

finished: bool

results property

results: List[JobResult]

Artifacts the task produced.

Parsed with the strictness and the response this Job was built with (see :meth:from_payload), so under strict_validation a drifted artifact raises here rather than degrading to None. A Job built directly rather than through from_payload has neither and gets the lenient default.

image_urls property

image_urls: List[str]

video_url property

video_url: Optional[str]

result_url property

result_url: Optional[str]

The single artifact of a one-result task.

from_payload classmethod

from_payload(
    body: Dict[str, Any],
    *,
    strict: bool = False,
    response: Optional[Response] = None
) -> "Job"
Source code in dashscope/resources/_jobs.py
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
@classmethod
def from_payload(
    cls,
    body: Dict[str, Any],
    *,
    strict: bool = False,
    response: Optional[httpx.Response] = None,
) -> "Job":
    output = body.get("output")
    payload = flatten_envelope(body)
    payload["output"] = output if isinstance(output, dict) else None
    if not isinstance(payload.get("usage"), dict):
        payload.pop("usage", None)
    job = parse_model(
        cls,
        payload,
        strict=strict,
        response=response,
    )
    # Post-hoc: private attrs are not fields, so parse_model cannot
    # carry them through validation or through its construct fallback.
    # pylint: disable=protected-access
    job._strict_validation = strict
    job._response = response
    # pylint: enable=protected-access
    return job

JobResult

Bases: BaseModel

One artifact a finished task produced.

Image tasks answer with url, transcription tasks with transcription_url; anything else a service adds stays readable as an attribute.

url class-attribute instance-attribute

url: Optional[str] = None

transcription_url class-attribute instance-attribute

transcription_url: Optional[str] = None

JobList

Bases: BasePage[Job]

One page of async tasks, from jobs.list (1.x GET /tasks).

Each entry in tasks parses with the same aliases as a fetched :class:Job; a FAILED task inside the list is data, not an error.

page_no / page_size / total_count come from :class:~dashscope.types.pagination.BasePage; iterate the page directly or cross pages with iter_pages() / next_page(). The wire reports the total as total, which is aliased onto total_count and also readable through the :attr:total property.

tasks class-attribute instance-attribute

tasks: List[Job] = []

items property

items: List[Job]

total property

total: int

Alias of total_count, keeping the historical field name readable.

from_payload classmethod

from_payload(
    body: Dict[str, Any],
    *,
    strict: bool = False,
    response: Optional[Response] = None
) -> "JobList"
Source code in dashscope/resources/_jobs.py
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
@classmethod
def from_payload(
    cls,
    body: Dict[str, Any],
    *,
    strict: bool = False,
    response: Optional[httpx.Response] = None,
) -> "JobList":
    # The list endpoint answers flat (no ``output`` wrapper), but
    # flatten_envelope also accepts an output-wrapped variant.
    data = flatten_envelope(body)
    tasks = data.pop("tasks", None)
    # A retyped ``tasks`` would blow up in the comprehension below,
    # ahead of the model layer that repairs the field.
    if not isinstance(tasks, list):
        tasks = []
    items = [task for task in tasks if isinstance(task, dict)]
    return parse_model(
        cls,
        {
            "page_no": data.get("page_no", 1),
            "page_size": data.get("page_size", 10),
            "total_count": data.get("total", len(items)),
            "tasks": items,
            **response_envelope(data),
        },
        strict=strict,
        response=response,
    )