# PipeBio Python SDK

> A Python SDK for the PipeBio platform - an integrated bioinformatics platform
> for large molecule and peptide discovery. This file is auto-generated from the
> SDK source by scripts/generate_llms_txt.py; do not edit by hand.

## Getting started

- Install: `pip install pipebio` (or `uv pip install pipebio`).
- Authenticate: set the `PIPE_API_KEY` environment variable (get a key from the
  `me` page of your PipeBio instance), or place it in a local `.env` file.
- Create a client and call resource services:

    from pipebio.pipebio_client import PipebioClient
    client = PipebioClient(url="https://app.pipebio.com")
    client.entities.get(entity_id)

- Escape hatch: for endpoints not yet wrapped by the SDK, use the authenticated
  `client.session` directly, e.g. `client.session.get("me")`.

## API reference

### pipebio.pipebio_client

- class `PipebioClient`: Authenticated client for the PipeBio API.

    Authenticated client for the PipeBio API.

    The client authenticates on construction (using ``PIPE_API_KEY`` by default)
    and exposes per-resource service objects as attributes:

    Attributes:
        session: The underlying authenticated :class:`requests` session. Use it
            directly to call endpoints not yet wrapped by the SDK.
        shareables: Operations on shareables (projects/folders ownership).
        entities: Operations on entities (documents, folders).
        jobs: Operations on jobs (create, list, poll, update).
        sequences: Operations on sequence documents (download, upload, import).
        organization_lists: Operations on organization-level lists.
        workflows: Operations on workflows.
        user: The authenticated user object, or ``None`` when manual auth is used.

  - `PipebioClient.export(self, entity_id: str, format: pipebio.models.export_format.ExportFormat, destination_folder: Optional[str] = None, destination_filename: Optional[str] = None, params: Optional[dict] = None) -> List[str]`: Export an entity to a file and download the result.

      Export an entity to a file and download the result.

      Runs an ``ExportJob`` server-side, waits for completion, then downloads
      every output link to ``destination_folder``.

      Args:
          entity_id: Id of the entity to export.
          format: The :class:`~pipebio.models.export_format.ExportFormat` to
              produce (e.g. GenBank, FASTA).
          destination_folder: Local folder to write the downloaded file(s) to.
          destination_filename: Optional output filename; defaults to the
              entity name.
          params: Optional extra export parameters merged into the job params.

      Returns:
          The list of local file paths that were downloaded.

  - `PipebioClient.get_user(self) -> Dict[str, Any]`: Fetch the authenticated user from the ``me`` endpoint.

      Fetch the authenticated user from the ``me`` endpoint.

      Returns:
          The user object as returned by the API.

      Raises:
          ValueError: If authentication fails (HTTP 401).

      .. API reference (generated - do not edit) ::

      **GET** ``/me``

      Get me

      Returns information about the currently authenticated user

      .. end API reference ::

  - property `PipebioClient.is_aws -> bool`: Whether the connected PipeBio instance runs on AWS.

      Whether the connected PipeBio instance runs on AWS.

      The result is determined once from the ``/debug/about`` endpoint and
      cached for the lifetime of the client.

      Returns:
          ``True`` if the instance is an AWS deployment, otherwise ``False``.

  - `PipebioClient.sanitize_baseurl(url: str) -> str`: Validate and normalise a PipeBio base URL.

      Validate and normalise a PipeBio base URL.

      Args:
          url: The base URL to sanitise.

      Returns:
          The URL with surrounding whitespace and any trailing slash removed.

      Raises:
          ValueError: If the URL does not start with ``https://``.

  - `PipebioClient.set_correlation_id(self, correlation_id: str) -> None`: Set a correlation ID sent as an X-Correlation-Id header on every subsequent API request.

      Set a correlation ID sent as an X-Correlation-Id header on every subsequent API request.

      Use this to link all API calls belonging to a single logical operation
      so they can be correlated in PipeBio server logs.

      Args:
          correlation_id: An opaque identifier for the operation being performed.

  - `PipebioClient.upload_file(self, file_name: str, absolute_file_location: str, parent_id: str, project_id: str, organization_id: Optional[str] = None, details: Optional[List[pipebio.models.upload_detail.UploadDetail]] = None, file_name_id: Optional[str] = None, poll_job: bool = False, on_progress: Optional[Callable[[int, int], NoneType]] = None) -> Dict[str, Any]`: Upload a single local file as a new document.

      Upload a single local file as a new document.

      Large files (at or above the multipart threshold) are uploaded with a
      multipart upload on AWS instances; otherwise a single signed upload is
      used.

      Args:
          file_name: Friendly name shown in the PipeBio UI.
          absolute_file_location: Absolute path to the file on local disk.
          parent_id: Id of the parent folder/document the upload belongs to.
          project_id: Id of the project (shareable) to upload into.
          organization_id: Organization id. Defaults to the user's default org.
          details: Optional per-file upload details/metadata.
          file_name_id: Optional client-supplied id used to correlate the file.
          poll_job: If ``True``, block until the parsing job finishes and
              return the completed job.
          on_progress: Optional callback receiving ``(bytes_sent, total_bytes)``
              during multipart uploads.

      Returns:
          The upload/parse job object. When ``poll_job`` is ``True`` this is the
          completed job; otherwise it is the in-progress job.

  - `PipebioClient.upload_files(self, absolute_folder_path: str, parent_id: str, project_id: str, organization_id: Optional[str] = None, filename_pattern: Optional[str] = None, poll_jobs: bool = False) -> List[Dict[str, Any]]`: Upload multiple files from a folder, one document per file.

      Upload multiple files from a folder, one document per file.

      Useful for uploading a number of files to a single folder, e.g. ab1
      files. Uploads are started in parallel and parsing is not awaited unless
      ``poll_jobs`` is set.

      Args:
          absolute_folder_path: Full path to the folder containing the files.
          parent_id: Id of the parent folder/document.
          project_id: Id of the project (shareable) to upload into.
          organization_id: Organization id. Defaults to the user's default org.
          filename_pattern: Optional regex matched against filenames, e.g.
              ``r".*\.ab1"``.
          poll_jobs: If ``True``, block until all parsing jobs finish.

      Returns:
          The list of upload job objects (completed when ``poll_jobs`` is set).

  - `PipebioClient.upload_files_as_zip(self, absolute_folder_path: str, parent_id: str, project_id: str, organization_id: Optional[str] = None, filename_pattern: Optional[str] = None, poll_jobs: bool = False) -> Dict[str, Any]`: Zip the matching files in a folder and upload them as one document.

      Zip the matching files in a folder and upload them as one document.

      Useful for uploading a number of files as a single document, e.g. ab1
      files.

      Args:
          absolute_folder_path: Full path to the folder containing the files.
          parent_id: Id of the parent folder/document.
          project_id: Id of the project (shareable) to upload into.
          organization_id: Organization id. Defaults to the user's default org.
          filename_pattern: Optional regex matched against filenames, e.g.
              ``r".*\.ab1"``.
          poll_jobs: If ``True``, block until the parsing job finishes.

      Returns:
          The single upload job object (completed when ``poll_jobs`` is set).



### pipebio.entities

