classiq 0.45.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

classiq/__init__.py

@@ -13,7 +13,6 @@ from classiq.interface.generator.functions import *  # noqa: F403
 from classiq.interface.generator.model import *  # noqa: F403
 from classiq.interface.generator.model import __all__ as _md_all
 from classiq.interface.generator.quantum_program import QuantumProgram
-from classiq.interface.generator.types.builtin_enum_declarations import *  # noqa: F403
 
 from classiq import applications, execution, synthesis
 from classiq._internals import logger

classiq/_internals/__init__.py

@@ -0,0 +1,20 @@
+import sys
+import warnings
+
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
+
+def _check_python_version() -> None:
+    if sys.version_info >= (3, 9):
+        return
+    warnings.warn(  # type: ignore[unreachable]
+        "Python version 3.8 is expected to reach its end-of-life on October 2024.\n"
+        "See https://devguide.python.org/versions/#supported-versions\n"
+        "The Classiq SDK is expected to drop support for 3.8 around the same time.\n"
+        "Please upgrade to a newer version of Python to avoid issues in the future.",
+        ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
+
+
+_check_python_version()

classiq/_internals/authentication/authentication.py

@@ -3,6 +3,17 @@ from classiq._internals.client import client
 
 
 def authenticate(overwrite: bool = False) -> None:
+    """
+
+    Authenticate to access the Classiq platform.
+
+     Args:
+        overwrite: A flag indicating whether to overwrite the existing
+        authentication tokens. Defaults to `False`.
+
+      If you are not registered, please visit the Classiq platform
+    to complete registration: https://platform.classiq.io/
+    """
     async_utils.run(authenticate_async(overwrite))
 
 

classiq/analyzer/analyzer.py

@@ -38,7 +38,7 @@ class Analyzer(AnalyzerUtilities):
         """Init self.
 
         Args:
-            circuit (): The circuit to be analyzed.
+            circuit: The circuit to be analyzed.
         """
         if circuit.qasm is None:
             raise ClassiqAnalyzerError(
@@ -86,11 +86,11 @@ class Analyzer(AnalyzerUtilities):
         Returns dict of the available devices by the providers. only devices
         with sufficient number of qubits are returns
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`).
+        Args: providers: List of providers.
         if None, the table include all the available hardware.
 
         Returns:
-            available devices (): dict of the available devices (Dict[str,List[str]]).
+            available devices: dict of the available devices.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
@@ -109,10 +109,10 @@ class Analyzer(AnalyzerUtilities):
         analyzer_sdk extra.
 
         Args:
-            provider (): provider name (optional - string or `AnalyzerProviderVendor`).
-            device (): device name (optional - string).
+            provider: provider name.
+            device: device name.
         Returns:
-         hardware_connectivity_graph (): interactive graph.
+         hardware_connectivity_graph: interactive graph.
         """
 
         self._validate_analyzer_extra()
@@ -138,11 +138,13 @@ class Analyzer(AnalyzerUtilities):
         """create a comparison table between the transpiled circuits result on different hardware.
         The  comparison table included the depth, multi qubit gates count,and total gates count of the circuits.
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`). if None, the table include all
-        the available hardware.
-        devices (): List of devices (string). if None, the table include all the available devices of the selected
+        Args:
+            providers: List of providers. if None, the table include all the available hardware.
+            devices: List of devices. if None, the table include all the available devices of the selected
         providers.
-        Returns: None.
+
+        Returns:
+            None.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -21,7 +21,7 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
     convert_pyomo_to_global_presentation,
 )
