roboto.exceptions.domain

Module Contents

AUTHENTICATION_FAILURE_MESSAGE

roboto.exceptions.domain.AUTHENTICATION_FAILURE_MESSAGE = 'Authentication to Roboto failed. This generally happens if the value in your...#

ReadPlanExecutionErrorKind

class roboto.exceptions.domain.ReadPlanExecutionErrorKind#

Bases: roboto.compat.StrEnum

Why a read of topic data through a read plan cannot continue.

Attributes

ReadPlanExecutionErrorKind.DATA_RANGE_NOT_IN_FILE

DATA_RANGE_NOT_IN_FILE = 'data-range-not-in-file' #

A partition’s data_range ends past its file’s stored row count, so the file lacks rows the slice names.

ReadPlanExecutionErrorKind.FIELD_NOT_IN_FILE

FIELD_NOT_IN_FILE = 'field-not-in-file' #

A file lacks a field the read takes from it: a field it supplies, or the partition’s timestamp field.

ReadPlanExecutionErrorKind.FIELD_SPLIT_INSIDE_NON_STRUCT

FIELD_SPLIT_INSIDE_NON_STRUCT = 'field-split-inside-non-struct' #

A partition’s files split a field that one of them stores as other than a struct, such as a list or a map.

ReadPlanExecutionErrorKind.INCONSISTENT_SCAN_TASKS_ON_FILE

INCONSISTENT_SCAN_TASKS_ON_FILE = 'inconsistent-scan-tasks-on-file' #

Scan tasks of one partition read one file but disagree on its format, transformations or topic name.

ReadPlanExecutionErrorKind.INVALID_TIMESTAMP

INVALID_TIMESTAMP = 'invalid-timestamp' #

A stored timestamp has no signed 64-bit nanosecond value once shifted by its partition’s time_offset_ns: it is NaN or infinite, a DECIMAL holding a fraction of a nanosecond, or out of range.

ReadPlanExecutionErrorKind.PARTITION_SCHEMA_MISMATCH

PARTITION_SCHEMA_MISMATCH = 'partition-schema-mismatch' #

A later partition’s files give the read a different schema than the first partition’s.

ReadPlanExecutionErrorKind.PLAN_WITHOUT_SCHEMA

PLAN_WITHOUT_SCHEMA = 'plan-without-schema' #

The plan projects every field of its schema, has a partition with a scan task, and names no schema.

ReadPlanExecutionErrorKind.PROJECTED_FIELD_IN_NO_SCAN_TASK

PROJECTED_FIELD_IN_NO_SCAN_TASK = 'projected-field-in-no-scan-task' #

No scan task of a partition reads the whole schema or a subtree containing a projected field.

ReadPlanExecutionErrorKind.SCAN_TASK_ROW_MISMATCH

SCAN_TASK_ROW_MISMATCH = 'scan-task-row-mismatch' #

The files of a partition hold different rows in the window.

ReadPlanExecutionErrorKind.UNSUPPORTED_FORMAT

UNSUPPORTED_FORMAT = 'unsupported-format' #

A scan task stores its data in a format other than MCAP and Parquet, the formats the readers decode.

ReadPlanExecutionErrorKind.UNSUPPORTED_TIMESTAMP

UNSUPPORTED_TIMESTAMP = 'unsupported-timestamp' #

The partition’s timestamp is one the readers refuse: a kind they do not know; a schema field with no path; a unit other than s, ms, us or ns; a message log or publish time on a Parquet file; or a Parquet timestamp field inside a list or map, holding a DATE or TIME, or not a number.

RobotoAuthenticationFailureException

exception roboto.exceptions.domain.RobotoAuthenticationFailureException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when authentication fails

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoAuthenticationFailureException.http_status_code

http_status_code int #

Return type: int

RobotoConditionException

exception roboto.exceptions.domain.RobotoConditionException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown if there is a failed condition

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoConditionException.http_status_code

http_status_code int #

Return type: int

RobotoConflictException

