Python SDK Reference

Generated from the product SDK package softqcos-sdk.

Package: softqcos-sdk
Version: 3.6.1
API modules: 35

Install

pip install softqcos-sdk

Client setup

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key='sq-live-...', base_url='https://api.softquantus.com')

Module index

acos: ACOSAPI (8 methods)
admin: AdminAPI (10 methods)
algorithms: AlgorithmsAPI (14 methods)
autopilot: AutopilotAPI (4 methods)
backends: BackendsAPI (26 methods)
batch: BatchAPI (5 methods)
bench: BenchAPI (10 methods)
billing: BillingAPI (11 methods)
calibration: CalibrationAPI (13 methods)
chemistry: ChemistryAPI (10 methods)
circuits: CircuitsAPI (9 methods)
coherence: CoherenceAPI (7 methods)
dri: DRIAPI (14 methods)
energy: EnergyAPI (7 methods)
evidence: EvidenceAPI (7 methods)
glassbox: GlassBoxAPI (6 methods)
gpu_qpu: GPUQPULinkAPI (9 methods)
isolation: IsolationAPI (8 methods)
jobs: JobsAPI (10 methods)
ledger: LedgerAPI (14 methods)
macro: MacroAPI (4 methods)
marketplace: MarketplaceAPI (5 methods)
navcore: NavCoreAPI (48 methods)
network: NetworkAPI (18 methods)
provider_hub: ProviderHubAPI (5 methods)
qec: QECAPI (18 methods)
qec_service: QECServiceAPI (5 methods)
qlink: QLinkAPI (4 methods)
qubo: QUBOAPI (3 methods)
sandbox: SandboxAPI (3 methods)
session: SessionAPI (6 methods)
use_cases: UseCasesAPI (2 methods)
visualize: VisualizeAPI (6 methods)
workflow: WorkflowAPI (6 methods)
zne: ZNEAPI (1 methods)

Modules

`acos`

Class: ACOSAPI

Method	Signature	Description
`certificate`	`(self, certificate_id: 'str') -> 'Dict[str, Any]'`	Get certificate details.
`certificates`	`(self) -> 'Any'`	List all certificates.
`certify`	`(self, backend: 'str', tier: 'str' = 'bronze', **kwargs) -> 'Dict[str, Any]'`	Run certification on a backend.
`evidence`	`(self, evidence_id: 'str') -> 'Dict[str, Any]'`	Get certification evidence.
`health`	`(self) -> 'Dict[str, Any]'`	Check ACOS service health.
`tests`	`(self) -> 'Any'`	List available certification tests.
`tiers`	`(self) -> 'Any'`	List certification tiers.
`verify`	`(self, certificate_id: 'str') -> 'Dict[str, Any]'`	Verify a certificate.

`admin`

Class: AdminAPI

Method	Signature	Description
`backend_capabilities`	`(self, backend_id: 'str') -> 'Dict[str, Any]'`	Get backend capabilities.
`backends_status`	`(self) -> 'Any'`	Get all backends status.
`circuit_breaker_reset`	`(self, service_name: 'str') -> 'Dict[str, Any]'`	Reset a circuit breaker.
`circuit_breakers`	`(self) -> 'Any'`	Get circuit breaker states.
`health_live`	`(self) -> 'Dict[str, Any]'`	Liveness probe.
`health_ready`	`(self) -> 'Dict[str, Any]'`	Readiness probe.
`metrics`	`(self) -> 'Dict[str, Any]'`	Get platform metrics.
`rate_limits`	`(self) -> 'Dict[str, Any]'`	Get rate limit configuration.
`tenant_usage`	`(self, tenant_id: 'str') -> 'Dict[str, Any]'`	Get tenant usage.
`tenants`	`(self) -> 'Any'`	List tenants.

`algorithms`

Class: AlgorithmsAPI

