Skip to main content

decentriq_platform.archv2

Sub-modules​

  • decentriq_platform.archv2.client
  • decentriq_platform.archv2.compute_job
  • decentriq_platform.archv2.materialization
  • decentriq_platform.archv2.release_policy_builder
  • decentriq_platform.archv2.secret
  • decentriq_platform.archv2.session

Classes​

ClientV2​

ClientV2(
    api: decentriq_platform.api.Api,
)

check_data_labs_compatibility​

def check_data_labs_compatibility(
    self,
    data_room_id: str,
    data_lab_ids: List[str],
) ‑> decentriq_platform.archv2.client.DataLabCompatibilityResponse

create_data_lab​

def create_data_lab(
    self,
    create_data_lab: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)],
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataLabV2

create_data_room​

def create_data_room(
    self,
    create_data_room: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)],
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataRoom

create_import_connector​

def create_import_connector(
    self,
    create_import_connector: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)],
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataRoom

Create an import-connector DCR through the dedicated endpoint (which tags it with the ImportConnector purpose, so it appears in get_import_connectors). Returns the created connector as a draft DCR: it has no materialization yet, so it is a plain DCR until the configuration wizard finalizes it — fetch the full connector via get_import_connector once it is ready.

create_job​

def create_job(
    self,
    data_room_id: str,
    data_room_compute_action: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)],
    freshness_token: Optional[str] = None,
    mode: Optional[Literal['always', 'if_stale']] = None,
) ‑> decentriq_platform.archv2.client.CreatedJob

Fire a compute action.

mode="if_stale" reuses the action's newest completed run when it belongs to the job the current state derives (that state's materialization is the current one) instead of running again; the returned run_status is COMPLETED iff a run was reused.

delete_data_lab​

def delete_data_lab(
    self,
    data_lab_id: str,
) ‑> None

delete_import_connector​

def delete_import_connector(
    self,
    import_connector_id: str,
) ‑> None

Delete an import-connector DCR. Only the owner or a super admin may delete it.

download_job_raw_errors​

def download_job_raw_errors(
    self,
    job_id: str,
) ‑> decentriq_platform.archv2.client.RawErrorsView

get_data_lab​

def get_data_lab(
    self,
    data_lab_id: str,
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataLabV2

get_data_labs​

def get_data_labs(
    self,
    user_id: str,
    verification_key: bytes,
) ‑> List[decentriq_platform.archv2.client.DataLabV2]

get_data_room​

def get_data_room(
    self,
    data_room_id: str,
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataRoom

get_data_room_action_info​

def get_data_room_action_info(
    self,
    data_room_id: str,
    data_room_compute_action: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)],
) ‑> decentriq_platform.archv2.client.Action

get_data_room_actions​

def get_data_room_actions(
    self,
    data_room_id: str,
) ‑> decentriq_platform.archv2.client.DataRoomActionsView

get_data_room_audit_log​