- class `Entities`: Wraps the ``entities`` API endpoints.

    Wraps the ``entities`` API endpoints.

    Obtain an instance via :attr:`PipebioClient.entities` rather than
    constructing it directly.

  - `Entities.convert_pandas_type(pandas_type: str) -> pipebio.models.table_column_type.TableColumnType`: (no description)
  - `Entities.create_file(self, project_id: str, name: str, parent_id: str = None, entity_type: pipebio.models.entity_types.EntityTypes = <EntityTypes.SEQUENCE_DOCUMENT: 'SEQUENCE_DOCUMENT'>, visible: bool = False) -> dict`: Create a new entity (document or folder).

      Create a new entity (document or folder).

      Args:
          project_id: Id of the project (shareable) to create the entity in.
          name: Display name for the new entity.
          parent_id: Optional id of the parent folder.
          entity_type: The :class:`~pipebio.models.entity_types.EntityTypes`
              to create. Defaults to a sequence document.
          visible: Whether the entity is immediately visible in the UI.

      Returns:
          The created entity object.

      .. API reference (generated - do not edit) ::

      **POST** ``/entities``

      Create

      Create a new entity, such as a folder or document

      API request body:
          * ``name`` -- Human-readable name for the new entity.
          * ``shareableId`` -- Id of the project (shareable) the entity belongs to.
          * ``type`` -- Type of entity to create, such as a folder or document.
          * ``visible`` (optional) -- Whether the entity is visible in the project tree.
          * ``parentId`` (optional) -- Id of the parent folder; omit to create at the project root.
          * ``sequenceDocumentKind`` (optional) -- For sequence documents, the kind of sequences they hold.
          * ``sequenceCount`` (optional) -- Number of sequences contained in the document.
          * ``attributes`` (optional) -- Arbitrary key/value metadata to attach to the entity.

      .. end API reference ::

  - `Entities.create_folder(self, project_id: str, name: str, parent_id: str = None, visible: bool = False) -> dict`: Create a new folder entity.

      Create a new folder entity.

      Args:
          project_id: Id of the project (shareable) to create the folder in.
          name: Display name for the folder.
          parent_id: Optional id of the parent folder.
          visible: Whether the folder is immediately visible in the UI.

      Returns:
          The created folder entity object.

  - `Entities.delete(self, entity_ids: list) -> None`: Delete one or more entities.

      Delete one or more entities.

      Args:
          entity_ids: Ids of the entities to delete.

      .. API reference (generated - do not edit) ::

      **DELETE** ``/entities``

      Delete

      Delete one or more entities

      API request body:
          * ``ids`` -- Ids of the entities to delete.

      .. end API reference ::

  - `Entities.download_original_file(self, entity_id: str, destination_filename: str) -> str`: Download the original uploaded file for a document.

      Download the original uploaded file for a document.

      Two requests are made: one to obtain a signed URL
      (``GET /api/v2/entities/:id/original``) and one to download the file
      from that URL.

      Args:
          entity_id: Id of the document whose original file to download.
          destination_filename: Local path to write the downloaded file to.

      Returns:
          The ``destination_filename`` that was written.

      .. API reference (generated - do not edit) ::

      **GET** ``/entities/{id}/original``

      Original file

      Generate signed url to download original file entity was created from

      API parameters:
          * ``id`` (path) -- Id of the entity whose original uploaded file to download.
          * ``allowDeleted`` (query) -- If true, also operate on the entity when it has been soft-deleted.

      .. end API reference ::

  - `Entities.get(self, entity_id: str) -> dict`: Fetch a single entity by id.

      Fetch a single entity by id.

      Args:
          entity_id: Id of the entity to fetch.

      Returns:
          The entity object.

      .. API reference (generated - do not edit) ::

      **GET** ``/entities/{id}``

      Get one

      Get a specific entity such as a folder or document.

      API parameters:
          * ``id`` (path) -- Id of the entity (document or folder) to fetch.
          * ``allowDeleted`` (query) -- If true, also return the entity when it has been soft-deleted.
          * ``includeMigrationDetails`` (query) -- If true, include AWS migration metadata in the response.

      .. end API reference ::

  - `Entities.get_all(self, entity_ids: List[str]) -> List[dict]`: Fetch multiple entities in parallel.

      Fetch multiple entities in parallel.

      Args:
          entity_ids: Ids of the entities to fetch.

      Returns:
          The list of entity objects (order is not guaranteed).

  - `Entities.get_fields(self, entity_id: str, ignore_id: bool = False) -> List[pipebio.column.Column]`: Return the column fields (schema) for a document.

      Return the column fields (schema) for a document.

      Args:
          entity_id: Id of the document to inspect.
          ignore_id: If ``True``, omit the ``id`` field from the result.

      Returns:
          The list of :class:`~pipebio.column.Column` definitions. Raises if
          the entity has no fields (e.g. it is a folder).

      .. API reference (generated - do not edit) ::

      **GET** ``/entities/{id}/fields``

      List entity fields

      If this entity is a document containing sequences, list all fields (columns). Otherwise (e.g. if the entity is a folder) will return an error.

      API parameters:
          * ``id`` (path) -- Id of the document whose fields (columns) to list.
          * ``allowDeleted`` (query) -- If true, also operate on the document when it has been soft-deleted.
          * ``getMinMax`` (query) -- If true, include per-column minimum and maximum values.
          * ``includeSortCols`` (query) -- If true, include hidden helper columns used for sorting.

      .. end API reference ::

  - `Entities.get_fields_for_all_entities(self, entity_ids: List[str]) -> List[pipebio.column.Column]`: (no description)
  - `Entities.get_file_handle(self, absolute_file_path: str) -> pandas.core.frame.DataFrame`: Read a tabular file into a pandas DataFrame.

      Read a tabular file into a pandas DataFrame.

      Attempts to read the file as Excel first, then falls back to
      comma-separated and finally tab-separated parsing.

      Args:
          absolute_file_path: Path to the local tabular file.

      Returns:
          The parsed :class:`pandas.DataFrame`.

  - `Entities.mark_file_visible(self, entity_summary: pipebio.models.upload_summary.UploadSummary) -> dict`: Make a previously hidden entity visible in the UI.

      Make a previously hidden entity visible in the UI.

      Args:
          entity_summary: Summary of the entity to update.

      Returns:
          The updated entity object.

      .. API reference (generated - do not edit) ::

      **PATCH** ``/entities/{id}``

      Update

      Update entity properties. Only properties that are included in the request body will be affected; the rest will be unchanged.

      API parameters:
          * ``id`` (path) -- Id of the entity to update.
          * ``allowDeleted`` (query) -- If true, also update the entity when it has been soft-deleted.

      API request body:
          * ``name`` (optional) -- New name for the entity.
          * ``visible`` (optional) -- Whether the entity is visible in the project tree.
          * ``sequenceCount`` (optional) -- Number of sequences contained in the document.
          * ``sequenceDocumentKind`` -- For sequence documents, the kind of sequences they hold.
          * ``type`` (optional) -- Type of the entity, such as a folder or document.
          * ``attributes`` (optional) -- Arbitrary key/value metadata to attach to the entity.

      .. end API reference ::

  - `Entities.merge(self, entity_id: str, assay_absolute_file_path: str, assay_column: str, entity_column: str, append_unmatched_rows: bool = False, timeout_seconds: int = 3600) -> Dict[str, Any]`: Merge tabular assay data into a sequence document.

      Merge tabular assay data into a sequence document.

      Reads a local csv/tsv/excel assay file and left-joins its rows onto the
      sequence document: every assay column becomes a new column on the
      document, and each document row is filled from the assay row whose
      ``assay_column`` value equals that row's ``entity_column`` value. This is
      equivalent to `add assay data
      <https://docs.pipebio.com/docs/assay-and-functional-data#add-assay-data>`_
      in the web app.

      The merge is performed in three steps:

      1. The assay file is converted to TSV and uploaded directly to storage
         via a presigned URL (no job is created for the upload).
      2. A ``MergeAssayDataJob`` referencing the uploaded file is created.
      3. This call blocks, polling until that job completes.

      Example:
          Merge binding scores keyed by clone name into a document whose
          ``name`` column holds the same clone names::

              client.entities.merge(
                  entity_id="12345",
                  assay_absolute_file_path="/data/binding_scores.csv",
                  assay_column="clone_id",   # header in binding_scores.csv
                  entity_column="name",      # column on document 12345
              )

      Args:
          entity_id: Id of the sequence document to merge the assay data into.
          assay_absolute_file_path: Absolute path to the tabular assay file on
              local disk (``.csv``, ``.tsv`` or ``.xlsx``); its first row must
              be a header.
          assay_column: Name of the join-key column *in the assay file* (a
              header from ``assay_absolute_file_path``).
          entity_column: Name of the join-key column *on the document* (e.g.
              ``"name"``) whose values are matched against ``assay_column``.
          append_unmatched_rows: If ``True``, assay rows that match no document
              row (e.g. controls) are appended to the document as new rows;
              if ``False`` they are discarded.
          timeout_seconds: Maximum seconds to wait for the merge job to finish
              before raising. Defaults to one hour.

      Returns:
          The completed ``MergeAssayDataJob`` as a ``dict`` (the polled job
          object, including its final ``status``).

      Raises:
          ValueError: If the assay file does not exist, or ``assay_column`` is
              not a header in the assay file.
          Exception: If the merge job fails or the timeout elapses.

  - `Entities.merge_fields(schema_a: List[pipebio.column.Column], schema_b: List[pipebio.column.Column]) -> List[pipebio.column.Column]`: (no description)