Method	Signature	Description
`bernstein_vazirani`	`(self, secret: 'str', shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Bernstein-Vazirani hidden linear function recovery.
`deutsch_jozsa`	`(self, oracle_type: 'str' = 'balanced', n_qubits: 'int' = 3, shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Deutsch-Jozsa oracle classification.
`grover`	`(self, target: 'str', n_qubits: 'Optional[int]' = None, shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Grover’s unstructured search algorithm.
`info`	`(self, name: 'str') -> 'Dict[str, Any]'`	Get metadata and parameter schema for a specific algorithm.
`job_status`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get status of an async algorithm job.
`jobs`	`(self) -> 'Dict[str, Any]'`	List all algorithm jobs.
`list`	`(self) -> 'Dict[str, Any]'`	List all available quantum algorithms with metadata.
`qaoa`	`(self, graph: 'Dict[str, Any]', p: 'int' = 1, shots: 'int' = 1024, async_run: 'bool' = False, **kwargs: 'Any') -> 'Dict[str, Any]'`	QAOA MaxCut approximate optimisation.
`qft`	`(self, n_qubits: 'int', shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Quantum Fourier Transform.
`qpe`	`(self, phase: 'float', n_qubits: 'int' = 4, shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Quantum Phase Estimation.
`run`	`(self, name: 'str', params: 'Dict[str, Any]', shots: 'int' = 1024, async_run: 'bool' = False) -> 'Dict[str, Any]'`	Run any algorithm by name with arbitrary parameters.
`shor`	`(self, N: 'int', shots: 'int' = 1024, a: 'int' = 2, cluster_mode: 'str' = 'local', lumi_nodes: 'int' = 1, lumi_host: 'str' = 'lumi', azure_resource_id: 'str' = '', ibm_token: 'str' = '', async_run: 'bool' = False) -> 'Dict[str, Any]'`	Factor integer N using Shor’s algorithm.
`shor_and_wait`	`(self, N: 'int', shots: 'int' = 1024, cluster_mode: 'str' = 'local', lumi_nodes: 'int' = 1, **kwargs: 'Any') -> 'Dict[str, Any]'`	Submit Shor async and wait for result (LUMI-safe blocking helper).
`wait`	`(self, job_id: 'str', *, timeout: 'float' = 900.0, poll_interval: 'float' = 3.0) -> 'Dict[str, Any]'`	Poll until an async algorithm job completes.

`autopilot`

Class: AutopilotAPI

Method	Signature	Description
`execute`	`(self, circuit_qasm: 'str', num_qubits: 'int', shots: 'int' = 4096, objective: 'str' = 'auto', sovereign_mode: 'str' = 'none', vendor_id: 'Optional[str]' = None, budget_usd: 'Optional[float]' = None) -> 'Dict[str, Any]'`	Execute a circuit via autopilot — full AI selection and execution.
`plan`	`(self, num_qubits: 'int', circuit_depth: 'int' = 100, shots: 'int' = 4096, objective: 'str' = 'auto', sovereign_mode: 'str' = 'none', budget_usd: 'Optional[float]' = None) -> 'Dict[str, Any]'`	Generate an autopilot execution plan without submitting.
`recommend`	`(self, num_qubits: 'int', circuit_depth: 'int' = 100, shots: 'int' = 4096) -> 'Dict[str, Any]'`	Get backend recommendation for a given workload.
`vendors`	`(self) -> 'Dict[str, Any]'`	List all available autopilot vendors and backends.

`backends`

Class: BackendsAPI

Method	Signature	Description
`add`	`(self, **kwargs) -> 'Dict[str, Any]'`	Register a new backend.
`all_backends`	`(self) -> 'Any'`	List all available backends (platform + user).
`azure_backends`	`(self) -> 'Any'`	List Azure Quantum backends.
`azure_cancel`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Cancel Azure job.
`azure_estimate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Estimate Azure job cost.
`azure_execute`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute on Azure backend.
`azure_providers`	`(self) -> 'Any'`	List Azure Quantum providers.
`azure_status`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get Azure job status.
`azure_targets`	`(self) -> 'Any'`	List Azure Quantum targets.
`braket_backends`	`(self) -> 'Any'`	List AWS Braket backends.
`braket_cancel`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Cancel Braket job.
`braket_estimate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Estimate Braket job cost.
`braket_execute`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute on Braket backend.
`braket_status`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get Braket job status.
`delete`	`(self, backend_id: 'str') -> 'Dict[str, Any]'`	Remove a backend.
`execute`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute on a user backend.
`get`	`(self, backend_id: 'str') -> 'Dict[str, Any]'`	Get backend details.
`ibm_backends`	`(self) -> 'Any'`	List IBM Quantum backends.
`ibm_cancel`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Cancel IBM job.
`ibm_estimate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Estimate IBM job cost.
`ibm_execute`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute on IBM backend.
`ibm_status`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get IBM job status.
`list`	`(self) -> 'Any'`	List user-registered backends.
`providers`	`(self) -> 'Any'`	List supported backend providers.
`update`	`(self, backend_id: 'str', **kwargs) -> 'Dict[str, Any]'`	Update backend configuration.
`validate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Validate backend credentials.

`batch`

Class: BatchAPI

Method	Signature	Description
`cancel`	`(self, batch_id: 'str') -> 'Dict[str, Any]'`	Cancel a batch.
`list`	`(self, status: 'Optional[str]' = None, limit: 'int' = 20) -> 'List[Dict[str, Any]]'`	List batches.
`results`	`(self, batch_id: 'str', include_failed: 'bool' = True) -> 'List[Dict[str, Any]]'`	Get batch results.
`status`	`(self, batch_id: 'str') -> 'Dict[str, Any]'`	Get batch status.
`submit`	`(self, jobs: 'List[Dict[str, Any]]', name: 'str' = 'SDK Batch', backend: 'str' = 'aer', shots: 'int' = 1024, max_concurrent: 'int' = 10) -> 'Dict[str, Any]'`	Submit a batch of circuits.

`bench`

Class: BenchAPI

Method	Signature	Description
`download`	`(self, benchmark_id: 'str') -> 'Any'`	Download benchmark report.
`health`	`(self) -> 'Dict[str, Any]'`	Check bench service health.
`metrics_coverage`	`(self) -> 'Dict[str, Any]'`	Get metrics coverage.
`metrics_kpis`	`(self) -> 'Dict[str, Any]'`	Get metrics KPIs.
`report`	`(self, benchmark_id: 'str') -> 'Dict[str, Any]'`	Get benchmark report.
`run`	`(self, backend: 'str' = 'aer_simulator', **kwargs) -> 'Dict[str, Any]'`	Run a benchmark.
`selftest`	`(self) -> 'Dict[str, Any]'`	Run self-test.
`suites`	`(self, suite_id: 'Optional[str]' = None) -> 'Any'`	List suites or get a specific suite.
`verify`	`(self, benchmark_id: 'str') -> 'Dict[str, Any]'`	Verify benchmark evidence.
`workloads`	`(self) -> 'Any'`	List available workloads.

`billing`

Class: BillingAPI

Method	Signature	Description
`calculate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Calculate cost estimate.
`compare_providers`	`(self, **params) -> 'Any'`	Compare provider pricing.
`plans`	`(self) -> 'Any'`	List available plans.
`pricebook`	`(self) -> 'Any'`	Get full pricebook.
`providers`	`(self) -> 'Any'`	List billing providers.
`report_data`	`(self, **kwargs) -> 'Dict[str, Any]'`	Generate ROI report data.
`report_latex`	`(self, **kwargs) -> 'Any'`	Generate ROI report as LaTeX.
`report_pdf`	`(self, **kwargs) -> 'Any'`	Generate ROI report as PDF.
`scenarios`	`(self, **kwargs) -> 'Dict[str, Any]'`	Calculate multiple cost scenarios.
`v1_calculate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Calculate cost (v1 API).
`v1_providers`	`(self) -> 'Any'`	List providers (v1 API).

`calibration`

Class: CalibrationAPI

Method	Signature	Description
`compile`	`(self, qasm: 'str', **kwargs) -> 'Dict[str, Any]'`	Compile a circuit with calibration awareness.
`compile_status`	`(self, compilation_id: 'str') -> 'Dict[str, Any]'`	Get compilation status.
`device_state`	`(self, device_name: 'str') -> 'Dict[str, Any]'`	Get device calibration state.
`devices`	`(self) -> 'Any'`	List all calibrated devices.
`evidence_audit`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Get evidence audit trail.
`evidence_create`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create an evidence bundle.
`evidence_finalize`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Finalize an evidence bundle.
`evidence_get`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Get an evidence bundle.
`evidence_sign`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Sign an evidence bundle.
`evidence_verify`	`(self, **kwargs) -> 'Dict[str, Any]'`	Verify evidence.
`health`	`(self) -> 'Dict[str, Any]'`	Check calibration service health.
`info`	`(self) -> 'Dict[str, Any]'`	Get calibration service info.
`qubit`	`(self, device_name: 'str', qubit_id: 'int') -> 'Dict[str, Any]'`	Get individual qubit calibration data.

`chemistry`

Class: ChemistryAPI

Method	Signature	Description
`compare_molecules`	`(self, molecule_ids: 'List[str]') -> 'Dict[str, Any]'`	Compare correlation lengths across molecules.
`compute_correlations`	`(self, molecule_id: 'str', correlation_types: 'Optional[List[str]]' = None, use_cached_vqe: 'bool' = True) -> 'Dict[str, Any]'`	Compute quantum correlation functions for a molecule.
`get_ruler`	`(self, molecule_id: 'str') -> 'Dict[str, Any]'`	Get a cached molecular ruler result.
`get_simulation`	`(self, molecule_id: 'str') -> 'Dict[str, Any]'`	Get a specific VQE simulation result.
`health`	`(self) -> 'Dict[str, Any]'`	Check molecular ruler service health.
`list_molecules`	`(self) -> 'Dict[str, Any]'`	List available molecules with metadata.
`list_simulations`	`(self) -> 'Dict[str, Any]'`	List VQE simulation results.
`measure_ruler`	`(self, molecule_id: 'str', run_vqe: 'bool' = True, vqe_params: 'Optional[Dict[str, Any]]' = None) -> 'Dict[str, Any]'`	Full molecular ruler measurement (VQE + correlations + predictions).
`predict`	`(self, molecule_id: 'str', properties: 'Optional[List[str]]' = None) -> 'Dict[str, Any]'`	Predict chemical properties from VQE.
`run_vqe`	`(self, molecule_id: 'str', ansatz: 'str' = 'hardware_efficient', optimizer: 'str' = 'COBYLA', max_iterations: 'int' = 100, n_layers: 'int' = 2, shots: 'int' = 4096) -> 'Dict[str, Any]'`	Run VQE for a molecule.

`circuits`

Class: CircuitsAPI

Method	Signature	Description
`convert`	`(self, qasm: 'str', target_format: 'str' = 'qiskit') -> 'Dict[str, Any]'`	Convert circuit between formats.
`delete`	`(self, circuit_id: 'str') -> 'Dict[str, Any]'`	Delete a circuit.
`get`	`(self, circuit_id: 'str') -> 'Dict[str, Any]'`	Get circuit details.
`list`	`(self, **params) -> 'Any'`	List all circuits.
`optimize`	`(self, qasm: 'str', **kwargs) -> 'Dict[str, Any]'`	Optimize a circuit.
`simulate`	`(self, qasm: 'str', shots: 'int' = 1024, **kwargs) -> 'Dict[str, Any]'`	Simulate a circuit locally.
`stats`	`(self, circuit_id: 'str') -> 'Dict[str, Any]'`	Get circuit statistics (depth, gate count, etc.).
`submit`	`(self, qasm: 'str', **kwargs) -> 'Dict[str, Any]'`	Submit a circuit.
`validate`	`(self, qasm: 'str') -> 'Dict[str, Any]'`	Validate circuit syntax.

`coherence`

Class: CoherenceAPI

Method	Signature	Description
`get_report`	`(self, backend_id: 'str') -> 'Dict[str, Any]'`	Get coherence report for a single backend.
`health`	`(self) -> 'Dict[str, Any]'`	Check coherence monitor service health.
`health_check`	`(self, backend_id: 'str') -> 'Dict[str, Any]'`	Pre-flight health check for runtime pipeline.
`list_alerts`	`(self, backend_id: 'Optional[str]' = None) -> 'Dict[str, Any]'`	List all drift alerts.
`list_reports`	`(self) -> 'Dict[str, Any]'`	Get coherence reports for all tracked backends.
`probe`	`(self, backend_id: 'str', **metrics) -> 'Dict[str, Any]'`	Probe a backend for coherence data on-demand.
`probe_all`	`(self) -> 'Dict[str, Any]'`	Probe all backends.

`dri`

Class: DRIAPI

Method	Signature	Description
`evidence`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Get DRI evidence bundle.
`health`	`(self) -> 'Dict[str, Any]'`	Check DRI service health.
`list`	`(self) -> 'Any'`	List DRI assessments.
`probe`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run a DRI probe.
`proof`	`(self, test_id: 'str') -> 'Dict[str, Any]'`	Get proof-of-quantum result.
`proof_certificate`	`(self, test_id: 'str') -> 'Any'`	Get proof-of-quantum certificate PDF.
`proof_compare`	`(self, **kwargs) -> 'Dict[str, Any]'`	Compare proof-of-quantum results.
`proof_compare_certificate`	`(self, comparison_id: 'str') -> 'Any'`	Get comparison certificate PDF.
`proof_compare_result`	`(self, comparison_id: 'str') -> 'Dict[str, Any]'`	Get comparison result.
`proof_report`	`(self, test_id: 'str') -> 'Dict[str, Any]'`	Get proof-of-quantum report.
`proof_run`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run proof-of-quantum test.
`report`	`(self, rating_id: 'str') -> 'Dict[str, Any]'`	Get DRI report.
`run`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run DRI assessment.
`summary`	`(self, rating_id: 'str') -> 'Dict[str, Any]'`	Get DRI summary.

`energy`

Class: EnergyAPI

Method	Signature	Description
`backends`	`(self) -> 'Dict[str, Any]'`	List backends with energy/carbon metadata.
`carbon_report`	`(self, project_id: 'str') -> 'Dict[str, Any]'`	Get the carbon footprint report for a project.
`compare`	`(self, backends: 'List[str]', circuit_depth: 'int' = 100, shots: 'int' = 4096) -> 'Dict[str, Any]'`	Compare backends by estimated energy, carbon, and cost.
`get_budget`	`(self, project_id: 'str') -> 'Dict[str, Any]'`	Get the energy and carbon budget for a project.
`schedule`	`(self, job_id: 'str', backend_id: 'str' = 'lumi', mode: 'str' = 'green_first', max_wait_hours: 'float' = 8.0) -> 'Dict[str, Any]'`	Schedule a job to the next available green window.
`set_budget`	`(self, project_id: 'str', budget_kwh: 'Optional[float]' = None, budget_carbon_g: 'Optional[float]' = None) -> 'Dict[str, Any]'`	Set or update the energy/carbon budget for a project.
`windows`	`(self, backend_id: 'str' = 'lumi', hours_ahead: 'int' = 24) -> 'Dict[str, Any]'`	Get upcoming green (low-carbon) execution windows.

`evidence`

Class: EvidenceAPI

Method	Signature	Description
`artifact`	`(self, job_id: 'str', artifact_name: 'str') -> 'Any'`	Get a specific artifact.
`artifacts`	`(self, job_id: 'str') -> 'Any'`	List artifacts for a job.
`capabilities`	`(self, job_id: 'str') -> 'Any'`	List evidence capabilities for a job.
`download`	`(self, job_id: 'str', output_dir: 'str \| Path' = '.') -> 'Path'`	Download evidence bundle to disk.
`public_key`	`(self) -> 'dict[str, Any]'`	Get the QCOS evidence public key (PEM).
`runtime_execution_bundle`	`(self, job_id: 'str') -> 'dict[str, Any]'`	Get the immutable execution-evidence bundle for a Runtime job.
`verify`	`(self, evidence_hash: 'str') -> 'dict[str, Any]'`	Verify an evidence hash.

`glassbox`

Class: GlassBoxAPI

Method	Signature	Description
`compile`	`(self, circuit_qasm: 'str', device_name: 'str', optimization_level: 'int' = 2) -> 'Dict[str, Any]'`	Compile a circuit with full GlassBox visibility.
`create_evidence`	`(self, job_id: 'str', include_full_state: 'bool' = False) -> 'Dict[str, Any]'`	Create a cryptographic evidence bundle for a completed job.
`device_state`	`(self, device_name: 'str') -> 'Dict[str, Any]'`	Get real-time calibration state for a specific device.
`list_devices`	`(self) -> 'Dict[str, Any]'`	List all GlassBox-enabled quantum devices.
`qubit_properties`	`(self, device_name: 'str', qubit_id: 'int') -> 'Dict[str, Any]'`	Get detailed properties of a specific qubit.
`verify_evidence`	`(self, bundle_id: 'str') -> 'Dict[str, Any]'`	Verify the cryptographic integrity of a GlassBox evidence bundle.

`gpu_qpu`

Class: GPUQPULinkAPI

Method	Signature	Description
`modes`	`(self) -> 'Dict[str, Any]'`	List all simulation modes (statevector, MPS, tensor-network).
`paths`	`(self) -> 'Dict[str, Any]'`	List all available GPU↔QPU data paths and QLink tiers.
`profile`	`(self, num_qubits: 'int', shots: 'int' = 1024, circuit_depth: 'int' = 20, mode: 'str' = 'auto') -> 'Dict[str, Any]'`	Profile GPU execution — memory, bandwidth, fidelity.
`qlink_profile`	`(self, n_gpu_ranks: 'int' = 4, size_mb: 'float' = 256.0, iterations: 'int' = 10, mode: 'str' = 'auto') -> 'Dict[str, Any]'`	Benchmark QLink bandwidth and latency.
`qlink_simulate`	`(self, num_qubits: 'int', n_gpu_ranks: 'int' = 4, shots: 'int' = 4096, circuit_depth: 'int' = 50, mode: 'str' = 'auto', backend: 'str' = 'statevector') -> 'Dict[str, Any]'`	Run a large circuit via QLink multi-GPU sharding.
`qlink_status`	`(self, session_id: 'Optional[str]' = None) -> 'Dict[str, Any]'`	Get QLink session status and transport tier.
`qlink_transfer`	`(self, source: 'str', dest: 'str', size_mb: 'float' = 64.0, zero_copy: 'bool' = True) -> 'Dict[str, Any]'`	Transfer data via QLink between GPU ranks.
`simulate`	`(self, num_qubits: 'int', shots: 'int' = 4096, circuit_depth: 'int' = 50, mode: 'str' = 'auto', precision: 'str' = 'fp64', backend: 'str' = 'statevector') -> 'Dict[str, Any]'`	Simulate a circuit using GPU acceleration.
`transfer`	`(self, source: 'str', dest: 'str', data_mb: 'float' = 64.0, zero_copy: 'bool' = True) -> 'Dict[str, Any]'`	Transfer tensor data between GPU rank and QPU backend.

`isolation`

Class: IsolationAPI

Method	Signature	Description
`allocate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Allocate qubits to an isolation zone.
`crosstalk`	`(self) -> 'Dict[str, Any]'`	Get crosstalk matrix.
`delete`	`(self, zone_id: 'str') -> 'Dict[str, Any]'`	Delete an isolation zone.
`evidence`	`(self, evidence_id: 'str') -> 'Dict[str, Any]'`	Get isolation evidence.
`execute`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute circuit within an isolated zone.
`health`	`(self) -> 'Dict[str, Any]'`	Check isolation service health.
`zone`	`(self, zone_id: 'str') -> 'Dict[str, Any]'`	Get zone details.
`zones`	`(self) -> 'Any'`	List isolation zones.

`jobs`

Class: JobsAPI

Method	Signature	Description
`artifact`	`(self, job_id: 'str', artifact_id: 'str') -> 'Dict[str, Any]'`	Get a specific artifact.
`artifacts`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	List job artifacts.
`cancel`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Cancel a pending job.
`estimate`	`(self, qasm: 'str', shots: 'int' = 1024, backend_id: 'str' = 'statevector_sim', **kwargs) -> 'Dict[str, Any]'`	Estimate job cost without executing.
`execute`	`(self, qasm: 'str', shots: 'int' = 1024, backend_id: 'str' = 'statevector_sim', **kwargs) -> 'Dict[str, Any]'`	Submit and wait for result (blocking convenience).
`get`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get job status and metadata.
`list`	`(self, **params) -> 'Any'`	List all jobs for the authenticated user.
`result`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get job result (counts, metadata).
`submit`	`(self, qasm: 'str', shots: 'int' = 1024, backend_id: 'str' = 'statevector_sim', **kwargs) -> 'Dict[str, Any]'`	Submit a quantum circuit for execution.
`wait`	`(self, job_id: 'str', *, timeout: 'float' = 300.0, poll_interval: 'float' = 2.0) -> 'Dict[str, Any]'`	Poll until job completes.

`ledger`

Class: LedgerAPI

Method	Signature	Description
`audit`	`(self) -> 'Dict[str, Any]'`	Get audit report.
`budget_create`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create a budget.
`budgets`	`(self, tenant_id: 'Optional[str]' = None) -> 'Any'`	List budgets.
`chargeback`	`(self, **kwargs) -> 'Dict[str, Any]'`	Get chargeback report.
`estimate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Estimate cost.
`job`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get metered job details.
`jobs`	`(self, **params) -> 'Any'`	List metered jobs.
`pricing`	`(self) -> 'Any'`	Get pricing information.
`project_create`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create a project.
`projects`	`(self) -> 'Any'`	List projects.
`provenance`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get job provenance (lineage).
`tenant_create`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create a tenant.
`tenants`	`(self, tenant_id: 'Optional[str]' = None) -> 'Any'`	Get tenant or list tenants.
`usage`	`(self) -> 'Dict[str, Any]'`	Get usage report.

`macro`

Class: MacroAPI

Method	Signature	Description
`energy_optimize`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run energy optimization analysis.
`health`	`(self) -> 'Dict[str, Any]'`	Check Macro service health.
`market_sizing`	`(self, **params) -> 'Dict[str, Any]'`	Get quantum market-sizing analysis.
`risk_analysis`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run quantum investment risk analysis.

`marketplace`

Class: MarketplaceAPI

Method	Signature	Description
`find`	`(self, num_qubits: 'int', shots: 'int' = 4096, objective: 'str' = 'auto', technology: 'Optional[str]' = None, sovereign_mode: 'str' = 'none', max_price_usd: 'Optional[float]' = None) -> 'Dict[str, Any]'`	Find and rank the best vendors for a workload.
`get_order`	`(self, order_id: 'str') -> 'Dict[str, Any]'`	Poll the status and results of a marketplace order.
`pricing`	`(self) -> 'Dict[str, Any]'`	Get real-time price comparison across all vendors.
`submit`	`(self, circuit_qasm: 'str', num_qubits: 'int', shots: 'int' = 4096, vendor_id: 'Optional[str]' = None, sovereign_mode: 'str' = 'none', priority: 'str' = 'normal') -> 'Dict[str, Any]'`	Submit a circuit to the marketplace (auto-selects vendor if not given).
`vendors`	`(self) -> 'Dict[str, Any]'`	List all vendors with useful-shot pricing details.

`navcore`

Class: NavCoreAPI

Method	Signature	Description
`algorithms`	`(self) -> 'Any'`	List available algorithms.
`compliance_audit`	`(self) -> 'Dict[str, Any]'`	Get compliance audit.
`compliance_summary`	`(self) -> 'Dict[str, Any]'`	Get compliance summary.
`conformance_report`	`(self) -> 'Dict[str, Any]'`	Get standards conformance report.
`face_status`	`(self) -> 'Dict[str, Any]'`	Get FACE status.
`hal_register`	`(self, **kwargs) -> 'Dict[str, Any]'`	Register HAL sensor.
`hal_sensors`	`(self) -> 'Any'`	List HAL sensors.
`kalman_predict`	`(self, **kwargs) -> 'Dict[str, Any]'`	Kalman filter predict.
`kalman_reset`	`(self, **kwargs) -> 'Dict[str, Any]'`	Reset Kalman filter.
`kalman_state`	`(self) -> 'Dict[str, Any]'`	Get Kalman filter state.
`kalman_update`	`(self, **kwargs) -> 'Dict[str, Any]'`	Kalman filter update.
`navigate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run Kalman navigation.
`nis2_gaps`	`(self) -> 'Any'`	List NIS2 compliance gaps.
`nis2_incident`	`(self, **kwargs) -> 'Dict[str, Any]'`	Report NIS2 incident.
`nis2_status`	`(self) -> 'Dict[str, Any]'`	Get NIS2 compliance status.
`noise_characterize`	`(self, **kwargs) -> 'Dict[str, Any]'`	Characterize noise.
`osnma_satellites`	`(self) -> 'Any'`	List OSNMA satellites.
`osnma_status`	`(self) -> 'Dict[str, Any]'`	Get OSNMA status.
`osnma_verify`	`(self, **kwargs) -> 'Dict[str, Any]'`	Verify OSNMA signal.
`pqc_keypair`	`(self, **kwargs) -> 'Dict[str, Any]'`	Generate a PQC keypair. Returns BOTH halves; keep the private one.
`pqc_sign`	`(self, **kwargs) -> 'Dict[str, Any]'`	PQC sign data. Requires `message` and `private_key` (both base64).
`pqc_verify`	`(self, **kwargs) -> 'Dict[str, Any]'`	PQC verify signature.
`qrng_bytes`	`(self, **kwargs) -> 'Dict[str, Any]'`	Generate QRNG bytes.
`qrng_nonce`	`(self) -> 'Dict[str, Any]'`	Generate QRNG nonce.
`qrng_uuid`	`(self) -> 'Dict[str, Any]'`	Generate QRNG UUID.
`quantum_circuit_run`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run quantum circuit.
`quantum_configure`	`(self, **kwargs) -> 'Dict[str, Any]'`	Configure quantum processing.
`quantum_performance`	`(self) -> 'Dict[str, Any]'`	Get quantum performance metrics.
`quantum_process`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run quantum processing.
`quantum_sequences`	`(self) -> 'Any'`	List quantum sequences.
`quantum_status`	`(self) -> 'Dict[str, Any]'`	Get quantum processing status.
`raim_exclude`	`(self, **kwargs) -> 'Dict[str, Any]'`	Exclude satellite from RAIM.
`raim_hybrid_fusion`	`(self) -> 'Dict[str, Any]'`	Get RAIM hybrid fusion data.
`raim_process`	`(self, **kwargs) -> 'Dict[str, Any]'`	Process RAIM data.
`raim_quantum_verification`	`(self) -> 'Dict[str, Any]'`	Get RAIM quantum verification status.
`raim_statistics`	`(self) -> 'Dict[str, Any]'`	Get RAIM statistics.
`raim_status`	`(self) -> 'Dict[str, Any]'`	Get RAIM status.
`raim_threats`	`(self) -> 'Any'`	Get RAIM threats.
`sensor_simulate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Simulate sensor data.
`sosa_profiles`	`(self) -> 'Any'`	List SOSA profiles.
`sosa_validate`	`(self, **kwargs) -> 'Dict[str, Any]'`	Validate SOSA compliance.
`spoof_detect`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run spoofing detection.
`status`	`(self) -> 'Dict[str, Any]'`	Get NavCore status.
`time_network`	`(self) -> 'Dict[str, Any]'`	Get network time.
`time_sync`	`(self, **kwargs) -> 'Dict[str, Any]'`	Synchronize time.
`time_utc`	`(self) -> 'Dict[str, Any]'`	Get UTC time reference.
`victory_publish`	`(self, **kwargs) -> 'Dict[str, Any]'`	Publish VICTORY service.
`victory_services`	`(self) -> 'Any'`	List VICTORY services.

`network`

Class: NetworkAPI

Method	Signature	Description
`backends`	`(self) -> 'Any'`	List network backends.
`barrier`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create network barrier.
`entangle`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create entanglement between nodes.
`evidence`	`(self, evidence_id: 'str') -> 'Dict[str, Any]'`	Get network evidence.
`evidence_bundle`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get evidence bundle for a job.
`health`	`(self) -> 'Dict[str, Any]'`	Check network service health.
`ion_species`	`(self) -> 'Any'`	List available ion species.
`job_evidence`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get network job evidence.
`job_result`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get network job result.
`job_status`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get network job status.
`jobs`	`(self) -> 'Any'`	List network jobs.
`phase0_sweep`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run phase 0 parameter sweep.
`phase0b_analyze`	`(self, **kwargs) -> 'Dict[str, Any]'`	Analyze phase 0b results.
`phase0b_recommend`	`(self, **kwargs) -> 'Dict[str, Any]'`	Get phase 0b recommendations.
`remote_cnot`	`(self, **kwargs) -> 'Dict[str, Any]'`	Execute remote CNOT gate.
`status`	`(self) -> 'Dict[str, Any]'`	Get network status.
`teleport`	`(self, **kwargs) -> 'Dict[str, Any]'`	Teleport quantum state.
`topology`	`(self) -> 'Dict[str, Any]'`	Get network topology.

`provider_hub`

Class: ProviderHubAPI

Method	Signature	Description
`health`	`(self, provider_id: 'str') -> 'Dict[str, Any]'`	Health-check a specific provider.
`health_all`	`(self) -> 'Dict[str, Any]'`	Concurrently health-check ALL registered providers.
`list`	`(self) -> 'Dict[str, Any]'`	List all registered providers in the ProviderHub.
`register`	`(self, module_path: 'str', class_name: 'str', init_kwargs: 'Optional[Dict[str, Any]]' = None, overwrite: 'bool' = False) -> 'Dict[str, Any]'`	Dynamically register a community BackendAdapter into the ProviderHub.
`remove`	`(self, provider_id: 'str') -> 'Dict[str, Any]'`	Remove a provider from the ProviderHub.

`qec`

Class: QECAPI

Method	Signature	Description
`benchmark`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run the full QEC benchmark suite across all decoders.
`certify`	`(self, **kwargs) -> 'Dict[str, Any]'`	Certify isolation.
`code`	`(self, code_id: 'str') -> 'Dict[str, Any]'`	Get code details.
`codes`	`(self) -> 'Any'`	List available QEC codes.
`compile`	`(self, **kwargs) -> 'Dict[str, Any]'`	Compile PBC circuit. Returns OpenQASM 3 in `qasm3` field.
`conformance_certify`	`(self, **kwargs) -> 'Dict[str, Any]'`	Issue an ACOS FT conformance certificate for a QEC job.
`create_code`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create a new QEC code.
`decode`	`(self, **kwargs) -> 'Dict[str, Any]'`	Decode error syndrome.
`health`	`(self) -> 'Dict[str, Any]'`	Check QEC service health.
`isolation_certificates`	`(self) -> 'Any'`	List isolation certificates.
`isolation_evidence`	`(self, evidence_id: 'str') -> 'Dict[str, Any]'`	Get isolation evidence.
`pipeline`	`(self, **kwargs) -> 'Dict[str, Any]'`	Run full QEC pipeline.
`submit_pbc`	`(self, **kwargs) -> 'Dict[str, Any]'`	Submit a PBC-compiled OpenQASM 3 circuit to QCOS Runtime.
`syndrome`	`(self, **kwargs) -> 'Dict[str, Any]'`	Extract error syndrome.
`zone`	`(self, zone_id: 'str') -> 'Dict[str, Any]'`	Get zone details.
`zone_create`	`(self, **kwargs) -> 'Dict[str, Any]'`	Create an isolation zone.
`zone_delete`	`(self, zone_id: 'str') -> 'Dict[str, Any]'`	Delete an isolation zone.
`zones`	`(self) -> 'Any'`	List isolation zones.

`qec_service`

Class: QECServiceAPI

Method	Signature	Description
`certify`	`(self, job_id: 'str', include_evidence: 'bool' = True) -> 'Dict[str, Any]'`	Generate QEC certification with Evidence Bundle 2.0 for a job.
`codes`	`(self) -> 'Dict[str, Any]'`	List all supported QEC codes with parameters.
`health`	`(self) -> 'Dict[str, Any]'`	Check QEC service health and available resources.
`recommend`	`(self, num_qubits: 'int', target_logical_error_rate: 'float' = 1e-10, physical_error_rate: 'float' = 0.001, circuit_depth: 'Optional[int]' = None, hardware_type: 'str' = 'superconducting') -> 'Dict[str, Any]'`	Recommend the best QEC code for given hardware parameters.
`run`	`(self, circuit_qasm: 'str', qec_code: 'str' = 'surface_code', code_distance: 'int' = 3, shots: 'int' = 1024, backend: 'Optional[str]' = None, evidence_bundle: 'bool' = True) -> 'Dict[str, Any]'`	Encode and execute a circuit with QEC middleware.

`qlink`

Class: QLinkAPI

Method	Signature	Description
`profile`	`(self, n_gpu_ranks: 'int' = 4, size_mb: 'float' = 256.0, iterations: 'int' = 10, mode: 'str' = 'auto') -> 'Dict[str, Any]'`	Benchmark QLink transfer bandwidth and latency across all tiers.
`simulate`	`(self, num_qubits: 'int', n_gpu_ranks: 'int' = 4, shots: 'int' = 4096, circuit_depth: 'int' = 50, mode: 'str' = 'auto', backend: 'str' = 'statevector') -> 'Dict[str, Any]'`	Run a large circuit via QLink multi-GPU statevector sharding.
`status`	`(self, session_id: 'Optional[str]' = None) -> 'Dict[str, Any]'`	Get QLink transport tier, bandwidth, GPU rank count, and session stats.
`transfer`	`(self, source: 'str', dest: 'str', size_mb: 'float' = 64.0, zero_copy: 'bool' = True) -> 'Dict[str, Any]'`	Transfer a tensor between GPU ranks or between GPU↔QPU.

`qubo`

Class: QUBOAPI

Method	Signature	Description
`energy_dispatch`	`(self, startup_costs: 'List[float]', capacities: 'List[float]', demand: 'List[float]') -> 'Dict[str, Any]'`	Quantum unit commitment for energy dispatch optimization.
`maxcut`	`(self, adjacency_matrix: 'List[List[float]]', vertex_labels: 'Optional[List[str]]' = None) -> 'Dict[str, Any]'`	MaxCut graph partitioning via QUBO.
`portfolio`	`(self, returns: 'List[float]', covariance: 'List[List[float]]', n_select: 'int', risk_aversion: 'float' = 1.0, asset_labels: 'Optional[List[str]]' = None) -> 'Dict[str, Any]'`	Quantum-enhanced Markowitz portfolio optimization via QUBO.

`sandbox`

Class: SandboxAPI

Method	Signature	Description
`execute`	`(self, code: 'str', language: 'str', shots: 'int' = 1024, backend_id: 'str' = 'aer_simulator', comparison_mode: 'bool' = False) -> 'Dict[str, Any]'`	Execute raw quantum framework code natively in QCOS sandbox.
`execute_with_adapter`	`(self, adapter: 'Any', comparison_mode: 'bool' = False) -> 'Dict[str, Any]'`	Execute using a framework adapter (QiskitAdapter, CirqAdapter, etc.).
`stream`	`(self, job_id: 'str', mode: 'str' = 'qcos') -> 'Iterator[Dict[str, Any]]'`	Stream SSE execution stage events for a job.

`session`

Class: SessionAPI

Method	Signature	Description
`audit`	`(self, session_id: 'Optional[str]' = None, operation: 'Optional[str]' = None, limit: 'int' = 100) -> 'List[Dict[str, Any]]'`	Get audit log entries.
`audit_report`	`(self) -> 'Dict[str, Any]'`	Get usage report.
`create`	`(self, user_id: 'Optional[str]' = None, project_id: 'Optional[str]' = None, source: 'str' = 'sdk', tags: 'Optional[List[str]]' = None) -> 'Dict[str, Any]'`	Create a new session.
`end`	`(self, session_id: 'str') -> 'Dict[str, Any]'`	End a session.
`get`	`(self, session_id: 'str') -> 'Dict[str, Any]'`	Get session details.
`list`	`(self, source: 'Optional[str]' = None, limit: 'int' = 20) -> 'List[Dict[str, Any]]'`	List active sessions.

`use_cases`

Class: UseCasesAPI

Method	Signature	Description
`discover`	`(self, sector: 'str', challenge: 'str', goal: 'str', data_available: 'bool' = True, constraints: 'Optional[str]' = None) -> 'Dict[str, Any]'`	Discover quantum use cases relevant to a business problem.
`feasibility`	`(self, use_case_title: 'str', problem_description: 'str', sector: 'str', problem_size: 'Optional[str]' = None, data_available: 'bool' = True, current_classical_runtime: 'Optional[str]' = None) -> 'Dict[str, Any]'`	Generate a quantum feasibility report for a specific use case.

`visualize`

Class: VisualizeAPI

Method	Signature	Description
`bloch`	`(self, theta: 'float' = 0.0, phi: 'float' = 0.0, width: 'int' = 50) -> 'Dict[str, Any]'`	Render Bloch sphere from angles.
`bloch_from_counts`	`(self, counts: 'Dict[str, int]') -> 'Dict[str, Any]'`	Infer Bloch sphere from measurement counts.
`compare`	`(self, counts_qcos: 'Dict[str, int]', counts_vanilla: 'Dict[str, int]', shots: 'Optional[int]' = None) -> 'Dict[str, Any]'`	Compare QCOS vs vanilla results with Hellinger analytics.
`histogram`	`(self, counts: 'Dict[str, int]', shots: 'int', backend: 'Optional[str]' = None, format: 'str' = 'json') -> 'Dict[str, Any]'`	Render histogram from counts.
`histogram_for_job`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get histogram for a job.
`stats`	`(self, job_id: 'str') -> 'Dict[str, Any]'`	Get job statistics.

`workflow`

Class: WorkflowAPI

Method	Signature	Description
`list`	`(self, status: 'Optional[str]' = None, limit: 'int' = 20) -> 'List[Dict[str, Any]]'`	List workflows.
`run`	`(self, yaml_content: 'str', inputs: 'Optional[Dict[str, Any]]' = None, name: 'Optional[str]' = None) -> 'Dict[str, Any]'`	Execute a YAML workflow.
`status`	`(self, workflow_id: 'str') -> 'Dict[str, Any]'`	Get workflow status.
`template`	`(self, name: 'str') -> 'Dict[str, Any]'`	Get a specific template.
`templates`	`(self) -> 'Dict[str, Any]'`	List workflow templates.
`validate`	`(self, yaml_content: 'str') -> 'Dict[str, Any]'`	Validate a workflow YAML.

`zne`

Class: ZNEAPI

Method	Signature	Description
`mitigate`	`(self, job_id: 'str', scale_factors: 'Optional[List[float]]' = None, extrapolation: 'str' = 'richardson', observable: 'str' = 'Z0', shots: 'int' = 1024) -> 'Dict[str, Any]'`	Apply Zero-Noise Extrapolation to a completed QCOS job.

​Python SDK Reference

​Install

​Client setup

​Module index

​Modules

​acos

​admin

​algorithms

​autopilot

​backends

​batch

​bench

​billing

​calibration

​chemistry

​circuits

​coherence

​dri

​energy

​evidence

​glassbox

​gpu_qpu

​isolation

​jobs

​ledger

​macro

​marketplace

​navcore

​network

​provider_hub

​qec

​qec_service

​qlink

​qubo

​sandbox

​session

​use_cases

​visualize

​workflow

​zne