roboto.query

Bases: ConditionVisitor

Query base visitor

BaseVisitor.visit_condition()

BaseVisitor.visit_condition_group()

Bases: _FilterBase

True or false, or unset.

Bases: roboto.compat.StrEnum

The comparator to use when comparing a field to a value.

Comparator.from_string()

Comparator.to_compact_string()

Bases: pydantic.BaseModel

A filter for any arbitrary attribute for a Roboto resource.

Condition.equals_cond()

Condition.matches()

Condition.target_unspecified()

Condition.targets_dataset()

Condition.targets_file()

Condition.targets_message_path()

Condition.targets_topic()

Bases: pydantic.BaseModel

A group of conditions that are combined together.

ConditionGroup.and_group()

ConditionGroup.matches()

ConditionGroup.or_group()

ConditionGroup.validate_conditions()

Bases: roboto.compat.StrEnum

The operator to use when combining multiple conditions.

ConditionOperator.from_string()

Bases: abc.ABC

Query condition visitor

ConditionVisitor.visit()

ConditionVisitor.visit_condition()

ConditionVisitor.visit_condition_group()

Default page size for search.

Bases: _FilterBase

Instants and ranges. Values are ISO 8601 strings.

The only variant offering relative windows, which is where the fidelity problem this whole model exists for actually bites.

Bases: _FilterBase

Equality against a closed set of options.

Bases: str

A string-like field path that parses resource qualifiers and extracts the target path.

Field extends str to provide automatic parsing of qualified field paths like “dataset.metadata.owner” or “topic.name” into their constituent parts. It identifies the target resource type (dataset, file, topic, or message_path) and extracts the actual field path within that resource.

The class supports both qualified paths (e.g., “dataset.org_id”) and unqualified paths (e.g., “org_id”). For qualified paths, it strips the resource prefix and stores both the original fully qualified path and the extracted target information.

Usage

field = Field("dataset.metadata.foo")
field.target.resource
# 'dataset'
field.target.path
# 'metadata.foo'

field = Field("org_id")
field.target.resource is None
# True
field.target.path
# 'org_id'

Field.wrap()

One filter row. type selects the variant, and with it the operators on offer.

Bases: roboto.compat.StrEnum

How separate filters combine.

Bases: roboto.compat.StrEnum

Operators a saved filter needs that Comparator cannot express.

Every member is a gap in the query language, and this enum is the list of them. It is the complement of Comparator, never a superset: a member here that Comparator can express is a stale entry.

Members are removed one at a time as Comparator grows to cover them. The wire values do not change when that happens, so filters saved beforehand keep parsing.

Bases: roboto.compat.StrEnum

Operators over a principal-valued field, where the operator names a principal type.

An audit column such as created_by stores a fully-qualified principal — user:<user_id>, device:<device_id>@<org_id>, invocation:<invocation_id> — so “created by a user” is a question about the type prefix and “created by this user” a question about the whole value. Putting the type in the operator is what lets a filter UI offer the matching directory to pick from, instead of asking for a hand-typed prefix.

Each type contributes two operators (see IDENTITY_OPERATORS_BY_TYPE): a value-bearing IS_<TYPE> and a valueless IS_ANY_<TYPE>.

Separate from FilterOnlyComparator because these are not gaps in the query language. Both halves are expressible as a query today — IS_<TYPE> as EQUALS against each picked principal, IS_ANY_<TYPE> as LIKE '<type>:%' — so they are never removed. They are a filter-control affordance, and they outlive the gap enum.

Bases: _FilterBase

A principal-valued field, filtered by principal type.

Audit columns (created_by, modified_by) hold a fully-qualified principal string, so the operator names the type (IdentityComparator) and any values it takes are principals of that type — an IS_USER filter carrying a device: value is rejected, since it records an intent the picker cannot express and a query cannot satisfy.

Values are labeled options rather than bare strings: a principal id is not a name a reader can place, so the directory’s display name is captured alongside it at pick time.

Has no presence axis. Every write path stamps an audit principal, so the column is never null and a null check would be an operator that always answers the same way.

Bases: pydantic.BaseModel

One option as it was picked: the value a query is built from, plus what the picker showed.

Both halves are stored because the label cannot be recovered later. An opaque value — user:usr_01J..., a tag id — renders as itself, and resolving it on load would mean a directory lookup per chip, against an org that whoever opens a shared View may not be able to read. Only value ever reaches a query.