### pipebio.jobs

- class `Jobs`: Wraps the ``jobs`` API endpoints.

    Wraps the ``jobs`` API endpoints.

    Obtain an instance via :attr:`PipebioClient.jobs` rather than constructing
    it directly. The service can hold a current ``job_id`` (e.g. when running
    inside a job) which several methods fall back to when no id is supplied.

  - `Jobs.bulk_update(self, updates: List[dict]) -> None`: Update multiple jobs in a single request.

      Update multiple jobs in a single request.

      Args:
          updates: List of update dicts. Each requires ``id`` and ``status``
              and may include ``progress``, ``messages``, ``outputEntities``
              and ``outputLinks``. Between 1 and 100 updates are allowed.

      Raises:
          ValueError: If no updates are given or more than 100 are supplied.

      .. API reference (generated - do not edit) ::

      **PATCH** ``/jobs``

      Update bulk

      Update jobs in bulk

      API request body:
          * ``updates`` -- List of per-job updates to apply (1-100 items).

      .. end API reference ::

  - `Jobs.cancel(self, job_id: str = None) -> None`: Cancel a running or queued job.

      Cancel a running or queued job.

      Args:
          job_id: Job id to cancel. Falls back to the instance job id if
              omitted.

      .. API reference (generated - do not edit) ::

      **DELETE** ``/jobs/{jobId}``

      Cancel

      Cancel a job

      API parameters:
          * ``jobId`` (path) -- Id of the job to cancel.

      .. end API reference ::

  - `Jobs.create(self, shareable_id: str, job_type: pipebio.models.job_type.JobType, name: str, input_entity_ids: List[str], owner_id: str = None, params=None, poll_jobs: bool = False, client_side: bool = False, messages: Optional[List[str]] = None, status: Optional[pipebio.models.job_status.JobStatus] = None, allow_deleted_entities: bool = False) -> str`: Create a new job.

      Create a new job.

      Args:
          shareable_id: Project the input documents belong to.
          job_type: The :class:`~pipebio.models.job_type.JobType` to run.
          name: User-facing job name.
          input_entity_ids: Ids of the input documents/entities.
          owner_id: Organization id owning this job. Defaults to the user's
              default org.
          params: Job-specific parameters.
          poll_jobs: If ``True``, block until the job completes.
          client_side: If ``True``, run locally rather than on PipeBio servers.
          messages: Optional initial status messages (max 10).
          status: Optional initial status (defaults to ``QUEUED``).
          allow_deleted_entities: Allow referencing deleted entities.

      Returns:
          The id of the created job.

      .. API reference (generated - do not edit) ::

      **POST** ``/jobs``

      Create

      Create a new job

      API parameters:
          * ``allowDeletedEntities`` (query) -- If true, allow referencing entities that have been soft-deleted.

      API request body:
          * ``name`` -- Give the job a friendly name that is meaningful to the end user
          * ``clientSide`` (optional) -- Set true if you want to run the job locally yourself and not on PipeBio servers
          * ``shareableId`` -- Copy your project id from the project settings page
          * ``params`` -- Parameters the job can use
          * ``type`` -- What type of job is this
          * ``messages`` -- Update the user with details about what the job is currently doing
          * ``inputEntities`` -- Entity ids of entities that should be fed into this job
          * ``status`` -- Initial status of the job.

      .. end API reference ::

  - `Jobs.create_signed_upload(self, file_name: str, parent_id: str, project_id: str, details: List[pipebio.models.upload_detail.UploadDetail], file_name_id: str, organization_id: str = None) -> dict`: Create a signed upload slot for a new sequence document.

      Create a signed upload slot for a new sequence document.

      Args:
          file_name: Friendly name shown in the PipeBio UI.
          parent_id: Id of the target parent folder.
          project_id: Id of the project (shareable) to upload into.
          details: Per-file upload details/metadata.
          file_name_id: Optional client-supplied id to correlate the file.
          organization_id: Organization id. Defaults to the user's default org.

      Returns:
          The signed-upload response, including the URL, headers and job.

      .. API reference (generated - do not edit) ::

      **POST** ``/signed-url``

      Create (start upload)

      Start an upload with a signed url.

      API request body:
          * ``name`` -- Name to give the entity created from the upload.
          * ``type`` -- Type of entity to create from the upload.
          * ``contentType`` -- MIME type of the uploaded content.
          * ``details`` -- Per-row attributes to attach to the created entity.
          * ``source`` -- Identifier of the external system the data came from.
          * ``sourceId`` -- Id of the source record in the originating system.
          * ``shareableId`` -- Id of the project the new entity belongs to.
          * ``targetFolderId`` -- Id of the folder to place the new entity in.
          * ``options`` -- Additional options controlling the create-from-upload job.
          * ``columns`` -- Column definitions (name and kind) for the uploaded data.
          * ``location`` -- Can help with upload speeds

      .. end API reference ::

  - `Jobs.get(self, job_id: str = None) -> Dict[str, Any]`: Fetch a single job by id.

      Fetch a single job by id.

      Args:
          job_id: Job id to fetch. Falls back to the instance job id if omitted.

      Returns:
          The job object.

      .. API reference (generated - do not edit) ::

      **GET** ``/jobs/{jobId}``

      Get

      Get a single job.

      API parameters:
          * ``jobId`` (path) -- Id of the job to fetch.

      .. end API reference ::

  - `Jobs.list(self, organization_id: str = None, page_offset: Optional[int] = None, page_limit: Optional[int] = None, sort: Optional[str] = None, include_cols: Optional[List[str]] = None, include_total_count: Optional[bool] = None, filters: Optional[List[pipebio.models.job_filter.JobFilter]] = None) -> Dict[str, Any]`: List jobs with optional pagination, sorting and filtering.

      List jobs with optional pagination, sorting and filtering.

      When ``filters`` is provided this uses ``POST /jobs/_search``; otherwise
      it uses ``GET /jobs``.

      Args:
          organization_id: Organization to list jobs for. Defaults to the
              user's default org.
          page_offset: Pagination offset (0-based).
          page_limit: Maximum results per page (default 100).
          sort: Comma-separated sort fields; prefix with ``-`` for descending
              (e.g. ``"-created_at,name"``).
          include_cols: Columns to include in the response.
          include_total_count: Whether to include the total count.
          filters: Filter conditions; when provided, the ``_search`` endpoint
              is used.

      Returns:
          The response object with a ``data`` array and optional total count.

      .. API reference (generated - do not edit) ::

      **GET** ``/jobs``

      List

      List jobs for the current user

      API parameters:
          * ``sort`` (query) -- Sort expression in the form "columnName:asc" or "columnName:desc".
          * ``pageOffset`` (query) -- Zero-based index of the first row to return.
          * ``pageLimit`` (query) -- Maximum number of rows to return.
          * ``includeCols`` (query) -- Comma-separated list of column names to include in the response.
          * ``excludeCols`` (query) -- Comma-separated list of column names to exclude from the response.
          * ``includeTotalCount`` (query) -- If true, include the total matching row count in the response.

      .. end API reference ::

  - `Jobs.poll_job(self, job_id: str = None, timeout_seconds: Optional[int] = None) -> Dict[str, Any]`: Poll a job until it completes or fails.

      Poll a job until it completes or fails.

      Args:
          job_id: Job id to poll. Falls back to the instance job id if omitted.
          timeout_seconds: Maximum time to wait. Defaults to 600 seconds.

      Returns:
          The final job object.

      Raises:
          Exception: If the timeout elapses before the job finishes.

  - `Jobs.poll_jobs(self, job_ids: List[str], timeout_seconds: Optional[int] = None) -> List[Dict[str, Any]]`: Poll multiple jobs in parallel until they complete or fail.

      Poll multiple jobs in parallel until they complete or fail.

      Args:
          job_ids: Ids of the jobs to poll.
          timeout_seconds: Maximum time to wait per job. Defaults to 600
              seconds.

      Returns:
          The list of final job objects.

  - `Jobs.reschedule(self, job_id: str = None, automated: Optional[bool] = None) -> Dict[str, Any]`: Re-run a failed job.

      Re-run a failed job.

      Args:
          job_id: Job id to reschedule. Falls back to the instance job id if
              omitted.
          automated: Whether this is an automated (vs user-initiated)
              reschedule.

      Returns:
          The updated job object.

      .. API reference (generated - do not edit) ::

      **POST** ``/jobs/{jobId}/reschedule``

      Reschedule

      Re-run a failed job

      API parameters:
          * ``jobId`` (path) -- Id of the job to reschedule.

      API request body:
          * ``automated`` (optional) -- Set true when the reschedule is triggered automatically rather than by a user.

      .. end API reference ::

  - `Jobs.set_complete(self, messages: List[str] = None, output_entity_ids: List[str] = None, output_links: List[pipebio.models.output_link.OutputLink] = None) -> requests.models.Response`: Mark the current job complete (status COMPLETE, progress 100).

      Mark the current job complete (status COMPLETE, progress 100).

      Args:
          messages: Optional final status messages.
          output_entity_ids: Ids of output entities produced by the job.
          output_links: Download links produced by the job.

      Returns:
          The raw API response.

  - `Jobs.start_import_job(self, file_size: Optional[int] = None) -> requests.models.Response`: Trigger an import job run via the job-processing engine.

      Trigger an import job run via the job-processing engine.

      Args:
          file_size: Optional size of the uploaded file in bytes.

      Returns:
          The raw API response.

      .. API reference (generated - do not edit) ::

      **PATCH** ``/jobs/{jobId}/import``

      Import

      Parse newly imported sequences once their bytes have been uploaded

      API parameters:
          * ``jobId`` (path) -- Id of the import job to finalise.

      API request body:
          * ``fileSize`` (optional) -- Size of the uploaded file in bytes; can improve upload throughput.

      .. end API reference ::

  - `Jobs.update(self, status: pipebio.models.job_status.JobStatus, progress=None, messages: List[str] = None, output_entity_ids: List[str] = None, output_links: List[pipebio.models.output_link.OutputLink] = None, allow_deleted_entities: bool = False) -> requests.models.Response`: Update the current job's status.

      Update the current job's status.

      Args:
          status: The new :class:`~pipebio.models.job_status.JobStatus`.
          progress: Progress value, clamped to the range 0-100.
          messages: Status messages to attach.
          output_entity_ids: Ids of output entities produced by the job.
          output_links: Download links produced by the job.
          allow_deleted_entities: Allow referencing deleted entities.

      Returns:
          The raw API response.

      .. API reference (generated - do not edit) ::

      **PATCH** ``/jobs/{jobId}``

      Update

      Update a single job

      API parameters:
          * ``jobId`` (path) -- Id of the job to update.
          * ``allowDeletedEntities`` (query) -- If true, allow referencing entities that have been soft-deleted.

      API request body:
          * ``status`` -- New status to set on the job.
          * ``progress`` (optional) -- Job completion percentage between 0 and 100.
          * ``messages`` (optional) -- Status messages describing what the job is currently doing.
          * ``outputEntities`` (optional) -- Entity ids produced by the job.
          * ``outputLinks`` (optional) -- Downloadable output files produced by the job.

      .. end API reference ::

  - `Jobs.upload_data_to_signed_url(self, absolute_file_location: str, signed_url: str, signed_headers: Any) -> None`: Upload a file to a signed URL (small-file path).

      Upload a file to a signed URL (small-file path).

      For large files, prefer
      :func:`pipebio.multipart_upload.upload_multipart_aws`.

      Args:
          absolute_file_location: Path to the local file to upload.
          signed_url: The signed URL to upload to.
          signed_headers: Headers that must be sent unmodified with the upload.

      .. API reference (generated - do not edit) ::

      **POST** ``/sequences/signed-upload/{entityId}``

      Create a signed upload

      Start a signed upload; Upload sequences in bulk.

      API parameters:
          * ``entityId`` (path) -- Id of the entity the signed upload writes sequences into.
          * ``allowDeleted`` (query) -- If true, also operate on the entity when it has been soft-deleted.

      API request body:
          * ``location`` -- Can help with upload speeds

      .. end API reference ::