def get_data_room_audit_log(
    self,
    data_room_id: str,
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.DataRoomAuditLog

get_data_room_policies​

def get_data_room_policies(
    self,
    data_room_id: str,
    policy_ids: List[str],
) ‑> Dict[str, Union[decentriq_platform.archv2.client.PolicyNotFound, decentriq_platform.archv2.client.PolicyNotProvisioned, decentriq_platform.archv2.client.PolicyMetadata]]

get_import_connector​

def get_import_connector(
    self,
    import_connector_id: str,
    verification_key: bytes,
) ‑> decentriq_platform.archv2.client.ImportConnector

Fetch a finalized import-connector DCR together with its single materialization. The DCR's signed content is verified; the materialization body is returned as received (verify via its signed content). 404s for a draft connector — fetch that via get_data_room.

get_import_connector_runs​

def get_import_connector_runs(
    self,
    import_connector_id: str,
    limit: Optional[int] = None,
    next_cursor: Optional[str] = None,
    prev_cursor: Optional[str] = None,
) ‑> decentriq_platform.archv2.client.ImportConnectorRunsPage

List one page of the connector's Import runs, newest first, cursor-paginated — validation runs are not part of the import history. Each run carries its materialization outcome inline; on success that includes the produced dataset as snapshotted at settlement (its manifestHash resolves to the dataset and, via Client.get_dataset_encryption_key_secret_id, to its key).

get_import_connectors​

def get_import_connectors(
    self,
    user_id: str,
    verification_key: bytes,
) ‑> List[decentriq_platform.archv2.client.DataRoom]

List the user's import connectors. Only finalized (ready) connectors are returned — connectors still in configuration are addressed by id via get_import_connector.

get_job​

def get_job(
    self,
    job_id: str,
) ‑> decentriq_platform.archv2.client.Job

get_job_freshness​

def get_job_freshness(
    self,
    job_id: str,
) ‑> bool

get_job_results_as_decentriq_user​

def get_job_results_as_decentriq_user(
    self,
    job_id: str,
) ‑> bytes

Fetch the result zip via GET /jobs/:job_id/results.

Requires a Decentriq SuperAdmin (or SuperAdminReadOnly) token and an MDCR created with share_aggregated_results=True. The enclave enforces check_api_platform_user_permission_for_result.

get_job_status​

def get_job_status(
    self,
    job_id: str,
) ‑> decentriq_platform.archv2.client.JobStatusView

get_job_tasks​

def get_job_tasks(
    self,
    job_id: str,
) ‑> decentriq_platform.archv2.client.JobTasksView

get_materialization​

def get_materialization(
    self,
    materialization_id: str,
) ‑> decentriq_platform.archv2.client.MaterializationView

Fetch a materialization and its execution history. Owner-scoped: visible to the creator, their org, or an admin.

get_run_status​

def get_run_status(
    self,
    run_id: str,
) ‑> decentriq_platform.archv2.client.RunView

list_data_room_runs​

def list_data_room_runs(
    self,
    data_room_id: str,
    action: Union[Dict[str, ForwardRef('JSONType')], List[ForwardRef('JSONType')], str, int, float, bool, ForwardRef(None)] = None,
    limit: Optional[int] = None,
    next_cursor: Optional[str] = None,
    prev_cursor: Optional[str] = None,
) ‑> decentriq_platform.archv2.client.RunsPage

List one page of the runs fired against the data room, newest first, cursor-paginated. action optionally narrows the listing to one compute action, given as action JSON.

list_materializations​

def list_materializations(
    self,
    user_id: str,
    limit: Optional[int] = None,
    next_cursor: Optional[str] = None,
    prev_cursor: Optional[str] = None,
) ‑> decentriq_platform.archv2.client.MaterializationsPage

List one page of the materializations created by the user, newest first, cursor-paginated. Owner-scoped like get_materialization: visible to the user, their org, or an admin. Execution history is omitted from list items — fetch it via get_materialization.

revoke_materialization​

def revoke_materialization(
    self,
    materialization_id: str,
) ‑> None

Revoke a materialization (tombstone it). Only the creator or a super admin may revoke; the enclave stops honoring it on the next run.

stop_data_room​

def stop_data_room(
    self,
    data_room_id: str,
) ‑> None

ComputeJob​

ComputeJob(
    dcr_id: str,
    action: DataRoomComputeAction,
    result_zip_file_name: str,
    client: Client,
    as_decentriq_admin: bool = False,
)

Abstract base class for compute jobs in archv2 DCRs.

Initialize a compute job.

Parameters:

  • dcr_id: The identifier for the DCR or DataLab
  • action: The compute action to perform
  • result_zip_file_name: The name of the file in the zip to get the result from
  • client: The client instance for API communication
  • as_decentriq_admin: When True, retrieve results via GET /jobs/:job_id/results. Requires a Decentriq SuperAdmin token and the DCR's share_aggregated_results=True.

Ancestors (in MRO)

  • abc.ABC Descendants
  • decentriq_platform.data_lab.compute_job.DataLabEnhancedValidationStatusJob
  • decentriq_platform.data_lab.compute_job.DataLabStatisticsJob
  • decentriq_platform.data_lab.compute_job.DataLabValidationStatusJob
  • decentriq_platform.data_lab.compute_job.ValidationReportJob
  • decentriq_platform.media.compute_job.MediaAudienceUserListJob
  • decentriq_platform.media.compute_job.MediaDataAttributesJob
  • decentriq_platform.media.compute_job.MediaEstimateAudienceSizeJob
  • decentriq_platform.media.compute_job.MediaGetAudiencesJob
  • decentriq_platform.media.compute_job.MediaGetCustomAudiencesJob
  • decentriq_platform.media.compute_job.MediaGetSeedAudiencesJob
  • decentriq_platform.media.compute_job.MediaInsightsJob
  • decentriq_platform.media.compute_job.MediaLookalikeAudienceStatisticsJob
  • decentriq_platform.media.compute_job.MediaMatchingValidationReportJob
  • decentriq_platform.media.compute_job.MediaModelQualityReportJob
  • decentriq_platform.media.compute_job.MediaOverlapStatisticsJob
  • decentriq_platform.media.compute_job.ValidationReportJob

download_result​

def download_result(
    self,
    task_result_hash: str,
) ‑> io.RawIOBase

Download the result of the compute job.

Parameters:

  • task_result_hash: The hash of the task result to download

Returns:

  • The result of the compute job

get_result​

def get_result(
    self,
) ‑> bytes

Get the result of the compute job.

Returns:

  • The content of the result file as bytes or raises an exception if the job failed

get_result_as_zipfile​

def get_result_as_zipfile(
    self,
) ‑> zipfile.ZipFile

Get the result of the compute job as a zipfile.ZipFile.

Returns:

  • The content of the result file as a zipfile.ZipFile. If the job failed, an Exception will be raised.

is_complete​

def is_complete(
    self,
) ‑> bool

Check if the compute job is complete.

Returns:

  • True if the job is complete, False otherwise

result​

def result(
    self,
) ‑> Any

Get the parsed result of the compute job.

Each job subclass should implement this method and return the appropriate type which represents the job result.

run​

def run(
    self,
) ‑> None

Run the compute job.

Raises:

  • Exception: If the computation has already been run

wait_for_completion​

def wait_for_completion(
    self,
    timeout: Optional[int] = None,
    sleep_interval: int = 1,
) ‑> Self

Wait for the compute job to complete.

Parameters:

  • timeout: The maximum time to wait for the job to complete, in seconds
  • sleep_interval: The interval to wait between checks, in seconds

Returns:

  • The compute job

DataLabV2​

DataLabV2(
    *args,
    **kwargs,
)

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

Ancestors (in MRO)

  • builtins.dict

JobStatus​

JobStatus(
    *args,
    **kwds,
)

str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.str() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to 'strict'.

Ancestors (in MRO)

  • builtins.str
  • enum.Enum

MaterializationDataset​

MaterializationDataset(
    name: str,
    owners: List[str],
    readers: List[str] = <factory>,
    zip_path: Optional[str] = None,
)

The owned Dataset a materialization produces (the target).

Parameters:

  • name: Base name for the produced Dataset, used verbatim. The platform appends _{yyyy}-{mm}-{dd} at materialize time, plus a _{n} counter when a dataset with that name already exists.
  • owners: User ids granted Owner on the produced Dataset's key; at least one is required.
  • readers: User ids granted read access on the produced Dataset's key.
  • zip_path: Extract a single file from the result's zip at this path; None materializes the result bytes as-is.

MaterializationSource​

MaterializationSource(
    dcr_id: str,
    action: Union[JSONType, object],
    task_name: str,
    result_selector: str = 'success',
)

The completed DCR compute result a materialization reads from.

Parameters:

  • dcr_id: Source DataRoom whose completed result is materialized.
  • action: The DCR compute action that produces the result — a ddc DataRoomComputeAction (pydantic) or its camelCase JSON dict.
  • task_name: GlobalName of the task in the source compute graph.
  • result_selector: Which result of the action to materialize.

Secret​

Secret(
    secret: bytes,
    state: decentriq_dcr_compiler._schemas.secret_store_entry_state.SecretStoreEntryState,
)

Secret(secret: bytes, state: decentriq_dcr_compiler._schemas.secret_store_entry_state.SecretStoreEntryState)

SessionV2​

SessionV2(
    client: Client,
    connection: Connection,
)

Class for managing the communication with an enclave.

Session instances should not be instantiated directly but rather be created using a Client object using decentriq_platform.Client.create_session_v2.

create_materialization​

def create_materialization(
    self,
    source: MaterializationSource,
    dataset: MaterializationDataset,
) ‑> str

Create a materialization and return the materialization ID.

Takes the source result to materialize and the dataset to produce; the enclave derives createdBy/createdAt/sourceActionId and signs the stored Materialization. Serialized as ddc JSON bytes — like dcrAction — since the entity is a ddc serde type, not a proto.

create_policy​

def create_policy(
    self,
    policy: ReleasePolicy,
) ‑> str

Create a release policy and return the policy ID.

create_secret​

def create_secret(
    self,
    secret: Secret,
) ‑> str

Store a secret in the user's own enclave-protected secret store

get_secret​

def get_secret(
    self,
    secret_id: str,
) ‑> Tuple[decentriq_platform.archv2.secret.Secret, int]

remove_secret​

def remove_secret(
    self,
    secret_id: str,
    expected_cas_index: int,
) ‑> bool

send_authenticated_request​

def send_authenticated_request(
    self,
    authenticated_request: AuthenticatedRequest,
) ‑> gcg_pb2.AuthenticatedResponse

send_data_room_state_action_request​

def send_data_room_state_action_request(
    self,
    data_room_id: str,
    action: JSONType,
) ‑> Union[Dict[str, JSONType], List[JSONType], str, int, float, bool, ForwardRef(None)]

Send a DCR action request.

send_export_result_as_dataset_request​

def send_export_result_as_dataset_request(
    self,
    job_id: str,
    task_result_hash: str,
    zip_path: Optional[str],
) ‑> Tuple[str, str, str]

Export a result as a dataset.

send_get_verification_key_request​

def send_get_verification_key_request(
    self,
) ‑> bytes

Retrieve the verification key for a DCR.

send_retrieve_result_encryption_key_request​

def send_retrieve_result_encryption_key_request(
    self,
    job_id: str,
    task_result_hash: str,
) ‑> Tuple[str, bytes]

Retrieve the manifest hash and encryption key for a result.

send_secret_store_request​

def send_secret_store_request(
    self,
    request: SecretStoreRequest,
) ‑> secret_store_pb2.SecretStoreResponse

update_secret_acl​

def update_secret_acl(
    self,
    secret_id: str,
    new_acl: v0.SecretStoreEntryAcl,
    expected_cas_index: int,
) ‑> bool

Update a secret ACL