# Python client API

## The Debusine class

class debusine.client.debusine.Debusine(base_api_url: str, api_token: str | None = None, scope: str | None = None, *, logger: Logger)

  Bases: `object`

  Class to interact with debusine server.

  API_VERSION = '1.0'
  __init__(base_api_url: str, api_token: str | None = None, scope: str | None = None, *, logger: Logger)

    Initialize client.

    Parameters:

      - base_api_url – URL for API endpoint (e.g. http://localhost/api)

      - api_token – optional token to be used for the calls.

  artifact_create(artifact: LocalArtifact[Any], *, workspace: str | None, work_request: int | None = None, expire_at: datetime | None = None) → ArtifactResponse

    Create artifact in the debusine server.

  artifact_get(artifact_id: int, workspace: str | None = None) → ArtifactResponse

    Get artifact information.

    Use download_artifact() to download the artifact.

  asset_create(category: AssetCategory, data: BaseAssetDataModel, *, workspace: str, work_request: int | None = None) → AssetResponse

    Create asset in the debusine server.

  asset_list(*, asset_id: int | None = None, work_request: int | None = None, workspace: str | None = None) → AssetsResponse

    Create asset in the debusine server.

  asset_permission_check(*, asset_category: str, asset_slug: str, permission_name: str, artifact_id: int, work_request_id: int, workspace: str) → AssetPermissionCheckResponse

    Check work_request’s permission to use an asset on an artifact.

  collection_create(workspace: str, data: CollectionDataNew) → CollectionData

    Create a new collection.

  collection_delete(workspace: str, data: CollectionData) → None

    Delete a collection.

  collection_get(workspace: str, category: str, name: str, with_stats: bool = False) → CollectionData

    Fetch information about a collection.

  collection_iter(workspace: str) → Iterable[CollectionData]

    List collections on a workspace.

  collection_update(workspace: str, data: CollectionData) → CollectionData

    Set information for a collection.

  download_artifact(artifact_id: int, destination: Path, *, tarball: bool = False, workspace: str | None = None) → ArtifactResponse

    Download artifact_id into destination directory.

    Parameters:

      - artifact_id – artifact id to download

      - destination – destination directory to download/uncompress

      - tarball – True to only download the tarball (artifact-id.tar.gz), False to uncompress it

  download_artifact_file(artifact_id: int | ArtifactResponse, path_in_artifact: str, destination: Path, workspace: str | None = None) → ArtifactResponse

    Download a single file from artifact into destination directory.

    Parameters:

      - artifact_id – artifact id to download, or an `ArtifactResponse` representing the artifact

      - path_in_artifact – download the file from the artifact with this name

      - destination – destination file to download to

  emit_metric(*, metric_type: Literal['counter', 'gauge', 'summary', 'histogram'], name: str, labels: dict[str, str], value: float) → None

    Ask the server to emit a metric on behalf of this client.

  fetch_task_configuration_collection(*, workspace: str, name: str) → RemoteTaskConfigurationRepository

    Fetch a task configuration collection.

  get_workspace_inheritance(workspace: str) → WorkspaceInheritanceChain

    Get a workspace inheritance chain.

  lookup_multiple(lookup: LookupMultiple, work_request: int, expect_type: Literal[LookupChildType.ARTIFACT], default_category: CollectionCategory | None = None) → LookupMultipleResponse[LookupSingleResponseArtifact]
  lookup_multiple(lookup: LookupMultiple, work_request: int, expect_type: Literal[LookupChildType.COLLECTION], default_category: CollectionCategory | None = None) → LookupMultipleResponse[LookupSingleResponseCollection]
  lookup_multiple(lookup: LookupMultiple, work_request: int, expect_type: LookupChildType, default_category: CollectionCategory | None = None) → LookupMultipleResponse[LookupSingleResponse]

    Look up multiple collection items.

  lookup_single(lookup: LookupSingle, work_request: int, expect_type: Literal[LookupChildType.ARTIFACT], default_category: CollectionCategory | None = None) → LookupSingleResponseArtifact
  lookup_single(lookup: LookupSingle, work_request: int, expect_type: Literal[LookupChildType.COLLECTION], default_category: CollectionCategory | None = None) → LookupSingleResponseCollection
  lookup_single(lookup: LookupSingle, work_request: int, expect_type: LookupChildType, default_category: CollectionCategory | None = None) → LookupSingleResponse

    Look up a single collection item.

  on_work_request_completed(*, workspaces: list[str] | None = None, last_completed_at: Path | None = None, command: list[str], working_directory: Path) → None

    Execute command when a work request is completed.

  async process_async_message(msg: WSMessage, msg_text_to_callable: dict[str, _MessageProcessor]) → bool

    Process “msg”: logs possible error, raise errors.

    If msg.type is aiohttp.WSMsgType.TEXT: decode msg.data (contains JSON), call callable msg_text_to_callable[msg.data[“text”]](msg_content: dict).

    Return True a callable from msg_to_callable is called or False if not (invalid messages, etc.).

    Raises:

      TokenDisabledError – if reason_code is TOKEN_DISABLED.

  push_task_configuration_collection(*, repo: LocalTaskConfigurationRepository, dry_run: bool) → TaskConfigurationCollectionUpdateResults

    Replace the contents of a task configuration collection on server.

  relation_create(artifact_id: int, target_id: int, relation_type: RelationType) → RelationResponse

    Create a new relation between artifacts.

    Parameters:

      - artifact_id – relation from

      - target_id – relation to

      - relation_type – type of relation such as extends, relates-to, built-using

    Returns:

      True if the relation already existed/has been created, False if it could not be created

  relation_list(*, artifact_id: int | None = None, target_id: int | None = None) → RelationsResponse

    List relations associated with an artifact.

    Exactly one of artifact_id or target_id must be set.

    Parameters:

      - artifact_id – search for relations from this artifact

      - target_id – search for relations to this artifact

    Returns:

      a list of relations

    Raises:

      ValueError – if exactly one of artifact_id or target_id is not set

  set_workspace_inheritance(workspace: str, *, chain: WorkspaceInheritanceChain) → WorkspaceInheritanceChain

    Set a workspace inheritance chain.

  upload_artifact(local_artifact: LocalArtifact[Any], *, workspace: str | None, work_request: int | None = None, expire_at: datetime | None = None) → RemoteArtifact

    Upload (create and upload files) the local_artifact to the server.

  upload_files(artifact_id: int, upload_files: dict[str, Path], base_directory: Path | None = None) → None

    Upload into artifact the files.

    Parameters:

      - artifact_id – artifact_id to upload files to.

      - upload_files – list of files to upload.

      - base_directory – base directory for relative path’s files to upload.

  webui_url(path: str) → str

    Generate a URL to the web UI given a full path.

  work_request_abort(work_request_id: int) → WorkRequestResponse

    Abort a work request.

  static work_request_completed_path(work_request_id: int) → str

    Return path to update the completed result for work_request_id.

  work_request_completed_update(work_request_id: int, result: WorkRequestResults, output_data: OutputData) → None

    Update work_request_id as completed with result.

  work_request_create(work_request: WorkRequestRequest) → WorkRequestResponse

    Create a work request (via POST /work-request/).

    Returns:

      WorkRequest returned by the server.

    Raises:

      see _api_request method documentation.

  work_request_external_debsign_complete(work_request_id: int, external_debsign_request: WorkRequestExternalDebsignRequest) → WorkRequestResponse

    Provide external debsign data to a work request.

  work_request_external_debsign_get(work_request_id: int) → WorkRequestResponse

    Get data about work request waiting for an external debsign.

  work_request_get(work_request_id: int) → WorkRequestResponse

    Get WorkRequest for work_request_id.

    Parameters:

      work_request_id – id to fetch the status of.

    Raises:

      many – see _api_request method documentation.

  work_request_iter() → Iterable[WorkRequestResponse]

    List all WorkRequests.

    Raises:

      many – see _api_request method documentation.

  work_request_retry(work_request_id: int) → WorkRequestResponse

    Retry a work request.

  work_request_update(work_request_id: int, *, priority_adjustment: int) → WorkRequestResponse

    Update properties of work_request_id.

  workflow_create(create_workflow: CreateWorkflowRequest) → WorkRequestResponse

    Create a workflow (via POST /workflow/).

    Returns:

      Workflow WorkRequest returned by the server.

    Raises:

      see _api_request method documentation.

  workflow_template_create(workspace: str, workflow_template: WorkflowTemplateDataNew) → WorkflowTemplateData

    Create a workflow template (via POST /workflow-template/{workspace}/).

    Returns:

      WorkflowTemplate returned by the server.

    Raises:

      see _api_request method documentation.

  workflow_template_get(workspace: str, workflow_template: int | str) → WorkflowTemplateData

    Fetch information about a workflow template.

  workflow_template_iter(workspace: str) → Iterable[WorkflowTemplateData]

    List workflow templates on a workspace.

  workflow_template_update(workspace: str, data: WorkflowTemplateData) → WorkflowTemplateData

    Set information for a workflow template.

  static write_last_completed_at(completed_at_file: Path | None, completed_at: datetime | None) → None

    Write to completed_at_file the completed_at datetime.

## Associated data models

The parameters of the HTTP requests and the responses of the server are represented by Pydantic models that are described below.

Models used by debusine client.

class debusine.client.models.ArtifactCreateRequest(*, category: str, workspace: str | None = None, files: FilesRequestType = {}, data: dict[str, Any] = {}, work_request: int | None = None, expire_at: datetime | None = None)

  Bases: `StrictBaseModel`

  Declare an ArtifactCreateRequest: client sends it to the server.

  category: str
  data: dict[str, Any]
  expire_at: datetime | None
  files: FilesRequestType
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  work_request: int | None
  workspace: str | None

class debusine.client.models.ArtifactResponse(*, links: dict[str, str | Link] = {}, id: int, url: str, scope: str, workspace: str, category: str, created_at: datetime, data: dict[str, Any], download_tar_gz_url: AnyUrl, files_to_upload: list[str], expire_at: datetime | None = None, files: FilesResponseType = {})

  Bases: `ServerObject`

  Declare an ArtifactResponse: server sends it to the client.

  category: str
  created_at: datetime
  data: dict[str, Any]
  download_tar_gz_url: AnyUrl
  expire_at: datetime | None
  files: FilesResponseType
  files_to_upload: list[str]
  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  scope: str
  url: str
  workspace: str

class debusine.client.models.AssetCreateRequest(*, category: AssetCategory, data: dict[str, Any], work_request: int | None = None, workspace: str)

  Bases: `StrictBaseModel`

  Request for the Asset creation API.

  category: AssetCategory
  data: dict[str, Any]
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  work_request: int | None
  workspace: str

class debusine.client.models.AssetPermissionCheckResponse(*, links: dict[str, str | Link] = {}, has_permission: bool, username: str | None, user_id: int | None, resource: dict[str, Any] | None)

  Bases: `ServerObject`

  A response from the asset permission check endpoint.

  has_permission: bool
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  resource: dict[str, Any] | None
  user_id: int | None
  username: str | None

class debusine.client.models.AssetResponse(*, links: dict[str, str | Link] = {}, id: int, category: AssetCategory, data: dict[str, Any], work_request: int | None = None, workspace: str)

  Bases: `ServerObject`

  Response from an Asset creation / listing API.

  category: AssetCategory
  data: dict[str, Any]
  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  validate_data() → Self

    Validate data using the correct data model.

  work_request: int | None
  workspace: str

class debusine.client.models.AssetsResponse(root: RootModelRootType = PydanticUndefined)

  Bases: `RootModel[Sequence[AssetResponse]]`, `StrictBaseModel`

  A response from the server with multiple AssetResponse objects.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.CollectionData(*, links: dict[str, str | Link] = {}, id: int, name: str, category: str, full_history_retention_period: int | None = None, metadata_only_retention_period: int | None = None, data: dict[str, Any], stats: list[dict[str, Any]] | None = None)

  Bases: `ServerObject`

  Data for a Collection.

  category: str
  data: dict[str, Any]
  full_history_retention_period: int | None
  id: int
  metadata_only_retention_period: int | None
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str
  stats: list[dict[str, Any]] | None

class debusine.client.models.CollectionDataNew(*, name: str, category: str, full_history_retention_period: int | None = None, metadata_only_retention_period: int | None = None, data: dict[str, Any])

  Bases: `StrictBaseModel`

  Data for a Collection to be created.

  category: str
  data: dict[str, Any]
  full_history_retention_period: int | None
  metadata_only_retention_period: int | None
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str

class debusine.client.models.CreateWorkflowRequest(*, template_name: str, workspace: str | None = None, task_data: dict[str, Any])

  Bases: `StrictBaseModel`

  Client sends a workflow creation request to the server.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  task_data: dict[str, Any]
  template_name: str
  workspace: str | None

class debusine.client.models.EmitMetricRequest(*, metric_type: Literal['counter', 'gauge', 'summary', 'histogram'], name: str, labels: dict[str, str], value: float)

  Bases: `StrictBaseModel`

  A request for the server to emit a metric on behalf of the client.

  labels: dict[str, str]
  metric_type: Literal['counter', 'gauge', 'summary', 'histogram']
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str
  value: float

class debusine.client.models.EnrollConfirmPayload(*, outcome: EnrollOutcome, token: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(pattern=re.compile('^[A-Za-z0-9]{8,64}$'))])] | None = None)

  Bases: `BaseModel`

  Enrollment response from the server.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  outcome: EnrollOutcome
  token: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(pattern=re.compile('^[A-Za-z0-9]{8,64}$'))])] | None