### pipebio.sequences

- class `ImportError`: Raised when a sequence import fails irrecoverably.

    Raised when a sequence import fails irrecoverably.


- class `Sequences`: Wraps the sequence extract/import API endpoints.

    Wraps the sequence extract/import API endpoints.

    Obtain an instance via :attr:`PipebioClient.sequences` rather than
    constructing it directly.

  - `Sequences.convert_parquet_to_tsv(path_to_parquet_data: str, path_to_tsv_file: str, skip_header: bool = False, chunk_size: int = 10000) -> None`: Convert a Parquet shard to TSV, appending to the output file.

      Convert a Parquet shard to TSV, appending to the output file.

      Args:
          path_to_parquet_data: Path to the input Parquet file.
          path_to_tsv_file: Path to the output TSV file (overwritten on the
              first chunk, appended thereafter).
          skip_header: If ``True``, do not write a header row.
          chunk_size: Number of rows to convert per chunk.

  - `Sequences.create_signed_upload(self, entity_id: str, retries: int = 5) -> dict`: Create a signed upload slot for sequence data.

      Create a signed upload slot for sequence data.

      Retries with a short backoff on failure.

      Args:
          entity_id: Id of the document to upload sequences into.
          retries: Number of remaining retry attempts.

      Returns:
          The signed-upload response object.

      .. API reference (generated - do not edit) ::

      **POST** ``/sequences/signed-upload/{entityId}``

      Create a signed upload

      Start a signed upload; Upload sequences in bulk.

      API parameters:
          * ``entityId`` (path) -- Id of the entity the signed upload writes sequences into.
          * ``allowDeleted`` (query) -- If true, also operate on the entity when it has been soft-deleted.

      API request body:
          * ``location`` -- Can help with upload speeds

      .. end API reference ::

  - `Sequences.download(self, entity_id: str, destination: str = None, sort: List[pipebio.models.sort.Sort] = None, query: str = None, include_cols: Optional[List[str]] = None, exclude_cols: Optional[List[str]] = None, limit: int = None, allow_deleted: bool = True) -> str`: Download the sequences of a single document to a local file.

      Download the sequences of a single document to a local file.

      Args:
          entity_id: Id of the document to download.
          destination: Local path to write the assembled TSV to.
          sort: Deprecated. Will be removed in a future release.
          query: Deprecated. Will be removed in a future release.
          include_cols: Deprecated. Will be removed in a future release.
          exclude_cols: Deprecated. Will be removed in a future release.
          limit: Deprecated. Will be removed in a future release.
          allow_deleted: Whether to include deleted sequences.

      Returns:
          The ``destination`` path that was written.

      .. API reference (generated - do not edit) ::

      **POST** ``/entities/{id}/_extract``

      Extract sequences

      API parameters:
          * ``id`` (path) -- Id of the document to extract rows from.
          * ``sort`` (query) -- Sort expression in the form "columnName:asc" or "columnName:desc".
          * ``pageOffset`` (query) -- Zero-based index of the first row to return.
          * ``pageLimit`` (query) -- Maximum number of rows to return.
          * ``includeCols`` (query) -- Comma-separated list of column names to include in the response.
          * ``excludeCols`` (query) -- Comma-separated list of column names to exclude from the response.
          * ``includeTotalCount`` (query) -- If true, include the total matching row count in the response.
          * ``includeHeaders`` (query) -- If true, include column header metadata in the response.
          * ``includeSortCols`` (query) -- If true, include hidden helper columns used for sorting.
          * ``allowDeleted`` (query) -- If true, also operate on the document when it has been soft-deleted.

      API request body:
          * ``filter`` (optional) -- Query expression, or list of query clauses, selecting matching rows.
          * ``options`` (optional) -- Additional query options.
          * ``selection`` (optional) -- Explicit row ranges to operate on instead of a filter.
          * ``sort`` (optional) -- Sort order to apply to the results.
          * ``jobId`` (optional) -- Id of an existing job to associate the extract with.

      .. end API reference ::

  - `Sequences.download_to_memory(self, entity_ids: List[str]) -> Dict[str, Any]`: Download several documents and return their sequences in memory.

      Download several documents and return their sequences in memory.

      Args:
          entity_ids: Ids of the documents to download.

      Returns:
          A map keyed by a compound ``"<entity_id>##@##<sequence_id>"`` id,
          each value containing the parsed id, name, sequence, annotations and
          type.

  - `Sequences.get_joined_cols(cols, parameter)`: (no description)
  - `Sequences.import_signed_upload(self, import_details: Dict, allow_deleted_entity: bool = True, remaining_retries: int = 10) -> bool`: Trigger import of a previously uploaded file, polling to completion.

      Trigger import of a previously uploaded file, polling to completion.

      Handles network errors, HTTP errors, rate limits and "already exists"
      responses with exponential backoff.

      Args:
          import_details: The import descriptor returned by the upload step.
          allow_deleted_entity: Whether to allow importing into a deleted
              entity.
          remaining_retries: Number of remaining retry attempts.

      Returns:
          ``True`` when the import succeeds.

      Raises:
          ImportError: If the import finishes in a failed state.
          Exception: On unexpected states or exhausted network retries.

      .. API reference (generated - do not edit) ::

      **POST** ``/sequences/import-signed-upload``

      Import signed upload

      Finish a signed upload; Upload sequences in bulk.

      API parameters:
          * ``allowDeletedEntity`` (query) -- If true, allow referencing an entity that has been soft-deleted.
          * ``format`` (query) -- Format of the uploaded sequence data.

      API request body:
          * ``schema`` -- Column schema describing the uploaded sequence data.
          * ``entityId`` -- Id of the entity the uploaded data is imported into.
          * ``id`` -- Id returned when the signed upload was created.
          * ``location`` -- Can help with upload speeds

      .. end API reference ::

  - `Sequences.maybe_compress_file(file_path) -> str`: (no description)
  - `Sequences.upload(self, url: str, file_path: str, headers: dict = None, retries: int = 5) -> None`: Upload a local file to a signed URL, retrying on connection errors.

      Upload a local file to a signed URL, retrying on connection errors.

      Args:
          url: The signed URL to PUT the data to.
          file_path: Path to the local file to upload.
          headers: Optional headers to include (e.g. for server-side
              encryption).
          retries: Number of remaining retry attempts.

      Raises:
          Exception: If the upload times out after exhausting retries.



