Jobs Api

@validate_call
async def create_job(
    self,
    job_create_dto: JobCreateDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Create a manual job

    Run a specific job. Most jobs are queued automatically, but this endpoint allows for manual creation of a handful of jobs, including various cleanup tasks, as well as creating a new database backup.

    :param job_create_dto: (required)
    :type job_create_dto: JobCreateDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._create_job_serialize(
        job_create_dto=job_create_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "204": None,
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

@validate_call
async def create_job_with_http_info(
    self,
    job_create_dto: JobCreateDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Create a manual job

    Run a specific job. Most jobs are queued automatically, but this endpoint allows for manual creation of a handful of jobs, including various cleanup tasks, as well as creating a new database backup.

    :param job_create_dto: (required)
    :type job_create_dto: JobCreateDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._create_job_serialize(
        job_create_dto=job_create_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "204": None,
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

@validate_call
async def create_job_without_preload_content(
    self,
    job_create_dto: JobCreateDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a manual job

    Run a specific job. Most jobs are queued automatically, but this endpoint allows for manual creation of a handful of jobs, including various cleanup tasks, as well as creating a new database backup.

    :param job_create_dto: (required)
    :type job_create_dto: JobCreateDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501

    _param = self._create_job_serialize(
        job_create_dto=job_create_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "204": None,
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    return response_data.response

@validate_call
async def get_queues_legacy(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> QueuesResponseLegacyDto:
    """(Deprecated) Retrieve queue counts and status

    Retrieve the counts of the current queue, as well as the current status.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("GET /jobs is deprecated.", DeprecationWarning)

    _param = self._get_queues_legacy_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueuesResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

@validate_call
async def get_queues_legacy_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[QueuesResponseLegacyDto]:
    """(Deprecated) Retrieve queue counts and status

    Retrieve the counts of the current queue, as well as the current status.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("GET /jobs is deprecated.", DeprecationWarning)

    _param = self._get_queues_legacy_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueuesResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

@validate_call
async def get_queues_legacy_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve queue counts and status

    Retrieve the counts of the current queue, as well as the current status.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("GET /jobs is deprecated.", DeprecationWarning)

    _param = self._get_queues_legacy_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueuesResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    return response_data.response

@validate_call
async def run_queue_command_legacy(
    self,
    name: Annotated[QueueName, Field(description="Queue name")],
    queue_command_dto: QueueCommandDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> QueueResponseLegacyDto:
    """(Deprecated) Run jobs

    Queue all assets for a specific job type. Defaults to only queueing assets that have not yet been processed, but the force command can be used to re-process all assets.

    :param name: Queue name (required)
    :type name: QueueName
    :param queue_command_dto: (required)
    :type queue_command_dto: QueueCommandDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("PUT /jobs/{name} is deprecated.", DeprecationWarning)

    _param = self._run_queue_command_legacy_serialize(
        name=name,
        queue_command_dto=queue_command_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueueResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

@validate_call
async def run_queue_command_legacy_with_http_info(
    self,
    name: Annotated[QueueName, Field(description="Queue name")],
    queue_command_dto: QueueCommandDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[QueueResponseLegacyDto]:
    """(Deprecated) Run jobs

    Queue all assets for a specific job type. Defaults to only queueing assets that have not yet been processed, but the force command can be used to re-process all assets.

    :param name: Queue name (required)
    :type name: QueueName
    :param queue_command_dto: (required)
    :type queue_command_dto: QueueCommandDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("PUT /jobs/{name} is deprecated.", DeprecationWarning)

    _param = self._run_queue_command_legacy_serialize(
        name=name,
        queue_command_dto=queue_command_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueueResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    await response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

@validate_call
async def run_queue_command_legacy_without_preload_content(
    self,
    name: Annotated[QueueName, Field(description="Queue name")],
    queue_command_dto: QueueCommandDto,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
        ],
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Run jobs

    Queue all assets for a specific job type. Defaults to only queueing assets that have not yet been processed, but the force command can be used to re-process all assets.

    :param name: Queue name (required)
    :type name: QueueName
    :param queue_command_dto: (required)
    :type queue_command_dto: QueueCommandDto
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """  # noqa: E501
    warnings.warn("PUT /jobs/{name} is deprecated.", DeprecationWarning)

    _param = self._run_queue_command_legacy_serialize(
        name=name,
        queue_command_dto=queue_command_dto,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index,
    )

    _response_types_map: Dict[str, Optional[str]] = {
        "200": "QueueResponseLegacyDto",
    }
    response_data = await self.api_client.call_api(
        *_param, _request_timeout=_request_timeout
    )
    return response_data.response