Maximum allowable page size for search.

Prefix distinguishing a user-defined metric from an ordinary numeric property.

Metric filters store the prefixed form so that field means the same thing here as it does in a Condition, and translating a filter into a query copies the field across rather than special-casing it.

Bases: _FilterBase

Ordering and equality over a user-defined metric.

Numeric in every respect except that field is a metric path. Kept a distinct variant so a client restoring a View knows to reopen the metric picker rather than the property form, which it cannot infer from the field name alone.

Carries the presence pair like any other scalar type. A session may simply have no such metric recorded, and the session query path answers that directly — it maps IS_NULL to a NOT EXISTS over the metrics table.

Bases: _FilterBase

Ordering and equality over a numeric property.

Bases: pydantic.BaseModel

A RoboQL query which has been qualified with a target.

A low-level Roboto query client. Prefer RobotoSearch for a simpler, more curated query interface.

QueryClient.are_query_results_available()

QueryClient.get_query_record()

QueryClient.get_query_results()

QueryClient.submit_query()

QueryClient.submit_roboql()

QueryClient.submit_roboql_and_await_results()

QueryClient.submit_structured()

QueryClient.submit_structured_and_await_results()

QueryClient.submit_term()

QueryClient.submit_term_and_await_results()

Bases: roboto.compat.StrEnum

Hint to query APIs on whether to return Roboto entities with custom metadata.

In RecordOnly mode, Roboto entities are returned without custom metadata, ensuring a smaller and more predictable response size. Use this mode when you need lower query latency, larger result page sizes, or both.

In RecordWithMeta mode, Roboto entities are returned with all available custom metadata. Use this mode if you need immediate access to metadata fields.

Note: content mode support is initially available for dataset queries, and will be added incrementally for other entity types.

Bases: pydantic.BaseModel

Context for a query

Bases: pydantic.BaseModel

A wire-transmissible representation of a query.

Bases: roboto.compat.StrEnum

A specific query format/schema which can be used in combination with some context JSON to provide all information required to execute a query.

Bases: pydantic.BaseModel

Model for specifying a query to the Roboto Platform.

Usage

Specify a query with a single condition:

>>> from roboto import query >>> query_spec = query.QuerySpecification( … condition=query.Condition(field=“name”, comparator=query.Comparator.Equals, value=“Roboto”) … )

Specify a query with multiple conditions:

>>> from roboto import query >>> query_spec = query.QuerySpecification( … condition=query.ConditionGroup( … operator=query.ConditionOperator.And, … conditions=[ … query.Condition(field=“name”, comparator=query.Comparator.Equals, value=“Roboto”), … query.Condition(field=“age”, comparator=query.Comparator.GreaterThan, value=18), … ], … ) … )

Arbitrarily nest condition groups:

>>> from roboto import query >>> query_spec = query.QuerySpecification( … condition=query.ConditionGroup( … operator=query.ConditionOperator.And, … conditions=[ … query.Condition(field=“name”, comparator=query.Comparator.Equals, value=“Roboto”), … query.ConditionGroup( … operator=query.ConditionOperator.Or, … conditions=[ … query.Condition(field=“age”, comparator=query.Comparator.GreaterThan, value=18), … query.Condition(field=“age”, comparator=query.Comparator.LessThan, value=30), … ], … ), … ], … ) … )

QuerySpecification.fields()

Bases: enum.Enum

The query lifecycle state of a given query.

Bases: pydantic.BaseModel

Context for query storage

Bases: roboto.compat.StrEnum

A specific query result storage format/schema which can be used in combination with some context JSON to provide all information required to vend query results

Bases: roboto.compat.StrEnum

The type of resource a specific query is requesting.

Bases: pydantic.BaseModel

A complete set of filter controls, as saved.

Bases: _FilterBase

Membership in a collection-valued field, such as tags.

Has no presence axis: an empty collection is not the same as an absent one, and the UI offers no null check here.

Bases: roboto.compat.StrEnum

The direction to sort the results of a query.

SortDirection.from_string()

Bases: _FilterBase

Text matching.

Bases: pydantic.BaseModel

Request payload to submit a RoboQL query

Bases: pydantic.BaseModel

Request payload to submit a structured query

Bases: pydantic.BaseModel

Request payload to submit a simple term query