### pipebio.workflows

- class `Workflows`: Wraps workflow execution on top of the ``jobs`` API.

    Wraps workflow execution on top of the ``jobs`` API.

    Obtain an instance via :attr:`PipebioClient.workflows` rather than
    constructing it directly.

  - `Workflows.run_workflow(self, project_id: str, workflow_id: str, name: str, input_entity_ids: List[str], organization_id: Optional[str] = None, target_folder_id: Optional[str] = None, params: Optional[Dict[str, Any]] = None, poll_job: bool = False) -> Dict[str, Any]`: Resolve and run a saved workflow.

      Resolve and run a saved workflow.

      Args:
          project_id: Id of the project (shareable) to run the workflow in.
          workflow_id: Id of the saved workflow definition.
          name: User-facing name for the resulting workflow job.
          input_entity_ids: Ids of the input documents/entities.
          organization_id: Organization id. Defaults to the user's default org.
          target_folder_id: Optional id of the folder to write outputs to.
          params: Values for the workflow's settable parameters, keyed by
              parameter name.
          poll_job: If ``True``, block until the workflow job completes.

      Returns:
          The workflow job object (completed when ``poll_job`` is set).

      .. API reference (generated - do not edit) ::

      **POST** ``/jobs``

      Create

      Create a new job

      API parameters:
          * ``allowDeletedEntities`` (query) -- If true, allow referencing entities that have been soft-deleted.

      API request body:
          * ``name`` -- Give the job a friendly name that is meaningful to the end user
          * ``clientSide`` (optional) -- Set true if you want to run the job locally yourself and not on PipeBio servers
          * ``shareableId`` -- Copy your project id from the project settings page
          * ``params`` -- Parameters the job can use
          * ``type`` -- What type of job is this
          * ``messages`` -- Update the user with details about what the job is currently doing
          * ``inputEntities`` -- Entity ids of entities that should be fed into this job
          * ``status`` -- Initial status of the job.

      .. end API reference ::



### pipebio.shareables

- class `Shareables`: Wraps the ``shareables`` API endpoints.

    Wraps the ``shareables`` API endpoints.

    Obtain an instance via :attr:`PipebioClient.shareables` rather than
    constructing it directly.

  - `Shareables.create_project(self, name: str, owner_id: str) -> dict`: Create a new project shareable.

      Create a new project shareable.

      Args:
          name: Display name for the project.
          owner_id: Id of the owning organization/user.

      Returns:
          The created project object.

      .. API reference (generated - do not edit) ::

      **POST** ``/shareables``

      Create

      Create a new shareable (project) and configure initial settings such as membership, privacy etc

      API request body:
          * ``type`` -- Type of shareable to create (currently always a project).
          * ``name`` -- Name of the new project.
          * ``description`` (optional) -- Optional description of the project.
          * ``ownerId`` -- Copy your organization id from the admin settings page
          * ``members`` (optional) -- Users to grant access to, with their permission levels.
          * ``labels`` (optional) -- Optional labels used to categorise the project.

      .. end API reference ::

  - `Shareables.get_project(self, project_name: str) -> dict`: Find a project by its exact name.

      Find a project by its exact name.

      Args:
          project_name: The exact project name to look for.

      Returns:
          The matching project object.

      Raises:
          Exception: If no project with that name is found.

  - `Shareables.list(self) -> List[dict]`: List the shareables (projects) the user can access.

      List the shareables (projects) the user can access.

      Returns:
          The list of shareable objects.

      .. API reference (generated - do not edit) ::

      **GET** ``/shareables``

      List

      List all shareables for the current user.

      API parameters:
          * ``sort`` (query) -- Sort expression in the form "columnName:asc" or "columnName:desc".
          * ``type`` (query) -- Filter shareables by type (e.g. project).

      .. end API reference ::

  - `Shareables.list_entities(self, shareable_id: str) -> List[dict]`: List the entities contained in a shareable.

      List the entities contained in a shareable.

      Args:
          shareable_id: Id of the shareable (project) to list entities from.

      Returns:
          The entities as a list of dict rows parsed from the TSV response.

      .. API reference (generated - do not edit) ::

      **GET** ``/shareables/{id}/entities``

      List entities

      List all entities for the given project.

      API parameters:
          * ``id`` (path) -- Id of the shareable (project) to list entities for.
          * ``visible`` (query) -- If true, only return entities that are visible.
          * ``deleted`` (query) -- If true, only return entities that have been soft-deleted.
          * ``parentId`` (query) -- Only return direct children of this parent entity id.

      .. end API reference ::