class debusine.client.models.EnrollOutcome(*values)

  Bases: `StrEnum`

  User action in response to an enroll confirmation request.

  CANCEL = 'cancel'
  CONFIRM = 'confirm'

class debusine.client.models.EnrollPayload(*, nonce: Annotated[str, _PydanticGeneralMetadata(pattern=re.compile('^[A-Za-z0-9_-]{8,64}$'))], challenge: Annotated[str, _PydanticGeneralMetadata(pattern=re.compile('^\\w{4,10}(?: \\w{4,10}){2,7}$', re.ASCII))], scope: str, hostname: str)

  Bases: `BaseModel`

  Client-provided enrollment payload.

  challenge: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(pattern=re.compile('^\\w{4,10}(?: \\w{4,10}){2,7}$', re.ASCII))])]

    Human-readable challenge to verify the client in the web UI

  hostname: str

    Hostname. Informational, shown in the confirmation page and in the generated token comment

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  nonce: Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(pattern=re.compile('^[A-Za-z0-9_-]{8,64}$'))])]

    Nonce identifying the client enrollment

  scope: str

    Scope. Informational, the confirmation page will warn if invalid

class debusine.client.models.FileRequest(*, size: Annotated[int, Ge(ge=0)], checksums: dict[str, Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=255)])]], type: Literal['file'], content_type: str | None = None)

  Bases: `StrictBaseModel`

  Declare a FileRequest: client sends it to the server.

  checksums: dict[str, Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=255)])]]
  content_type: str | None

    A media type, suitable for an HTTP `Content-Type` header.

  static create_from(path: Path, *, content_type: str | None = None) → FileRequest

    Return a FileRequest for the file path.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  size: Annotated[int, Ge(ge=0)]
  type: Literal['file']