exception roboto.exceptions.domain.RobotoConflictException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown if there is a conflict between a resource you’re creating and another existing resource

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoConflictException.http_status_code

http_status_code int #

Return type: int

RobotoContextTooLongException

exception roboto.exceptions.domain.RobotoContextTooLongException(message, stack_trace=[], headers={}, estimated_tokens=0, max_tokens=0, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when the conversation context (messages, system prompt, tool results) exceeds the model’s context window limit.

The token estimate and the model’s context limit are not carried on the exception, so a caller cannot read usage numbers off it.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

estimated_tokens int

max_tokens int

Properties

RobotoContextTooLongException.http_status_code

http_status_code int #

Return type: int

RobotoDashboardRevisionConflictException

exception roboto.exceptions.domain.RobotoDashboardRevisionConflictException(message, current_dashboard, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoConflictException

Thrown when a dashboard definition write carries a base revision that no longer matches the stored one — someone replaced the definition after the requester loaded it, so applying the write would erase their edit.

Carries the server’s current dashboard record, read under the same row lock that rejected the write, so a client can show both sides and let the user resolve without a second round trip.

Parameters

message str

current_dashboard dict[str, Any]

stack_trace list[str]

headers dict[str, str]

Attributes

RobotoDashboardRevisionConflictException.current_dashboard

current_dashboard #

RobotoDashboardRevisionConflictException.to_dict()

to_dict()#

Return type

dict[str, Any]

RobotoDatasetNotFoundException

exception roboto.exceptions.domain.RobotoDatasetNotFoundException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoNotFoundException

Specialization of RobotoNotFoundException for datasets.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

RobotoDeprecatedException

exception roboto.exceptions.domain.RobotoDeprecatedException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when an old API endpoint is called, to tell the client to upgrade

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoDeprecatedException.http_status_code

http_status_code int #

Return type: int

RobotoDeviceNotFoundException

exception roboto.exceptions.domain.RobotoDeviceNotFoundException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoNotFoundException

Specialization of RobotoNotFoundException for devices.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

RobotoDomainException

exception roboto.exceptions.domain.RobotoDomainException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: Exception

Expected exceptions from the Roboto domain entity objects.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoDomainException.error_code

error_code str #

Return type: str

RobotoDomainException.from_client_error()

static from_client_error(error)#

Parameters

error roboto.exceptions.http.HttpError

Return type

RobotoDomainException

RobotoDomainException.from_json()

static from_json(contents, headers={})#

Parameters

contents dict[str, Any]

headers dict[str, str]

Return type

RobotoDomainException

RobotoDomainException.from_json_string()

static from_json_string(contents)#

Parameters

contents str

Return type

RobotoDomainException

Properties

RobotoDomainException.headers

headers dict[str, str] #

Return type: dict[str, str]

RobotoDomainException.http_status_code

http_status_code int #

Return type: int

RobotoDomainException.message

message str #

Return type: str

RobotoDomainException.serialize()

serialize()#

Return type

str

Properties

RobotoDomainException.stack_trace

stack_trace list[str] #

Return type: list[str]

RobotoDomainException.to_dict()

to_dict()#

Return type

dict[str, Any]

RobotoExpiredException

exception roboto.exceptions.domain.RobotoExpiredException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown if a resource is missing or expired.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoExpiredException.http_status_code

http_status_code int #

Return type: int

RobotoFailedToGenerateException

exception roboto.exceptions.domain.RobotoFailedToGenerateException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when Roboto fails to generate a resource due to an internal error.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoFailedToGenerateException.http_status_code

http_status_code int #

Return type: int

RobotoFeatureNotAvailableException

exception roboto.exceptions.domain.RobotoFeatureNotAvailableException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when a route is gated by a feature flag that is not enabled for the caller.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoFeatureNotAvailableException.http_status_code

http_status_code int #

Return type: int

RobotoHttpExceptionParse

class roboto.exceptions.domain.RobotoHttpExceptionParse#

Bases: object

RobotoIllegalArgumentException

exception roboto.exceptions.domain.RobotoIllegalArgumentException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when request parameters are in some way invalid

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoIllegalArgumentException.http_status_code

http_status_code int #

Return type: int

RobotoInternalException

exception roboto.exceptions.domain.RobotoInternalException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when Roboto throws an unexpected internal error, expected to be systemic.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoInternalException.http_status_code

http_status_code int #

Return type: int

RobotoInvalidRequestException

exception roboto.exceptions.domain.RobotoInvalidRequestException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when request parameters are in some way invalid

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoInvalidRequestException.http_status_code

http_status_code int #

Return type: int

RobotoInvalidStateTransitionException

exception roboto.exceptions.domain.RobotoInvalidStateTransitionException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when requesting update of state to an invalid state, or via an invalid transition path

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoInvalidStateTransitionException.http_status_code

http_status_code int #

Return type: int

RobotoLayoutConflictException

exception roboto.exceptions.domain.RobotoLayoutConflictException(message, conflicting_layouts, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoConflictException

Thrown when multiple layouts with the same name are found and need disambiguation. Contains the conflicting layout records for client handling.

Parameters

message str

conflicting_layouts list[dict[str, Any]]

stack_trace list[str]

headers dict[str, str]

Attributes

RobotoLayoutConflictException.conflicting_layouts

conflicting_layouts #

RobotoLayoutConflictException.to_dict()

to_dict()#

Return type

dict[str, Any]

RobotoLimitExceededException

exception roboto.exceptions.domain.RobotoLimitExceededException(message, stack_trace=[], *args, resource_name='Unknown', current_quantity=0, limit_quantity=0, **kwargs)#

Bases: RobotoDomainException

Thrown if an operation would exceed a user or org level limit.

Parameters

message str

stack_trace list[str]

resource_name str

current_quantity int

limit_quantity int

Properties

RobotoLimitExceededException.current_quantity

current_quantity int #

Return type: int

RobotoLimitExceededException.http_status_code

http_status_code int #

Return type: int

RobotoLimitExceededException.limit_quantity

limit_quantity int #

Return type: int

RobotoLimitExceededException.resource_name

resource_name str #

Return type: str

RobotoLimitExceededException.to_dict()

to_dict()#

Return type

dict[str, Any]

RobotoNoOrgProvidedException

exception roboto.exceptions.domain.RobotoNoOrgProvidedException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when no org is provided to an operation which requires an org.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoNoOrgProvidedException.http_status_code

http_status_code int #

Return type: int

RobotoNotFoundException

exception roboto.exceptions.domain.RobotoNotFoundException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Throw when a requested resource does not exist

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoNotFoundException.http_status_code

http_status_code int #

Return type: int

RobotoNotImplementedException

exception roboto.exceptions.domain.RobotoNotImplementedException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown by shimmed out APIs which have not yet been implemented

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoNotImplementedException.http_status_code

http_status_code int #

Return type: int

RobotoNotReadyException

exception roboto.exceptions.domain.RobotoNotReadyException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Throw when a requested resource is resolvable by ID/context but is not fully initialized or ready to be served.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoNotReadyException.http_status_code

http_status_code int #

Return type: int

RobotoOperationTimeoutException

exception roboto.exceptions.domain.RobotoOperationTimeoutException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoServiceTimeoutException

Raised when an operation exceeds Roboto’s time budget and is aborted.

Roboto bounds certain operations with a time budget; exceeding it aborts the operation rather than letting it run unbounded. This is expected to be transient and ought to be retried.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoOperationTimeoutException.http_status_code

http_status_code int #

Return type: int

RobotoReadPlanExecutionException

exception roboto.exceptions.domain.RobotoReadPlanExecutionException(message, stack_trace=[], headers={}, *args, kind, field_path=None, row_number=None, **kwargs)#

Bases: RobotoInternalException

Thrown when a read of topic data through a read plan cannot continue, with the reason as its kind.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

kind ReadPlanExecutionErrorKind | str

field_path Optional[collections.abc.Sequence[str]]

row_number Optional[int]

Properties

RobotoReadPlanExecutionException.field_path

field_path tuple[str, ...] | None #

For field-not-in-file, the missing field’s path components, from its top-level field down to the first component the file lacks.

Return type: Optional[tuple[str, ...]]

RobotoReadPlanExecutionException.kind

kind ReadPlanExecutionErrorKind #

Why the read cannot continue.

Return type: ReadPlanExecutionErrorKind

RobotoReadPlanExecutionException.row_number

row_number int | None #

For invalid-timestamp, the row’s 0-based position among its topic’s rows in its file.

Return type: Optional[int]

RobotoReadPlanExecutionException.to_dict()

to_dict()#

Return type

dict[str, Any]

RobotoResponseTooLargeException

exception roboto.exceptions.domain.RobotoResponseTooLargeException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when the server cannot complete the request because the response payload exceeds a storage or transport capacity limit (e.g., Lambda response size). This is NOT expected to be transient and should NOT be retried.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoResponseTooLargeException.http_status_code

http_status_code int #

Return type: int

RobotoServiceException

exception roboto.exceptions.domain.RobotoServiceException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when Roboto Service failed in an unexpected way

Parameters

message str

stack_trace list[str]

headers dict[str, str]

RobotoServiceTimeoutException

exception roboto.exceptions.domain.RobotoServiceTimeoutException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when the service times out while processing a request. This is exepcted to be transient and ought to be retried.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoServiceTimeoutException.http_status_code

http_status_code int #

Return type: int

RobotoServiceUnavailableException

exception roboto.exceptions.domain.RobotoServiceUnavailableException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when a service is unavailable, such as when it’s under heavy load and can’t accept new requests. This is expected to be transient and ought to be retried.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoServiceUnavailableException.http_status_code

http_status_code int #

Return type: int

RobotoThreadReadOnlyException

exception roboto.exceptions.domain.RobotoThreadReadOnlyException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when adding to an agent thread that another surface owns.

A thread with an origin is mirrored into a conversation Roboto does not own, so appending to it over the API would leave that mirror incomplete.

Not an authorization failure, and not a subclass of RobotoUnauthorizedException: the caller may read, cancel, and rate the thread, and forking it yields a writable copy. Nothing about their identity would change the answer, so a client should offer the fork rather than send them to re-authenticate.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoThreadReadOnlyException.http_status_code

http_status_code int #

Return type: int

RobotoUnauthorizedException

exception roboto.exceptions.domain.RobotoUnauthorizedException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown when a user is attempting to access a resource that they do not have permission to access

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoUnauthorizedException.http_status_code

http_status_code int #

Return type: int

RobotoUnknownOperationException

exception roboto.exceptions.domain.RobotoUnknownOperationException(message, stack_trace=[], headers={}, *args, **kwargs)#

Bases: RobotoDomainException

Thrown if a user is attempting to perform an action unrecognized by the Roboto platform.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

Properties

RobotoUnknownOperationException.http_status_code

http_status_code int #

Return type: int

RobotoUnrecognizedErrorException

exception roboto.exceptions.domain.RobotoUnrecognizedErrorException(message, stack_trace=[], headers={}, error_code=None, *args, **kwargs)#

Bases: RobotoDomainException

An error the platform reported that this SDK release cannot resolve to a specific exception class.

Reported for an element of a BatchResponse whose error names a code this release defines no class for, or that arrived without a code, without a message, or as text that is not an error envelope at all. It carries whatever code and message the platform sent, so a caller handling the failure still learns what went wrong; when no message could be read, the message is the error’s raw text.

The error envelope carries no status code, so http_status_code reports the 500 inherited from RobotoDomainException rather than the status the failure actually had.

Parameters

message str

stack_trace list[str]

headers dict[str, str]

error_code Optional[str]

Properties

RobotoUnrecognizedErrorException.error_code

error_code str #

The code the platform sent, or this class’s name when the error arrived without one.

Return type: str