### pipebio.organization_lists

- class `OrganizationLists`: Wraps the ``organizations/{id}/lists`` API endpoints.

    Wraps the ``organizations/{id}/lists`` API endpoints.

    Obtain an instance via :attr:`PipebioClient.organization_lists` rather than
    constructing it directly. When ``organization_id`` is omitted, the user's
    default organization is used.

  - `OrganizationLists.get_germlines(self, organization_id: str = None) -> List[Dict[str, Any]]`: List the germline lists for an organization.

      List the germline lists for an organization.

      Args:
          organization_id: Organization id. Defaults to the user's default org.

      Returns:
          The list of germline list objects.

      .. API reference (generated - do not edit) ::

      **GET** ``/organizations/{organizationId}/lists``

      List

      Returns all available lists in your organization and also those you own specifically.

      API parameters:
          * ``organizationId`` (path) -- Id of the organization that owns the lists.
          * ``kind`` (query) -- Filter lists by kind.

      .. end API reference ::

  - `OrganizationLists.get_scaffolds(self, organization_id: str = None) -> Any`: List the scaffold lists for an organization.

      List the scaffold lists for an organization.

      Args:
          organization_id: Organization id. Defaults to the user's default org.

      Returns:
          The scaffolds response object.

      .. API reference (generated - do not edit) ::

      **GET** ``/organizations/{organizationId}/lists``

      List

      Returns all available lists in your organization and also those you own specifically.

      API parameters:
          * ``organizationId`` (path) -- Id of the organization that owns the lists.
          * ``kind`` (query) -- Filter lists by kind.

      .. end API reference ::

  - `OrganizationLists.get_workflow(self, workflow_id: str, organization_id: str = None) -> Any`: Fetch a single workflow list by id.

      Fetch a single workflow list by id.

      Args:
          workflow_id: Id of the workflow list to fetch.
          organization_id: Organization id. Defaults to the user's default org.

      Returns:
          The workflow list object.

      Raises:
          ValueError: If the list is missing or is not of kind ``WORKFLOW``.

      .. API reference (generated - do not edit) ::

      **GET** ``/organizations/{organizationId}/lists/{listId}``

      Get one

      Returns a specific list within your organization.

      API parameters:
          * ``organizationId`` (path) -- Id of the organization that owns the list.
          * ``listId`` (path) -- Id of the organization list to fetch.

      .. end API reference ::



### pipebio.uploader

- class `Uploader`: Buffered uploader that writes schema-applied rows to a PipeBio document.

    Buffered uploader that writes schema-applied rows to a PipeBio document.

  - `Uploader.add_natural_sort_columns(self, schema: List[pipebio.column.Column]) -> List[pipebio.column.Column]`: Inserts columns for natural sort.

      Inserts columns for natural sort.

  - `Uploader.build_no_sort_cols()`: (no description)
  - `Uploader.build_unique_schema(self) -> List[Dict[str, Any]]`: Return the schema as de-duplicated name/type/description dicts.

      Return the schema as de-duplicated name/type/description dicts.

  - `Uploader.cols_to_header_line(self) -> str`: Return the tab-separated header line for the current schema.

      Return the tab-separated header line for the current schema.

  - `Uploader.escape_tsv_within_tsv(tsv_line)`: We encode annotations as a tsv within the larger tsv document, therefore we need to escape tsv chartacters.

      We encode annotations as a tsv within the larger tsv document, therefore we need to escape tsv chartacters.
      :return:

  - `Uploader.fill_string_sort_cell(value: str, kind: <RendererCodes.medianv1: 'medianv1'> = None)`: (no description)
  - `Uploader.get_sort_kind(description: Optional[str]) -> pipebio.models.render_codes.RendererCodes`: (no description)
  - `Uploader.get_type(self) -> pipebio.models.entity_types.EntityTypes`: Return the inferred document type (alignment vs the configured type).

      Return the inferred document type (alignment vs the configured type).

  - `Uploader.make_line(self, row_data: dict) -> str`: Applies the columns to the row data.

      Applies the columns to the row data.

  - `Uploader.needs_natural_sort(self, column: pipebio.column.Column) -> bool`: Some columns are blacklisted as not needing sort. Other more uncommon columns can mark they do not need sort

      Some columns are blacklisted as not needing sort. Other more uncommon columns can mark they do not need sort
      by setting "column.no_sort".

  - `Uploader.upload(self, allow_empty: bool = False) -> bool`: Flush all buffered rows and wait for the uploads to finish.

      Flush all buffered rows and wait for the uploads to finish.

      Args:
          allow_empty: If ``True``, do not raise when nothing was written.
              Useful for merged-read jobs where one output may legitimately be
              empty.

      Returns:
          ``True`` if all chunk uploads succeeded, ``False`` otherwise.

      Raises:
          ValueError: If nothing was written and ``allow_empty`` is ``False``.

  - `Uploader.upload_if_ready(self, force: bool = False) -> None`: Upload the current chunk if it is full (or ``force`` is set).

      Upload the current chunk if it is full (or ``force`` is set).

      Args:
          force: If ``True``, upload the current chunk regardless of size and
              do not open a new chunk file.

  - `Uploader.write_data(self, data: dict) -> None`: Write a single row, applying the schema and buffering for upload.

      Write a single row, applying the schema and buffering for upload.

      Inspects the first rows to infer sequence kind and whether the document
      is an alignment, then uploads the current chunk once it is full.

      Args:
          data: The row as a mapping of column name to value.



### pipebio.multipart_upload

- `upload_multipart_aws(session: requests_toolbelt.sessions.BaseUrlSession, absolute_file_location: str, file_name: str, parent_id: str, project_id: str, organization_id: str, details: Optional[List[pipebio.models.upload_detail.UploadDetail]] = None, file_name_id: Optional[str] = None, on_progress: Optional[Callable[[int, int], NoneType]] = None) -> dict`: Upload a large file to an AWS instance using S3 multipart upload.

    Upload a large file to an AWS instance using S3 multipart upload.

    Coordinates with the server's multipart-upload endpoints to split the file
    into parts, upload each with retries, and finalise the upload. Attempts to
    abort on failure to free orphaned parts.

    Args:
        session: An authenticated base-url session from the client.
        absolute_file_location: Path to the local file to upload.
        file_name: Friendly name shown in the PipeBio UI.
        parent_id: Id of the target parent folder.
        project_id: Id of the project (shareable) to upload into.
        organization_id: Organization id that will own the upload.
        details: Optional per-file upload details/metadata.
        file_name_id: Optional client-supplied id used to correlate the file.
        on_progress: Optional callback receiving ``(bytes_uploaded, file_size)``
            after each part.

    Returns:
        The created upload job object.

    Raises:
        ValueError: If the file is empty.


### pipebio.column

- class `BooleanColumn`: (no description)
  - `BooleanColumn.parse(self, value)`: (no description)
  - `BooleanColumn.to_json(self) -> dict`: (no description)

- class `Column`: (no description)
  - `Column.parse(self, value)`: (no description)
  - `Column.to_json(self) -> dict`: (no description)

- class `ConstantColumn`: (no description)
  - `ConstantColumn.parse(self, value)`: (no description)
  - `ConstantColumn.to_json(self) -> dict`: (no description)

- class `IntegerColumn`: (no description)
  - `IntegerColumn.parse(self, value)`: (no description)
  - `IntegerColumn.to_json(self) -> dict`: (no description)

- class `NumberColumn`: (no description)
  - `NumberColumn.parse(self, value)`: (no description)
  - `NumberColumn.to_json(self) -> dict`: (no description)
  - `NumberColumn.write_for_db(value: Union[float, str]) -> str`: Writes in a value so it can be parsed.

      Writes in a value so it can be parsed.