class debusine.client.models.FileResponse(*, links: dict[str, str | Link] = {}, size: Annotated[int, Ge(ge=0)], checksums: dict[str, Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=255)])]], type: Literal['file'], url: AnyUrl, content_type: str | None = None)

  Bases: `ServerObject`

  Declare a FileResponse: server sends it to the client.

  checksums: dict[str, Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=255)])]]
  content_type: str | None
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  size: Annotated[int, Ge(ge=0)]
  type: Literal['file']
  url: AnyUrl

class debusine.client.models.Link(*, href: str, type: str | None = None)

  Bases: `StrictBaseModel`

  Structured version of a resource link.

  This is modeled as a subset of https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link

  can_be_str() → bool

    Check if the only field set is href.

  href: str

    Resource URL

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  type: str | None

class debusine.client.models.LookupChildType(*values)

  Bases: `StrEnum`

  Possible values for LookupDict.child_type and expect_type.

  ANY = 'any'
  ARTIFACT = 'artifact'
  ARTIFACT_OR_PROMISE = 'artifact-or-promise'
  BARE = 'bare'
  COLLECTION = 'collection'

class debusine.client.models.LookupMultipleRequest(*, lookup: list[int | str | dict[str, Any]], work_request: int, expect_type: LookupChildType, default_category: str | None = None)

  Bases: `StrictBaseModel`

  A request from the client to look up multiple collection items.

  default_category: str | None
  expect_type: LookupChildType
  lookup: list[int | str | dict[str, Any]]
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  work_request: int

