Models

class flame_hub.models.CreateNode(*, external_name: str | None, hidden: bool | None, name: str, realm_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], registry_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], type: Literal['aggregator', 'default'] | None)

Bases: BaseModel

external_name: str | None

hidden: bool | None

name: str

realm_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

type: Literal['aggregator', 'default'] | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Node(*, external_name: str | None, hidden: bool | None, name: str, realm_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], registry_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], type: Literal['aggregator', 'default'] | None, id: UUID, public_key: str | None, online: bool, registry: Annotated[Registry | None, IsIncludable] = None, registry_project_id: UUID | None, registry_project: Annotated[RegistryProject | None, IsIncludable] = None, robot_id: UUID, created_at: datetime, updated_at: datetime)

Bases: CreateNode

id: UUID

public_key: str | None

online: bool

registry: Annotated[Registry | None, IsIncludable]

registry_project_id: UUID | None

registry_project: Annotated[RegistryProject | None, IsIncludable]

robot_id: UUID

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateNode(*, hidden: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, external_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, type: ~typing.Literal['aggregator', 'default'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, public_key: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, realm_id: ~typing.Annotated[~uuid.UUID | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, registry_id: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

hidden: bool | type[UNSET]

external_name: str | None | type[UNSET]

type: Literal['aggregator', 'default'] | type[UNSET]

public_key: str | None | type[UNSET]

realm_id: Annotated[UUID | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.MasterImageGroup(*, id: UUID, name: str, path: str, virtual_path: str, created_at: datetime, updated_at: datetime)

Bases: BaseModel

id: UUID

name: str

path: str

virtual_path: str

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.MasterImage(*, id: UUID, path: str | None, virtual_path: str, group_virtual_path: str, name: str, command: str | None, command_arguments: Annotated[list[MasterImageCommandArgument] | None, BeforeValidator(func=ensure_position_none, json_schema_input_type=PydanticUndefined)], created_at: datetime, updated_at: datetime)

Bases: BaseModel

id: UUID

path: str | None

virtual_path: str

group_virtual_path: str

name: str

command: str | None

command_arguments: Annotated[list[MasterImageCommandArgument] | None, BeforeValidator(func=ensure_position_none, json_schema_input_type=PydanticUndefined)]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateProjectNode(*, node_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], project_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

node_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

project_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateProject(*, description: str | None, master_image_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], name: str)

Bases: BaseModel

description: str | None

master_image_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

name: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Project(*, description: str | None, master_image_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], name: str, id: UUID, analyses: int, nodes: int, master_image: Annotated[MasterImage | None, IsIncludable] = None, created_at: datetime, updated_at: datetime, realm_id: UUID, user_id: UUID | None, robot_id: UUID | None)

Bases: CreateProject

id: UUID

analyses: int

nodes: int

master_image: Annotated[MasterImage | None, IsIncludable]

created_at: datetime

updated_at: datetime

realm_id: UUID

user_id: UUID | None

robot_id: UUID | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateProject(*, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, master_image_id: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

description: str | None | type[UNSET]

master_image_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

name: str | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.ProjectNode(*, node_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], project_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, approval_status: Literal['rejected', 'approved'], comment: str | None, created_at: datetime, updated_at: datetime, node: Annotated[Node, IsIncludable] = None, project: Annotated[Project, IsIncludable] = None, project_realm_id: UUID, node_realm_id: UUID)

Bases: CreateProjectNode

id: UUID

approval_status: Literal['rejected', 'approved']

comment: str | None

created_at: datetime

updated_at: datetime

node: Annotated[Node, IsIncludable]

project: Annotated[Project, IsIncludable]

project_realm_id: UUID

node_realm_id: UUID

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysis(*, description: str | None, name: str | None, project_id: ~typing.Annotated[~uuid.UUID, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], master_image_id: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], registry_id: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], image_command_arguments: ~typing.Annotated[list[~flame_hub._core_client.MasterImageCommandArgument], ~pydantic.functional_validators.BeforeValidator(func=~flame_hub._core_client.CreateAnalysis.<lambda>, json_schema_input_type=PydanticUndefined)] = <factory>)

Bases: BaseModel

description: str | None

name: str | None

project_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

master_image_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

registry_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