- class `StringColumn`: (no description)
  - `StringColumn.parse(self, value)`: (no description)
  - `StringColumn.to_json(self) -> dict`: (no description)

- `strtobool(val: str) -> bool`: Convert a string representation of truth to True or False.

    Convert a string representation of truth to True or False.

    True values are 'y', 'yes', 't', 'true', 'on', and '1';
    False values are 'n', 'no', 'f', 'false', 'off', and '0'.
    Raises ValueError if 'val' is anything else.

- `take_uniques(maybe_with_dupes: List[<built-in function any>]) -> List[<built-in function any>]`: Like doing set(columns) but has the benefit of preserving order.

    Like doing set(columns) but has the benefit of preserving order.
    Uses the hash on an object for comparison.


### pipebio.models.job_type

- enum `JobType`: The type of job to run.
  - values: AmpliconOverlapAssemblyJob, ImportJob, FlashJob, AnnotateJob, AnnotateForBenchlingJob, CompareJob, ClusterJob, DetectMixedWellsJob, ChartJob, AlignJob, AlignNumberedJob, AlignAnchoredJob, SubtractionJob, AddToSequenceStoreJob, QuerySequenceStoreJob, RemoveSequencesFromStoreJob, ExtractJob, ExtractAndStitchJob, ConcatenateJob, RestrictionClone, CodonOptimiseJob, ExportJob, AddColumnsJob, RemoveColumnsJob, SangerAssemblyJob, SangerAlignmentJob, SangerSecondaryPeaksJob, WorkflowJob, ExtractMostAbundantJob, QcFor10xJob, TrimJob, CollapseUmiJob, PairJob, SummaryJob, NumberSequencesJob, ReconstructSequenceJob, MoveEntitiesJob, BackTranslateJob, SequencingQcJob, SynthesisCheckJob, DegenerateNucleotideSequencesJob, DifferentialEnrichmentJob, ReverseComplementJob, HumanizeJob, ExtractDifferentiallyEnrichedJob, DiversityAnalysisJob, AlignmentBasedDiversitySelectionJob, LiabilityBasedSelectionJob, AggregationJob, ProteinPropertiesJob, ClusterAssemblyJob, DemuxJob, BulkRemoveAnnotationsJob, OverlapAssemblyJob, AddToBenchlingJobV2, RuleBasedSelectionJob, ChartSummaryJob, FindRareAaJob, EnaImportJob, MlPredictAntibodyStructureJob, AddToLabkeyJob, TrimUmiJob, CollapsePcrDuplicatesJob, ExtractConsensusJob, HumannessJob, InsertMakerJob, PseudogeneFinderJob, DevelopabilityJob, HitpickJob, HumanizationJob, AwsImportJob, Merge10xSequencesAndAssayDataJob, SplitDocumentJob, CorrectLiabilitiesJob, FindAndReplaceJob, BindingPredictionJob, VariantGenerationJob, ProteinMpnnJob, EpianalyzerJob, ExtractUmiByAnchorJob, ClusterSequencesJob, DeduplicateUmiJob, DiamondAlignJob, LibraryDiversityJob, FastQcJob, FastpMergeJob, MergeAssayDataJob, CopyJob, QueryStoreJob, AddToBenchlingJob, MlHitpickingJob, StoreV3AddFromDocumentJob, StoreV3QueryJob, PluginJob

    The type of job to run.

    Covers the customer-facing subset of the server-side ``JobType`` enum.
    Legacy/SDK-only members may also be retained for backwards compatibility even if absent from the current canonical source.

    Members:
      AmpliconOverlapAssemblyJob: Assembles heavy and light chain reads into scFv contigs using overlap assembly. Runs in Python.
      ImportJob: Imports sequence or tabular data from uploaded files into new entities. Runs in Python.
      FlashJob: Merges overlapping paired-end reads using the FLASH algorithm. Runs in Python.
      AnnotateJob: Annotates sequences using scaffold-based germline alignment (FR/CDR regions). Runs in Python.
      AnnotateForBenchlingJob: Annotates sequences for Benchling using scaffold-based domain decomposition. Runs in Python.
      CompareJob: Compares and clusters sequences across multiple samples to identify shared and unique clusters. Runs in Python.
      ClusterJob: Clusters sequences using CD-HIT, K-mer, or flat-list algorithms. Runs in Python.
      DetectMixedWellsJob: Detects wells containing mixed sequences by clustering similar sequences. Runs in Python.
      ChartJob: Generates charts and visualizations (heatmaps, trees, logos, etc.) from documents. Runs in Python.
      AlignJob: Aligns sequences using MAFFT or MUSCLE and generates a phylogenetic tree. Runs in Python.
      AlignNumberedJob: Aligns sequences and preserves IMGT/Kabat numbering. Runs in Python.
      AlignAnchoredJob: Aligns sequences using annotation-based anchors from a scaffold. Runs in Python.
      SubtractionJob: Deprecated: No current implementation; Python file was removed in 2022.
      AddToSequenceStoreJob: Adds sequences from a document to a sequence store (Store v2). Runs server-side.
      QuerySequenceStoreJob: Queries a sequence store and adds match counts to a document. Runs server-side.
      RemoveSequencesFromStoreJob: Deprecated: Never implemented; superseded by Store v3.
      ExtractJob: Extracts a single region from sequences in a document. Runs in Python.
      ExtractAndStitchJob: Extracts specified regions from sequences and stitches them into a contiguous sequence. Runs in Python.
      ConcatenateJob: Concatenates multiple sequence documents into a single document. Runs in Python.
      RestrictionClone: Restriction cloning: inserts DNA fragments into vectors using restriction enzymes. Runs client-side in the browser.
      CodonOptimiseJob: Optimizes codon usage in DNA sequences for improved expression. Runs in Python.
      ExportJob: Exports sequence documents to various file formats (CSV, TSV, Excel, FASTA, etc.). Runs in Python.
      AddColumnsJob: Adds columns to a document's schema. Runs server-side.
      RemoveColumnsJob: Removes columns from a document's schema. Runs server-side.
      SangerAssemblyJob: Assembles Sanger traces into consensus sequences using Tracy. Runs in Python.
      SangerAlignmentJob: Aligns Sanger trace sequences to a reference and produces consensus sequences. Runs in Python.
      SangerSecondaryPeaksJob: Detects secondary peaks in Sanger chromatograms and optionally replaces bases with degenerate codes. Runs in Python.
      WorkflowJob: Runs a predefined workflow of jobs, with support for parallel branches. Runs in Python.
      ExtractMostAbundantJob: Extracts the most abundant sequences from each input document. Runs in Python.
      QcFor10xJob: Performs quality control on 10x Genomics single-cell antibody data. Runs in Python.
      TrimJob: Trims sequences using quality-based or primer-based trimming. Runs in Python.
      CollapseUmiJob: Deprecated: Superseded by CollapsePcrDuplicatesJob; Python file was removed in 2025.
      PairJob: Pairs sequences from documents by a grouping column and chain column (e.g., VH+VL). Runs in Python.
      SummaryJob: Generates summary reports (bar charts, box plots, statistics) from annotated documents. Runs in Python.
      NumberSequencesJob: Assigns IMGT numbering to antibody sequences. Runs in Python.
      ReconstructSequenceJob: Reconstructs sequences by replacing low-quality or mutated regions with germline reference. Runs in Python.
      MoveEntitiesJob: Moves entities (files/folders) between projects or folders. Runs server-side.
      BackTranslateJob: Back-translates amino acid sequences to DNA using a codon usage map. Runs in Python.
      SequencingQcJob: Performs quality control on sequences based on quality scores and length thresholds. Runs in Python.
      SynthesisCheckJob: Groups sequences by name and aligns matches to verify synthesis correctness. Runs in Python.
      DegenerateNucleotideSequencesJob: Generates degenerate nucleotide sequences from protein sequences using codon usage tables. Runs in Python.
      DifferentialEnrichmentJob: Performs differential enrichment analysis on clustered data using edgeR. Runs in Python.
      ReverseComplementJob: Reverses and complements DNA sequences in a document. Runs in Python.
      HumanizeJob: Deprecated: Legacy humanization job type used by the disabled "Humanize (AI)" dialog (HumanizeComponent, featureSwitchedOff). No humanize_job.py exists so dispatching would fail; superseded by HumanizationJob.
      ExtractDifferentiallyEnrichedJob: Extracts the most differentially enriched sequences from clusters. Runs in Python.
      DiversityAnalysisJob: Selects diverse representative sequences from clusters using phylogenetic tree pruning. Runs in Python.
      AlignmentBasedDiversitySelectionJob: Selects diverse sequences based on phylogenetic tree distance. Runs in Python.
      LiabilityBasedSelectionJob: Selects representative sequences from clusters using liability scores and IgG counts. Runs in Python.
      AggregationJob: Computes aggregate statistics (median, sum, min, max, etc.) per group. Runs in Python.
      ProteinPropertiesJob: Calculates protein properties (molecular weight, isoelectric point, etc.) for sequences. Runs in Python.
      ClusterAssemblyJob: Assembles reads within clusters into contigs and aligns contigs with reads. Runs in Python.
      DemuxJob: Demultiplexes sequences by barcode and splits into separate documents per barcode. Runs in Python.
      BulkRemoveAnnotationsJob: Bulk removes annotations from a document's sequences. Runs server-side.
      OverlapAssemblyJob: Assembles paired VH and VL antibody chains by overlap using cdrh3Sequence as the join key. Runs in Python.
      AddToBenchlingJobV2: Uploads sequences to Benchling using the bulk upsert API (v2). Runs in Python.
      RuleBasedSelectionJob: Selects rows from a document using rule-based ranking (e.g., top N per group). Runs in Python.
      ChartSummaryJob: Workflow-level chart summary step that aggregates chart outputs from workflow branches. Not a standalone job.
      FindRareAaJob: Identifies amino acids that occur infrequently at IMGT positions relative to a germline database. Runs in Python.
      EnaImportJob: Imports FASTQ files from the European Nucleotide Archive (ENA) FTP servers. Runs in Python.
      MlPredictAntibodyStructureJob: Predicts 3D structures for antibodies/nanobodies/TCRs using ImmuneBuilder. Runs in Python.
      AddToLabkeyJob: Deprecated: LabKey integration was removed in 2025.
      TrimUmiJob: Extracts UMIs from NGS reads and trims them from the sequence. Runs in Python.
      CollapsePcrDuplicatesJob: Collapses PCR duplicates by clustering sequences with identical or similar UMIs. Runs in Python.
      ExtractConsensusJob: Computes consensus sequences from aligned sequences in each input document. Runs in Python.
      HumannessJob: Computes humanness scores for antibody sequences by BLAST against human germline databases. Runs in Python.
      InsertMakerJob: Creates a new document by inserting selected rows from a source document. Runs client-side in the browser.
      PseudogeneFinderJob: Finds human and chicken pseudogene annotations in antibody sequences. Runs in Python.
      DevelopabilityJob: Calculates developability scores for antibody sequences from pre-existing PDB structure attachments. Runs in Python.
      HitpickJob: Creates a hit list document from selected cart items. Runs client-side in the browser.
      HumanizationJob: Humanizes antibody sequences by optimizing humanness scores while conserving specified regions. Runs in Python.
      AwsImportJob: Imports files from AWS S3 buckets into PipeBio as sequence or tabular documents. Runs in Python.
      Merge10xSequencesAndAssayDataJob: Merges 10x assay data onto 10x sequence contigs by matching name to contig_id. Runs in Python.
      SplitDocumentJob: Splits a document into multiple parts by chunk size or chunk count. Runs in Python.
      CorrectLiabilitiesJob: Identifies and proposes mutations to correct developability liabilities in antibody sequences. Runs in Python.
      FindAndReplaceJob: Finds and replaces sequence text in reading-frame-aligned positions. Runs in Python.
      BindingPredictionJob: Predicts antibody-antigen binding using Prodigy, Antipasti, or AntiFormer. Runs in Python.
      VariantGenerationJob: Generates antibody variants based on user-specified mutation parameters. Runs in Python.
      EpianalyzerJob: Runs immunogenicity analysis (NetMHC/Epianalyzer) on sequences. Runs in Python.
      ExtractUmiByAnchorJob: Extracts UMIs from merged NGS reads using regex anchor matching. Runs in Python.
      ClusterSequencesJob: Clusters DNA sequences by nucleotide identity using MMseqs2 linclust to resolve UMI collisions. Runs in Python.
      DeduplicateUmiJob: Deduplicates reads by UMI using exact, union-find, or directional adjacency algorithms. Runs in Python.
      DiamondAlignJob: Aligns DNA reads against an AA reference via DIAMOND blastx with frameshift support. Runs in Python.
      LibraryDiversityJob: Computes NGS library depth/diversity metrics (rarefaction, Chao1, Gini) and generates UMAP plots. Runs in Python.
      FastQcJob: Runs FastQC on one imported read document and attaches the HTML report as a blob. Runs in Python.
      FastpMergeJob: Merges paired-end reads with fastp from stored original FASTQ uploads. Runs in Python.
      MergeAssayDataJob: Merges assay data into an entity table via LEFT JOIN. Runs in Python.
      CopyJob: Copies documents, folders, and reports to a destination project/folder. Runs in Python.
      MlHitpickingJob: Deprecated: ML-based hit picking; Python file was removed in 2025.