class debusine.client.models.LookupMultipleResponse(root: RootModelRootType = PydanticUndefined)

  Bases: `RootModel[Sequence[TypeVar]]`, `StrictBaseModel`

  A response from the server with multiple lookup results.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.LookupResultType(*values)

  Bases: `StrEnum`

  A collection item type returned by a lookup.

  ARTIFACT = 'a'
  BARE = 'b'
  COLLECTION = 'c'

class debusine.client.models.LookupSingleRequest(*, lookup: int | str, work_request: int, expect_type: LookupChildType, default_category: str | None = None)

  Bases: `StrictBaseModel`

  A request from the client to look up a single collection item.

  default_category: str | None
  expect_type: LookupChildType
  lookup: int | str
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  work_request: int

class debusine.client.models.LookupSingleResponse(*, links: dict[str, str | Link] = {}, result_type: LookupResultType, collection_item: int | None = None, artifact: int | None = None, collection: int | None = None)

  Bases: `ServerObject`

  A response from the server with a single lookup result.

  artifact: int | None
  collection: int | None
  collection_item: int | None
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  result_type: LookupResultType

class debusine.client.models.LookupSingleResponseArtifact(*, links: dict[str, str | Link] = {}, result_type: Literal[LookupResultType.ARTIFACT], collection_item: int | None = None, artifact: int, collection: int | None = None)

  Bases: `LookupSingleResponse`

  A response from the server with a single lookup result for an artifact.

  Used to assist type annotations.

  artifact: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  result_type: Literal[LookupResultType.ARTIFACT]