image_command_arguments: <lambda>, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Analysis(*, description: str | None, name: str | None, project_id: ~uuid.UUID, master_image_id: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], registry_id: ~typing.Annotated[~uuid.UUID | None, ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)], image_command_arguments: ~typing.Annotated[list[~flame_hub._core_client.MasterImageCommandArgument], ~pydantic.functional_validators.BeforeValidator(func=~flame_hub._core_client.CreateAnalysis.<lambda>, json_schema_input_type=PydanticUndefined)] = <factory>, id: ~uuid.UUID, configuration_locked: bool, nodes: int, build_status: ~typing.Literal['starting', 'started', 'stopping', 'stopped', 'finished', 'failed'] | None, run_status: ~typing.Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None, created_at: ~datetime.datetime, updated_at: ~datetime.datetime, registry: ~typing.Annotated[~flame_hub._core_client.Registry | None, ~flame_hub._base_client.IsIncludable] = None, realm_id: ~uuid.UUID, user_id: ~uuid.UUID, project: ~typing.Annotated[~flame_hub._core_client.Project, ~flame_hub._base_client.IsIncludable] = None, master_image: ~typing.Annotated[~flame_hub._core_client.MasterImage | None, ~flame_hub._base_client.IsIncludable] = None)

Bases: CreateAnalysis

id: UUID

configuration_locked: bool

nodes: int

build_status: Literal['starting', 'started', 'stopping', 'stopped', 'finished', 'failed'] | None

run_status: Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None

created_at: datetime

updated_at: datetime

registry: Annotated[Registry | None, IsIncludable]

realm_id: UUID

user_id: UUID

project_id: UUID

project: Annotated[Project, IsIncludable]

master_image: Annotated[MasterImage | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysis(*, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, master_image_id: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, image_command_arguments: list[~flame_hub._core_client.MasterImageCommandArgument] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

description: str | None | type[UNSET]

name: str | None | type[UNSET]

master_image_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

image_command_arguments: list[MasterImageCommandArgument] | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisNode(*, analysis_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], node_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

analysis_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

node_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisNode(*, analysis_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], node_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, approval_status: Literal['rejected', 'approved'] | None, run_status: Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None, comment: str | None, artifact_tag: str | None, artifact_digest: str | None, created_at: datetime, updated_at: datetime, analysis: Annotated[Analysis, IsIncludable] = None, node: Annotated[Node, IsIncludable] = None, analysis_realm_id: UUID, node_realm_id: UUID)

Bases: CreateAnalysisNode

id: UUID

approval_status: Literal['rejected', 'approved'] | None

run_status: Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None

comment: str | None

artifact_tag: str | None

artifact_digest: str | None

created_at: datetime

updated_at: datetime

analysis: Annotated[Analysis, IsIncludable]

node: Annotated[Node, IsIncludable]

analysis_realm_id: UUID

node_realm_id: UUID

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysisNode(*, comment: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, approval_status: ~typing.Literal['rejected', 'approved'] | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, run_status: ~typing.Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

comment: str | None | type[UNSET]

approval_status: Literal['rejected', 'approved'] | None | type[UNSET]

run_status: Literal['starting', 'started', 'running', 'stopping', 'stopped', 'finished', 'failed'] | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisNodeLog(*, analysis_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], node_id: UUID, code: str | None, status: str, message: str | None, level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug'])

Bases: BaseModel

analysis_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

node_id: UUID

code: str | None

status: str

message: str | None

level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug']

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Log(*, time: str | int, message: str | None, level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug'], labels: dict[str, str | None])

Bases: BaseModel

time: str | int

message: str | None

level: Literal['emerg', 'alert', 'crit', 'error', 'warn', 'notice', 'info', 'debug']

labels: dict[str, str | None]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisBucket(*, id: UUID, type: Literal['CODE', 'RESULT', 'TEMP'], external_id: UUID | None, created_at: datetime, updated_at: datetime, analysis_id: UUID, analysis: Annotated[Analysis, IsIncludable] = None, realm_id: UUID)

Bases: BaseModel

id: UUID

type: Literal['CODE', 'RESULT', 'TEMP']

external_id: UUID | None

created_at: datetime

updated_at: datetime

analysis_id: UUID

analysis: Annotated[Analysis, IsIncludable]

realm_id: UUID

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateAnalysisBucketFile(*, name: str, external_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], bucket_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], root: bool)

Bases: BaseModel

name: str

external_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

bucket_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

root: bool

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AnalysisBucketFile(*, name: str, external_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], bucket_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], root: bool, id: UUID, created_at: datetime, updated_at: datetime, realm_id: UUID, user_id: UUID | None, robot_id: UUID | None, analysis_id: UUID, analysis: Annotated[Analysis, IsIncludable] = None, bucket: Annotated[AnalysisBucket, IsIncludable] = None)