-from classiq.qmod.builtins import PauliTerm
+from classiq.qmod.builtins.structs import PauliTerm
 
 
 def compute_qaoa_initial_point(

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -4,8 +4,8 @@ from classiq.interface.exceptions import ClassiqNonNumericCoefficientInPauliErro
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
 
-from classiq.qmod.builtins import PauliTerm
 from classiq.qmod.builtins.enums import Pauli
+from classiq.qmod.builtins.structs import PauliTerm
 
 
 def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[PauliTerm]:

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -13,6 +13,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -23,7 +24,6 @@ from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBitvector
 
-from classiq import Struct
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
     compute_qaoa_initial_point,
     convert_pyomo_to_global_presentation,

classiq/applications/libraries/qmci_library.py

@@ -2,15 +2,10 @@ from typing import cast
 
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
-from classiq.qmod import (  # type:ignore[attr-defined]
-    QArray,
-    QBit,
-    QCallable,
-    QNum,
-    Z,
-    amplitude_estimation,
-    qfunc,
-)
+from classiq.qmod.builtins.functions import Z, amplitude_estimation
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.quantum_callable import QCallable
 
 
 @qfunc

classiq/execution/execution_session.py

@@ -125,6 +125,15 @@ def generate_code_snippet(operation: str, **kwargs: Any) -> str:
 
 
 class ExecutionSession:
+    """
+    A session for executing a quantum program.
+    `ExecutionSession` allows to execute the quantum program with different parameters and operations without the need to re-synthesize the model.
+
+    Attributes:
+        quantum_program (Union[SerializedQuantumProgram, QuantumProgram]): The quantum program to execute.
+        execution_preferences (Optional[ExecutionPreferences]): Execution preferences for the Quantum Program.
+    """
+
     def __init__(
         self,
         quantum_program: Program,
@@ -134,35 +143,67 @@ class ExecutionSession:
         self.update_execution_preferences(execution_preferences)
 
     @property
-    def qprog(self) -> str:
+    def qprog(self) -> SerializedQuantumProgram:
+        """
+        Returns:
+            SerializedQuantumProgram: The serialized quantum program (str). See `QuantumProgram`.
+        """
         return SerializedQuantumProgram(self.program.json(indent=2))
 
     def update_execution_preferences(
         self, execution_preferences: Optional[ExecutionPreferences]
     ) -> None:
+        """
+        Update the execution preferences for the session.
+
+        Args:
+            execution_preferences: The execution preferences to update.
+
+        Returns:
+            None
+        """
         if execution_preferences is not None:
             self.program.model.execution_preferences = execution_preferences
 
-    def execute_quantum_program(
+    def _execute_quantum_program(
         self, operation: str, **kwargs: Any
     ) -> ResultsCollection:
         self.program.model.classical_execution_code = generate_code_snippet(
             operation, **kwargs
         )
-        return execute(self.qprog).result()
+        return execute(SerializedQuantumProgram(self.qprog)).result()
 
     def sample(self, parameters: Optional[ExecutionParams] = None) -> ExecutionDetails:
+        """
+        Samples the quantum program with the given parameters, if any.
+
+        Args:
+            parameters: The values to set for the parameters of the quantum program when sampling. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+
+        Returns:
+            ExecutionDetails: The result of the sampling.
+        """
         return cast(
             ExecutionDetails,
-            self.execute_quantum_program(
+            self._execute_quantum_program(
                 SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
             )[0].value,
         )
 
     def batch_sample(self, parameters: List[ExecutionParams]) -> List[ExecutionDetails]:
+        """
+        Samples the quantum program multiple times with the given parameters for each iteration. The number of samples is determined by the length of the parameters list.
+
+        Args:
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            List[ExecutionDetails]: The results of all the sampling iterations.
+        """
         return cast(
             MultipleExecutionDetails,
-            self.execute_quantum_program(
+            self._execute_quantum_program(
                 SupportedPrimitives.BATCH_SAMPLE,
                 parameters=format_parameters(parameters),
             )[0].value,
@@ -171,9 +212,19 @@ class ExecutionSession:
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
     ) -> EstimationResult:
+        """
+        Estimates the expectation value of the given Hamiltonian using the quantum program.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: The values to set for the parameters of the quantum program when estimating.  Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            EstimationResult: The result of the estimation.
+        """
         return cast(
             EstimationResult,
-            self.execute_quantum_program(
+            self._execute_quantum_program(
                 SupportedPrimitives.ESTIMATE,
                 parameters=format_parameters(parameters),
                 hamiltonian=to_hamiltonian_str(hamiltonian),
@@ -183,9 +234,19 @@ class ExecutionSession:
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
     ) -> List[EstimationResult]:
+        """
+        Estimates the expectation value of the given Hamiltonian multiple times using the quantum program, with the given parameters for each iteration. The number of estimations is determined by the length of the parameters list.
+
+        Args:
+            hamiltonian: The Hamiltonian to estimate the expectation value of.
+            parameters: A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.
+
+        Returns:
+            List[EstimationResult]: The results of all the estimation iterations.
+        """
         return cast(
             EstimationResults,
-            self.execute_quantum_program(
+            self._execute_quantum_program(
                 SupportedPrimitives.BATCH_ESTIMATE,
                 parameters=format_parameters(parameters),
                 hamiltonian=to_hamiltonian_str(hamiltonian),

classiq/executor.py

@@ -12,8 +12,8 @@ from classiq.interface.executor.quantum_instruction_set import QuantumInstructio
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.generator.quantum_program import QuantumProgram
 
+from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
 from classiq.execution.jobs import ExecutionJob
 from classiq.synthesis import SerializedQuantumProgram
 
@@ -36,7 +36,19 @@ async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJ
     return ExecutionJob(details=result)
 
 
-execute = syncify_function(execute_async)
+def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
+    """
+    Execute a quantum program. The preferences for execution are set on the quantum program using the method `set_execution_preferences`.
+
+    Args:
+        quantum_program: The quantum program to execute. This is the result of the synthesize method.
+
+    Returns:
+        ExecutionJob: The result of the execution.
+
+    For examples please see [Execution Documentation](https://docs.classiq.io/latest/reference-manual/executor/)
+    """
+    return async_utils.run(execute_async(quantum_program))
 
 
 def set_quantum_program_execution_preferences(

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.45.0'
+SEMVER_VERSION = '0.46.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -24,6 +24,17 @@ from classiq.interface.helpers.pydantic_model_helpers import values_with_discrim
 
 
 class BackendPreferences(BaseModel):
+    """
+    Preferences for the execution of the quantum program.
+
+    For more details, refer to:
+    [BackendPreferences](https://docs.classiq.io/latest/reference-manual/python-sdk/?h=backend#classiq.Preferences.backend_preferences)
+
+    Attributes:
+        backend_service_provider (str): Provider company or cloud for the requested backend.
+        backend_name (str): Name of the requested backend or target.
+    """
+
     # Due to the way the field is currently implemented, i.e. it redefined with different types
     # in the subclass, it shouldn't be dumped with exclude_unset. This causes this field not to appear.
     # For example: don't use obj.dict(exclude_unset=True).
@@ -55,6 +66,49 @@ class BackendPreferences(BaseModel):
 
 
 class AliceBobBackendPreferences(BackendPreferences):
+    """
+    Backend preferences specific to Alice&Bob for quantum computing tasks.
+
+    This class includes configuration options for setting up a backend using Alice&Bob's quantum hardware.
+    It extends the base `BackendPreferences` class and provides additional parameters required for working
+    with Alice&Bob's cat qubits, including settings for photon dissipation rates, repetition code distance,
+    and the average number of photons.
+
+    Attributes:
+        backend_service_provider (ProviderTypeVendor.ALICE_BOB):
+            The service provider for the backend, which is Alice&Bob.
+
+        distance (Optional[int]):
+            The number of times information is duplicated in the repetition code.
+            - **Tooltip**: Phase-flip probability decreases exponentially with this parameter, bit-flip probability increases linearly.
+            - **Supported Values**: 3 to 300, though practical values are usually lower than 30.
+            - **Default**: None.
+
+        kappa_1 (Optional[float]):
+            The rate at which the cat qubit loses one photon, creating a bit-flip.
+            - **Tooltip**: Lower values mean lower error rates.
+            - **Supported Values**: 10 to 10^5. Current hardware is at ~10^3.
+            - **Default**: None.
+
+        kappa_2 (Optional[float]):
+            The rate at which the cat qubit is stabilized using two-photon dissipation.
+            - **Tooltip**: Higher values mean lower error rates.
+            - **Supported Values**: 100 to 10^9. Current hardware is at ~10^5.
+            - **Default**: None.
+
+        average_nb_photons (Optional[float]):
+            The average number of photons.
+            - **Tooltip**: Bit-flip probability decreases exponentially with this parameter, phase-flip probability increases linearly.
+            - **Supported Values**: 4 to 10^5, though practical values are usually lower than 30.
+            - **Default**: None.
+
+        api_key (str):
+            The API key required to access Alice&Bob's quantum hardware.
+            - **Required**: Yes.
+
+    For more details, refer to the [Alice&Bob Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/alice-and-bob-backends/).
+    """
+
     backend_service_provider: ProviderTypeVendor.ALICE_BOB
     distance: Optional[int] = pydantic.Field(
         default=None, description="Repetition code distance"
@@ -90,6 +144,15 @@ class AliceBobBackendPreferences(BackendPreferences):
 
 
 class ClassiqBackendPreferences(BackendPreferences):
+    """
+    Represents backend preferences specific to Classiq quantum computing targets.
+
+    This class is used to configure the backend options for executing quantum circuits on Classiq's platform.
+    The relevant backend names for Classiq targets are specified in `ClassiqSimulatorBackendNames` & `ClassiqNvidiaBackendNames`.
+
+    For more details, refer to the [Classiq Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/classiq-backends/).
+    """
+
     backend_service_provider: ProviderTypeVendor.CLASSIQ
 
     @pydantic.root_validator(pre=True)
@@ -103,6 +166,36 @@ class ClassiqBackendPreferences(BackendPreferences):
 
 
 class AwsBackendPreferences(BackendPreferences):
+    """
+    AWS-specific backend preferences for quantum computing tasks using Amazon Braket.
+
+    This class contains configuration options specific to Amazon Braket, including the AWS role
+    ARN, S3 bucket details, and the folder path within the S3 bucket. It extends the base
+    `BackendPreferences` class to provide additional properties required for interaction with
+    Amazon Braket.
+
+    Attributes:
+        backend_service_provider (ProviderTypeVendor.AMAZON_BRAKET):
+            The service provider for the backend, which is Amazon Braket.
+
+        aws_role_arn (pydantic_backend.PydanticAwsRoleArn):
+            The Amazon Resource Name (ARN) of the role that will be assumed for execution
+            on your Braket account. This is a required field and should be provided to allow
+            secure and authorized access to AWS resources.
+
+        s3_bucket_name (str):
+            The name of the S3 bucket where results and other related data will be stored.
+            This field should contain a valid S3 bucket name under your AWS account.
+
+        s3_folder (pydantic_backend.PydanticS3BucketKey):
+            The folder path within the specified S3 bucket. This allows for organizing
+            results and data under a specific directory within the S3 bucket.
+
+
+    For more details, refer to:
+    [AwsBackendPreferences examples](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/amazon-backends/?h=awsbackend#usage)
+    """
+
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET
     aws_role_arn: pydantic_backend.PydanticAwsRoleArn = pydantic.Field(
         description="ARN of the role to be assumed for execution on your Braket account."
@@ -129,12 +222,38 @@ class AwsBackendPreferences(BackendPreferences):
 
 
 class IBMBackendProvider(BaseModel):
+    """
+
+    Represents the provider specs for identifying an IBM Quantum backend.
+
+    Attributes:
+        hub (str): hub parameter of IBM Quantum provider. Defaults to `"ibm-q"`.
+        group (str): group parameter of IBM Quantum provider. Defaults to `"open"`.
+        project (str): project parameter of IBM Quantum provider. Defaults to `"main"`.
+
+    """
+
     hub: str = "ibm-q"
     group: str = "open"
     project: str = "main"
 
 
 class IBMBackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to IBM Quantum services.
+
+    Inherits from `BackendPreferences` and adds additional fields and validations
+    specific to IBM Quantum backends.
+
+    Attributes:
+        backend_service_provider (ProviderTypeVendor.IBM_QUANTUM): Indicates the backend service provider as IBM Quantum.
+        access_token (Optional[str]): The IBM Quantum access token to be used with IBM Quantum hosted backends. Defaults to `None`.
+        provider (IBMBackendProvider): Specifications for identifying a single IBM Quantum provider. Defaults to a new `IBMBackendProvider`.
+        qctrl_api_key (Optional[str]): QCTRL API key to access QCTRL optimization abilities.
+
+    See examples in the [IBM Quantum Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ibm-backends/?h=).
+    """
+
     backend_service_provider: ProviderTypeVendor.IBM_QUANTUM
     access_token: Optional[str] = pydantic.Field(
         default=None,
@@ -158,6 +277,17 @@ class IBMBackendPreferences(BackendPreferences):
 
 
 class AzureCredential(pydantic.BaseSettings):
+    """
+    Represents the credentials and configuration required to authenticate with Azure services.
+
+    Attributes:
+        tenant_id (str): Azure Tenant ID used to identify the directory in which the application is registered.
+        client_id (str): Azure Client ID, also known as the application ID, which is used to authenticate the application.
+        client_secret (str): Azure Client Secret associated with the application, used for authentication.
+        resource_id (pydantic_backend.PydanticAzureResourceIDType): Azure Resource ID, including the subscription ID,
+            resource group, and workspace, typically used for personal resources.
+    """
+
     tenant_id: str = pydantic.Field(description="Azure Tenant ID")
     client_id: str = pydantic.Field(description="Azure Client ID")
     client_secret: str = pydantic.Field(description="Azure Client Secret")
@@ -173,6 +303,19 @@ class AzureCredential(pydantic.BaseSettings):
 
 
 class AzureBackendPreferences(BackendPreferences):
+    """
+    This class inherits from BackendPreferences.
+    This is where you specify Azure Quantum preferences.
+    See usage in the [Azure Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/azure-backends/).
+
+    Attributes:
+        location (str): Azure personal resource region. Defaults to `"East US"`.
+        credentials (Optional[AzureCredential]): The service principal credential to access personal quantum workspace. Defaults to `None`.
+        ionq_error_mitigation_flag (Optional[bool]): Error mitigation configuration upon running on IonQ through Azure. Defaults to `False`.
+
+
+    """
+
     backend_service_provider: ProviderTypeVendor.AZURE_QUANTUM
 
     location: str = pydantic.Field(
@@ -191,6 +334,12 @@ class AzureBackendPreferences(BackendPreferences):
 
     @property
     def run_through_classiq(self) -> bool:
+        """
+
+        Returns: `True` if there are no Azure Credentials.
+        Therefore you will be running through Classiq's credentials.
+
+        """
         return self.credentials is None
 
     @pydantic.root_validator(pre=True)
@@ -201,10 +350,28 @@ class AzureBackendPreferences(BackendPreferences):
 
 
 class IonqBackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to IonQ services.
+
+    Inherits from `BackendPreferences` and adds additional fields and configurations
+    specific to IonQ backends
+
+    Attributes:
+        backend_service_provider (ProviderTypeVendor.IONQ): Indicates the backend service provider as IonQ.
+        api_key (PydanticIonQApiKeyType): The IonQ API key required for accessing IonQ's quantum computing services.
+        error_mitigation (bool): A configuration option to enable or disable error mitigation during execution. Defaults to `False`.
+
+    See examples in the [IonQ Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ionq-backends/?h=).
+    """
+
     backend_service_provider: ProviderTypeVendor.IONQ
     api_key: pydantic_backend.PydanticIonQApiKeyType = pydantic.Field(
         ..., description="IonQ API key"
     )
+    error_mitigation: bool = pydantic.Field(
+        default=False,
+        description="Error mitigation configuration.",
+    )
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -214,6 +381,18 @@ class IonqBackendPreferences(BackendPreferences):
 
 
 class GCPBackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to Google Cloud Platform (GCP) services.
+
+    Inherits from `BackendPreferences` and sets the backend service provider to Google.
+
+    Attributes:
+        backend_service_provider (ProviderTypeVendor.GOOGLE): Indicates the backend service provider as Google,
+        specifically for quantum computing services on Google Cloud Platform (GCP).
+
+    See examples in the [Google Cloud Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/google-backends/?h=).
+    """
+
     backend_service_provider: ProviderTypeVendor.GOOGLE
 
     @pydantic.root_validator(pre=True)
@@ -227,6 +406,16 @@ class GCPBackendPreferences(BackendPreferences):
 
 
 class OQCBackendPreferences(BackendPreferences):
+    """
+
+    This class inherits from `BackendPreferences`.
+    This is where you specify OQC preferences.
+
+    Attributes:
+        username (str): OQC username
+        password (str): OQC password
+    """
+
     backend_service_provider: ProviderTypeVendor.OQC
     username: str = pydantic.Field(description="OQC username")
     password: str = pydantic.Field(description="OQC password")