### pipebio.models.job_status

- enum `JobStatus`: The status of a job in its lifecycle.
  - values: QUEUED, RUNNING, FAILED, COMPLETE, CANCELLED

    The status of a job in its lifecycle.

    Mirrors the customer-facing subset of the server-side job status enum.


### pipebio.models.job_filter

- class `JobFilter`: Represents a single filter condition for querying jobs.

    Represents a single filter condition for querying jobs.

    Allowed comparators: =, !=, >, <, LIKE, NOT LIKE, ILIKE, NOT ILIKE
    Allowed joiners: AND (default), OR

  - `JobFilter.to_json(self) -> dict`: Serialize to API request format.

      Serialize to API request format.



### pipebio.models.entity_types

- enum `EntityTypes`: The type of an entity in the PipeBio document tree.
  - values: FOLDER, REPORT, CLUSTER, CLUSTER_V3, COMPARISON, SEQUENCE_DOCUMENT, ALIGNMENT, PDF, IMAGE, UNKNOWN

    The type of an entity in the PipeBio document tree.


### pipebio.models.export_format

- enum `ExportFormat`: A file format an entity can be exported to.
  - values: FASTA, FASTQ, GENBANK, TSV, CSV, EXCEL, PARQUET, DUCKDB

    A file format an entity can be exported to.

    Subset of the canonical server enum; formats gated behind feature
    flags or only applicable to specific file types are intentionally
    omitted.


### pipebio.models.table_column_type

- enum `TableColumnType`: The data type of a document column.
  - values: INTEGER, STRING, BYTES, BOOLEAN, NUMERIC, BIGNUMERIC, FLOAT, FLOAT64, ARRAY, STRUCT, TIMESTAMP

    The data type of a document column.

    Values map to the underlying storage types used by PipeBio's table
    backend.


### pipebio.models.render_codes

- enum `RendererCodes`: Hints that control column rendering and sort behaviour in the UI.
  - values: idcol, hidden, medianv1, natural

    Hints that control column rendering and sort behaviour in the UI.


### pipebio.models.sort

- class `Sort`: (no description)
  - `Sort.from_json(json: dict)`: (no description)
  - `Sort.to_json(self)`: (no description)