Bases: CreateAnalysisBucketFile

id: UUID

created_at: datetime

updated_at: datetime

realm_id: UUID

user_id: UUID | None

robot_id: UUID | None

analysis_id: UUID

analysis: Annotated[Analysis, IsIncludable]

bucket: Annotated[AnalysisBucket, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateAnalysisBucketFile(*, root: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

root: bool | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRegistry(*, name: str, host: str, account_name: str | None, account_secret: Annotated[str | None, IsOptionalField] = None)

Bases: BaseModel

name: str

host: str

account_name: str | None

account_secret: Annotated[str | None, IsOptionalField]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Registry(*, name: str, host: str, account_name: str | None, account_secret: Annotated[str | None, IsOptionalField] = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: CreateRegistry

id: UUID

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRegistry(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, host: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, account_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, account_secret: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

host: str | type[UNSET]

account_name: str | None | type[UNSET]

account_secret: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRegistryProject(*, name: str, type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'], registry_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], external_name: str)

Bases: BaseModel

name: str

type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node']

registry_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

external_name: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RegistryProject(*, name: str, type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'], registry_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], external_name: str, id: UUID, public: bool, external_id: str | None, webhook_name: str | None, webhook_exists: bool | None, realm_id: UUID | None, registry: Annotated[Registry, IsIncludable] = None, account_id: Annotated[str | None, IsOptionalField] = None, account_name: Annotated[str | None, IsOptionalField] = None, account_secret: Annotated[str | None, IsOptionalField] = None, created_at: datetime, updated_at: datetime)

Bases: CreateRegistryProject

id: UUID

public: bool

external_id: str | None

webhook_name: str | None

webhook_exists: bool | None

realm_id: UUID | None

registry: Annotated[Registry, IsIncludable]

account_id: Annotated[str | None, IsOptionalField]

account_name: Annotated[str | None, IsOptionalField]

account_secret: Annotated[str | None, IsOptionalField]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRegistryProject(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, type: ~typing.Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'] | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, registry_id: ~typing.Annotated[~uuid.UUID | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, external_name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

type: Literal['default', 'aggregator', 'incoming', 'outgoing', 'masterImages', 'node'] | type[UNSET]

registry_id: Annotated[UUID | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

external_name: str | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateBucket(*, name: str, region: str | None)

Bases: BaseModel

name: str

region: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.BucketFile(*, id: UUID, name: str, path: str, hash: str, directory: str, size: int | None, created_at: datetime, updated_at: datetime, actor_type: str, actor_id: UUID, bucket_id: UUID, bucket: Annotated[Bucket, IsIncludable] = None)

Bases: BaseModel

id: UUID

name: str

path: str

hash: str

directory: str

size: int | None

created_at: datetime

updated_at: datetime

actor_type: str

actor_id: UUID

bucket_id: UUID

bucket: Annotated[Bucket, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Bucket(*, name: str, region: str | None, id: UUID, created_at: datetime, updated_at: datetime, actor_id: UUID, actor_type: str, realm_id: UUID | None)

Bases: CreateBucket

id: UUID

created_at: datetime

updated_at: datetime

actor_id: UUID

actor_type: str

realm_id: UUID | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UNSET

Bases: BaseModel

Sentinel to mark parameters as unset as opposed to using None.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRealm(*, name: str, display_name: str | None, description: str | None)

Bases: BaseModel

name: str

display_name: str | None

description: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRealm(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, display_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Realm(*, name: str, display_name: str | None, description: str | None, id: UUID, built_in: bool, created_at: datetime, updated_at: datetime)

Bases: CreateRealm

id: UUID

built_in: bool

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRobot(*, name: str, realm_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], secret: Annotated[str, IsOptionalField] = None, display_name: str | None)

Bases: BaseModel

name: str

realm_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

secret: Annotated[str, IsOptionalField]

display_name: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Robot(*, name: str, realm_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], secret: Annotated[str, IsOptionalField] = None, display_name: str | None, id: UUID, description: str | None, active: bool, created_at: datetime, updated_at: datetime, user_id: UUID | None, user: Annotated[User | None, IsIncludable] = None, realm: Annotated[Realm, IsIncludable] = None)

Bases: CreateRobot

id: UUID

description: str | None

active: bool

created_at: datetime

updated_at: datetime

user_id: UUID | None

user: Annotated[User | None, IsIncludable]

realm: Annotated[Realm, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRobot(*, display_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, realm_id: ~typing.Annotated[~uuid.UUID | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, secret: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

display_name: str | None | type[UNSET]

name: str | type[UNSET]

realm_id: Annotated[UUID | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

secret: str | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreatePermission(*, name: str, display_name: str | None, description: str | None, realm_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], policy_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

name: str

display_name: str | None

description: str | None

realm_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

policy_id: Annotated[UUID | None, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Permission(*, name: str, display_name: str | None, description: str | None, realm_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], policy_id: Annotated[UUID | None, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, built_in: bool, client_id: UUID | None, created_at: datetime, updated_at: datetime, realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreatePermission

id: UUID

built_in: bool

client_id: UUID | None

created_at: datetime

updated_at: datetime

realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdatePermission(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, display_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, realm_id: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>, policy_id: ~typing.Annotated[~uuid.UUID | None | type[~flame_hub._base_client.UNSET], ~pydantic.functional_validators.WrapValidator(func=~flame_hub._base_client.uuid_validator, json_schema_input_type=PydanticUndefined)] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

realm_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

policy_id: Annotated[UUID | None | type[UNSET], FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRole(*, name: str, display_name: str | None, description: str | None)

Bases: BaseModel

name: str

display_name: str | None

description: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.Role(*, name: str, display_name: str | None, description: str | None, id: UUID, target: str | None, realm_id: UUID | None, created_at: datetime, updated_at: datetime, realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRole

id: UUID

target: str | None

realm_id: UUID | None

created_at: datetime

updated_at: datetime

realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateRole(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, display_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, description: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

display_name: str | None | type[UNSET]

description: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRolePermission(*, role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

role_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

permission_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RolePermission(*, role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, role_realm_id: UUID | None, permission_realm_id: UUID | None, policy_id: UUID | None, created_at: datetime, updated_at: datetime, role: Annotated[Role, IsIncludable] = None, role_realm: Annotated[Realm | None, IsIncludable] = None, permission: Annotated[Permission, IsIncludable] = None, permission_realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRolePermission

id: UUID

role_realm_id: UUID | None

permission_realm_id: UUID | None

policy_id: UUID | None

created_at: datetime

updated_at: datetime

role: Annotated[Role, IsIncludable]

role_realm: Annotated[Realm | None, IsIncludable]

permission: Annotated[Permission, IsIncludable]

permission_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUser(*, name: str, display_name: str | None, email: Annotated[str | None, IsOptionalField], active: bool, name_locked: bool, first_name: str | None, last_name: str | None)

Bases: BaseModel

name: str

display_name: str | None

email: Annotated[str | None, IsOptionalField]

active: bool

name_locked: bool

first_name: str | None

last_name: str | None

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.User(*, id: UUID, name: str, active: bool, name_locked: bool, email: Annotated[str | None, IsOptionalField] = None, display_name: str | None, first_name: str | None, last_name: str | None, avatar: str | None, cover: str | None, realm_id: UUID, realm: Annotated[Realm, IsIncludable] = None, created_at: datetime, updated_at: datetime)

Bases: BaseModel

id: UUID

name: str

active: bool

name_locked: bool

email: Annotated[str | None, IsOptionalField]

display_name: str | None

first_name: str | None

last_name: str | None

avatar: str | None

cover: str | None

realm_id: UUID

realm: Annotated[Realm, IsIncludable]

created_at: datetime

updated_at: datetime

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UpdateUser(*, name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, display_name: str | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, email: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, active: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, name_locked: bool | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, first_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, last_name: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>, password: str | None | type[~flame_hub._base_client.UNSET] = <class 'flame_hub._base_client.UNSET'>)

Bases: BaseModel

name: str | type[UNSET]

display_name: str | type[UNSET]

email: str | None | type[UNSET]

active: bool | type[UNSET]

name_locked: bool | type[UNSET]

first_name: str | None | type[UNSET]

last_name: str | None | type[UNSET]

password: str | None | type[UNSET]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUserPermission(*, user_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

user_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

permission_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UserPermission(*, user_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, user_realm_id: UUID | None, permission_realm_id: UUID | None, policy_id: UUID | None, created_at: datetime, updated_at: datetime, permission: Annotated[Permission, IsIncludable] = None, user: Annotated[User, IsIncludable] = None, permission_realm: Annotated[Realm | None, IsIncludable] = None, user_realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateUserPermission

id: UUID

user_realm_id: UUID | None

permission_realm_id: UUID | None

policy_id: UUID | None

created_at: datetime

updated_at: datetime

permission: Annotated[Permission, IsIncludable]

user: Annotated[User, IsIncludable]

permission_realm: Annotated[Realm | None, IsIncludable]

user_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateUserRole(*, user_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

user_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

role_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.UserRole(*, user_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, user_realm_id: UUID | None, role_realm_id: UUID | None, created_at: datetime, updated_at: datetime, user: Annotated[User, IsIncludable] = None, role: Annotated[Role, IsIncludable] = None, user_realm: Annotated[Realm | None, IsIncludable] = None, role_realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateUserRole

id: UUID

user_realm_id: UUID | None

role_realm_id: UUID | None

created_at: datetime

updated_at: datetime

user: Annotated[User, IsIncludable]

role: Annotated[Role, IsIncludable]

user_realm: Annotated[Realm | None, IsIncludable]

role_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRobotPermission(*, robot_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

robot_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

permission_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RobotPermission(*, robot_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], permission_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, robot_realm_id: UUID | None, permission_realm_id: UUID | None, policy_id: UUID | None, created_at: datetime, updated_at: datetime, robot: Annotated[Robot, IsIncludable] = None, permission: Annotated[Permission, IsIncludable] = None, robot_realm: Annotated[Realm | None, IsIncludable] = None, permission_realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRobotPermission

id: UUID

robot_realm_id: UUID | None

permission_realm_id: UUID | None

policy_id: UUID | None

created_at: datetime

updated_at: datetime

robot: Annotated[Robot, IsIncludable]

permission: Annotated[Permission, IsIncludable]

robot_realm: Annotated[Realm | None, IsIncludable]

permission_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.CreateRobotRole(*, robot_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)])

Bases: BaseModel

robot_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

role_id: Annotated[UUID, FieldInfo(annotation=NoneType, required=True), WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RobotRole(*, robot_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], role_id: Annotated[UUID, WrapValidator(func=uuid_validator, json_schema_input_type=PydanticUndefined)], id: UUID, robot_realm_id: UUID | None, role_realm_id: UUID | None, created_at: datetime, updated_at: datetime, robot: Annotated[Robot, IsIncludable] = None, role: Annotated[Role, IsIncludable] = None, robot_realm: Annotated[Realm | None, IsIncludable] = None, role_realm: Annotated[Realm | None, IsIncludable] = None)

Bases: CreateRobotRole

id: UUID

robot_realm_id: UUID | None

role_realm_id: UUID | None

created_at: datetime

updated_at: datetime

robot: Annotated[Robot, IsIncludable]

role: Annotated[Role, IsIncludable]

robot_realm: Annotated[Realm | None, IsIncludable]

role_realm: Annotated[Realm | None, IsIncludable]

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.IsOptionalField

Bases: object

Sentinel to annotate model attributes as optional fields.

class flame_hub.models.IsIncludable

Bases: object

Sentinel to annotate model attributes as includable.

class flame_hub.models.ResourceListMeta(*, total: int, **extra_data: Any)

Bases: BaseModel

Resource for meta information on list responses.

See also

_get_all_resources(), _find_all_resources()

model_config: ClassVar[ConfigDict] = {'extra': 'allow'}

Based on the type of the request, additional attributes like limit or offset may be available.

total: int

The total amount of records of a specific resource type.

class flame_hub.models.ResourceList(*, data: list[ResourceT], meta: ResourceListMeta)

Bases: BaseModel, Generic[ResourceT]

Resource for list responses.

See also

_get_all_resources(), _find_all_resources()

data: list[ResourceT]

Attribute which holds all retrieved resources as a list.

meta: ResourceListMeta

Attribute which holds meta information about the result and the requested resource type.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.AccessToken(*, access_token: str, expires_in: int, token_type: str, scope: str)

Bases: BaseModel

access_token: str

expires_in: int

token_type: str

scope: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class flame_hub.models.RefreshToken(*, access_token: str, expires_in: int, token_type: str, scope: str, refresh_token: str)

Bases: AccessToken

refresh_token: str

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].