class debusine.client.models.LookupSingleResponseCollection(*, links: dict[str, str | Link] = {}, result_type: Literal[LookupResultType.COLLECTION], collection_item: int | None = None, artifact: int | None = None, collection: int)

  Bases: `LookupSingleResponse`

  A response from the server with a single lookup result for a collection.

  Used to assist type annotations.

  collection: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  result_type: Literal[LookupResultType.COLLECTION]

class debusine.client.models.OnWorkRequestCompleted(*, links: dict[str, str | Link] = {}, work_request_id: int, completed_at: datetime, result: str)

  Bases: `ServerObject`

  Server return an OnWorkRequestCompleted to the client.

  Returned via websocket consumer endpoint.

  completed_at: datetime
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  result: str
  work_request_id: int

class debusine.client.models.PaginatedResponse(*, count: int | None = None, next: AnyUrl | None = None, previous: AnyUrl | None = None, results: list[dict[str, Any]])

  Bases: `StrictBaseModel`

  Paginated response from the API.

  count: int | None
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  next: AnyUrl | None
  previous: AnyUrl | None
  results: list[dict[str, Any]]

class debusine.client.models.RelationCreateRequest(*, artifact: int, target: int, type: RelationType)

  Bases: `StrictBaseModel`

  Declare a RelationCreateRequest: client sends it to the server.

  artifact: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  target: int
  type: RelationType

class debusine.client.models.RelationResponse(*, links: dict[str, str | Link] = {}, id: int, artifact: int, target: int, type: RelationType)

  Bases: `ServerObject`

  Declare a RelationResponse.

  artifact: int
  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  target: int
  type: RelationType

class debusine.client.models.RelationType(*values)

  Bases: `StrEnum`

  Possible values for RelationCreateRequest.type.

  BUILT_USING = 'built-using'
  EXTENDS = 'extends'
  RELATES_TO = 'relates-to'

class debusine.client.models.RelationsResponse(root: RootModelRootType = PydanticUndefined)

  Bases: `RootModel[Sequence[RelationResponse]]`, `StrictBaseModel`

  A response from the server with multiple RelationResponse objects.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.RemoteArtifact(*, links: dict[str, str | Link] = {}, id: int, url: str, workspace: str)

  Bases: `ServerObject`

  Declare RemoteArtifact.

  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  url: str
  workspace: str

class debusine.client.models.RuntimeParameter(*values)

  Bases: `StrEnum`

  WorkflowTemplate `runtime_parameter` special values.

  ANY = 'any'

class debusine.client.models.ServerObject(*, links: dict[str, str | Link] = {})

  Bases: `StrictBaseModel`

  Model representing an object on the server.

  get_link_url(name: str) → str

    Return the href URL for a link.

  links: dict[str, str | Link]

    URLs to related resources

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.StrictBaseModel

  Bases: `BaseModel`

  Stricter pydantic configuration.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.TaskConfigurationCollection(*, links: dict[str, str | Link] = {}, id: int, name: str, data: dict[str, Any])

  Bases: `ServerObject`

  Response fragment identifying a TaskConfiguration collection.

  data: dict[str, Any]
  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str

class debusine.client.models.TaskConfigurationCollectionContents(*, links: dict[str, str | Link] = {}, collection: TaskConfigurationCollection, items: list[DebusineTaskConfiguration])

  Bases: `ServerObject`

  Bundle together a TaskConfiguration collection and its items.

  collection: TaskConfigurationCollection
  items: list[DebusineTaskConfiguration]
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.TaskConfigurationCollectionUpdateResults(*, links: dict[str, str | Link] = {}, added: int, updated: int, removed: int, unchanged: int)

  Bases: `ServerObject`

  Results of a task configuration collection update.

  added: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  removed: int
  unchanged: int
  updated: int

class debusine.client.models.WorkRequestExternalDebsignRequest(*, signed_artifact: int)

  Bases: `StrictBaseModel`

  Client sends data from an external debsign run to the server.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  signed_artifact: int

class debusine.client.models.WorkRequestRequest(*, task_name: str, workspace: str | None = None, task_data: dict[str, Any], event_reactions: dict[str, Any])

  Bases: `StrictBaseModel`

  Client send a WorkRequest to the server.

  event_reactions: dict[str, Any]
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  task_data: dict[str, Any]
  task_name: str
  workspace: str | None

class debusine.client.models.WorkRequestResponse(*, links: dict[str, str | Link] = {}, id: int, url: str, created_at: datetime, started_at: datetime | None = None, completed_at: datetime | None = None, duration: float | None = None, status: str, result: str, worker: int | None = None, task_type: str, task_name: str, task_data: dict[str, Any], dynamic_task_data: dict[str, Any] | None = None, priority_base: int, priority_adjustment: int, artifacts: list[int], scope: str | None = None, workspace: str, scheduler_tags_provided: list[str] = [], scheduler_tags_required: list[str] = [])

  Bases: `ServerObject`

  Server return a WorkRequest to the client.

  artifacts: list[int]
  completed_at: datetime | None
  created_at: datetime
  duration: float | None
  dynamic_task_data: dict[str, Any] | None
  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  priority_adjustment: int
  priority_base: int
  result: str
  scheduler_tags_provided: list[str]
  scheduler_tags_required: list[str]
  scope: str | None
  started_at: datetime | None
  status: str
  task_data: dict[str, Any]
  task_name: str
  task_type: str
  url: str
  worker: int | None
  workspace: str

class debusine.client.models.WorkflowTemplateData(*, links: dict[str, str | Link] = {}, id: int, name: str, task_name: str, static_parameters: dict[str, Any], runtime_parameters: dict[str, list[str] | Literal[RuntimeParameter.ANY]] | Literal[RuntimeParameter.ANY], priority: int = 0)

  Bases: `ServerObject`

  Data for a WorkflowTemplate.

  id: int
  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str
  priority: int
  runtime_parameters: dict[str, list[str] | Literal[RuntimeParameter.ANY]] | Literal[RuntimeParameter.ANY]
  static_parameters: dict[str, Any]
  task_name: str

class debusine.client.models.WorkflowTemplateDataNew(*, name: str, task_name: str, static_parameters: dict[str, Any], runtime_parameters: dict[str, list[str] | Literal[RuntimeParameter.ANY]] | Literal[RuntimeParameter.ANY] = {}, priority: int = 0)

  Bases: `StrictBaseModel`

  Data for a WorkflowTemplate to be created.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  name: str
  priority: int
  runtime_parameters: dict[str, list[str] | Literal[RuntimeParameter.ANY]] | Literal[RuntimeParameter.ANY]
  static_parameters: dict[str, Any]
  task_name: str

class debusine.client.models.WorkspaceInheritanceChain(*, links: dict[str, str | Link] = {}, chain: list[WorkspaceInheritanceChainElement] = [])

  Bases: `ServerObject`

  Ordered list of workspaces inherited by a workspace.

  chain: list[WorkspaceInheritanceChainElement]
  classmethod from_strings(values: Collection[str]) → Self

    Build an inheritance chain from a list of user-provided strings.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

class debusine.client.models.WorkspaceInheritanceChainElement(*, id: int | None = None, scope: str | None = None, workspace: str | None = None)

  Bases: `StrictBaseModel`

  An element in an inheritance chain.

  classmethod from_string(value: str) → Self

    Resolve a command line argument to a WorkspaceInheritanceChain.

  id: int | None
  matches(element: WorkspaceInheritanceChainElement) → bool

    Check if the components of element that are set match this one.

  model_config: ClassVar[ConfigDict] = {'validate_assignment': True}

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

  not_empty() → Self

    Ensure at least one of id or workspace is set.

  scope: str | None
  workspace: str | None

## Representation of artifacts

Artifacts to be uploaded are first created as a `debusine.artifacts.local_artifact.LocalArtifact` object. There are many descendants of that class available in `debusine.artifacts`, one for each category of artifact.

class debusine.artifacts.local_artifact.LocalArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: AD)

  Bases: `BaseModel`, `ABC`, `Generic`

  Represent an artifact locally.

  static artifact_categories() → list[str]

    Return list of artifact categories.

  category: ArtifactCategory

    Artifact type

  static class_from_category(category: str) → type[LocalArtifact[Any]]

    Return class sub_local_artifact.

  content_types: dict[str, str]
  classmethod create_data(data_dict: dict[str, Any]) → AD

    Instantiate a data model from a dict.

  data: AD

    Artifact data

  files: dict[str, Path]
  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

  remote_files: dict[str, FileRequest]

Debusine client.

class debusine.artifacts.AutopkgtestArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianAutopkgtest)

  Bases: `LocalArtifact[DebianAutopkgtest]`

  Autopkgtest: encapsulate result of the Autopkgtest run.

  classmethod create(artifact_directory: Path, data: DebianAutopkgtest) → Self

    Return AutopkgtestArtifact with the files and data set.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.BinaryPackage(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianBinaryPackage)

  Bases: `LocalArtifact[DebianBinaryPackage]`

  BinaryPackage: encapsulates a single *.deb / *.udeb.

  classmethod create(*, file: Path) → Self

    Return a BinaryPackage setting file and data.

  classmethod files_exactly_one(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError if len(files) != 1.

  classmethod files_must_end_in_deb_or_udeb(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError if a file does not end in .deb or .udeb.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.BinaryPackages(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianBinaryPackages)

  Bases: `LocalArtifact[DebianBinaryPackages]`

  BinaryPackages: encapsulates a group of *.deb / *.udeb.

  classmethod create(*, srcpkg_name: str, srcpkg_version: str, version: str, architecture: str, files: list[Path]) → Self

    Return a BinaryPackages setting files and data.

  classmethod files_more_than_zero(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError if len(files) == 0.

  classmethod files_must_end_in_deb_or_udeb(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError if a file does not end in .deb or .udeb.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.BlhcArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianBlhc)

  Bases: `LocalArtifact[DebianBlhc]`

  BlhcArtifact: encapsulate result of the blhc run.

  classmethod create(blhc_output: Path, build_log: DebianPackageBuildLog | None) → Self

    Return a BlhcArtifact with the files set.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.DebDiffArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebDiff)

  Bases: `LocalArtifact[DebDiff]`

  DebDiffArtifact: encapsulate result of the debdiff run.

  classmethod create(debdiff_output: Path, original: str, new: str, *, label: str | None = None) → Self

    Return a DebDiffArtifact with the files set.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.DebianSystemTarballArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianSystemTarball)

  Bases: `LocalArtifact[DebianSystemTarball]`

  Contain system.tar.xz file with a Debian.

  Can be used by a chroot, container, etc.

  classmethod create(tarball: Path, data: dict[str, Any]) → Self

    Return a DebianSystemTarballArtifact with the tarball file.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.LintianArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianLintian)

  Bases: `LocalArtifact[DebianLintian]`

  LintianArtifact: encapsulate result of the Lintian run.

  classmethod create(analysis: Path, lintian_output: Path, architecture: str, summary: DebianLintianSummary) → Self

    Return a LintianArtifact with the files set.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.LocalArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: AD)

  Bases: `BaseModel`, `ABC`, `Generic`

  Represent an artifact locally.

  static artifact_categories() → list[str]

    Return list of artifact categories.

  category: ArtifactCategory

    Artifact type

  static class_from_category(category: str) → type[LocalArtifact[Any]]

    Return class sub_local_artifact.

  content_types: dict[str, str]
  classmethod create_data(data_dict: dict[str, Any]) → AD

    Instantiate a data model from a dict.

  data: AD

    Artifact data

  files: dict[str, Path]
  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

  remote_files: dict[str, FileRequest]

class debusine.artifacts.PackageBuildLog(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianPackageBuildLog)

  Bases: `LocalArtifact[DebianPackageBuildLog]`

  PackageBuildLog: represents a build log file.

  classmethod create(*, file: Path, source: str, version: str, architecture: str | None = None, bd_uninstallable: DoseDistCheck | None = None) → Self

    Return a PackageBuildLog.

  classmethod file_must_end_in_build(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError if the file does not end in .build.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

  classmethod validate_files_length_is_one(files: dict[str, Path]) → dict[str, Path]

    Validate that artifact has only one file.

class debusine.artifacts.PiupartsArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianPiuparts)

  Bases: `LocalArtifact[DebianPiuparts]`

  Piuparts: encapsulate result of a `piuparts` run.

  classmethod create(*, piuparts_output: Path, data: DebianPiuparts) → Self

    Return a `PiupartsArtifact` with the files and data set.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.RepositoryIndex(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianRepositoryIndex)

  Bases: `LocalArtifact[DebianRepositoryIndex]`

  An index file in a repository.

  classmethod create(*, file: Path, path: str, content_type: str | None = None) → Self

    Return a RepositoryIndex.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.SigningInputArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebusineSigningInput)

  Bases: `LocalArtifact[DebusineSigningInput]`

  Input to a Sign task.

  classmethod create(files: Iterable[Path], base_dir: Path, trusted_certs: list[str] | None = None, binary_package_name: str | None = None) → Self

    Return a new SigningInputArtifact.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

  classmethod validate_at_least_one_file(files: dict[str, Path]) → dict[str, Path]

    Validate that artifact has at least one file.

class debusine.artifacts.SigningOutputArtifact(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebusineSigningOutput)

  Bases: `LocalArtifact[DebusineSigningOutput]`

  Output of a Sign task.

  classmethod create(purpose: KeyPurpose, fingerprint: str, results: Iterable[SigningResult], files: Iterable[Path], base_dir: Path, binary_package_name: str | None = None) → Self

    Return a new SigningOutputArtifact.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.SourcePackage(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianSourcePackage)

  Bases: `LocalArtifact[DebianSourcePackage]`

  SourcePackage: contains source code to be built into BinaryPackages.

  classmethod create(*, name: str, version: str, files: list[Path]) → Self

    Return a SourcePackage setting files and data.

  classmethod files_contain_one_dsc(files: dict[str, Path]) → dict[str, Path]

    Raise ValueError when files does not have exactly 1 .dsc file.

  classmethod files_contains_files_in_dsc(files: dict[str, Path]) → dict[str, Path]

    Validate that set(files) == set(files_in_dsc_file).

    Exception: The .dsc file must be in files but not in the .dsc file.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.Upload(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.DebianUpload)

  Bases: `LocalArtifact[DebianUpload]`

  Upload: encapsulate a .changes and files listed in it.

  classmethod create(*, changes_file: Path, allow_remote: bool = False) → Self

    Return a Upload. Add the changes_files and files listed in it.

    Parameters:

      - changes_file – a .changes file. Parsed by deb822.Changes.

      - allow_remote – if True, allow files referenced by the .changes file to be missing locally; uploading this artifact will require them to already exist on the server.

  files_contain_changes() → Self

    Raise ValueError when files does not have exactly 1 .changes file.

  files_contains_files_in_changes() → Self

    Validate that set(files) == set(files_in_changes_file).

    Exception: The .changes file must be in files but not in the .changes file.

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.

class debusine.artifacts.WorkRequestDebugLogs(*, category: ~debusine.artifacts.models.ArtifactCategory, files: dict[str, ~pathlib.Path] = <factory>, remote_files: dict[str, ~debusine.client.models.FileRequest] = <factory>, content_types: dict[str, str] = <factory>, data: ~debusine.artifacts.models.EmptyArtifactData = <factory>)

  Bases: `LocalArtifact[EmptyArtifactData]`

  WorkRequestDebugLogs: help debugging issues executing the task.

  Log files for debusine users in order to debug possible problems in their WorkRequests.

  classmethod create(*, files: Iterable[Path]) → Self

    Return a WorkRequestDebugLogs.

  data: EmptyArtifactData

    Artifact data

  model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}

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

  model_post_init(context: Any, /) → None

    This function is meant to behave like a BaseModel method to initialise private attributes.

    It takes context as an argument since that’s what pydantic-core passes when calling it.

    Args:

      self: The BaseModel instance. context: The context.