classiq 0.56.1__py3-none-any.whl → 0.58.0__py3-none-any.whl

classiq/analyzer/show_interactive_hack.py

@@ -10,7 +10,7 @@ from classiq._internals.async_utils import syncify_function
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
 
 
-async def handle_remote_app(circuit: QuantumProgram, dispaly_url: bool = False) -> None:
+async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
     if circuit.outputs.get(QuantumFormat.QASM) is None:
         raise ClassiqAnalyzerVisualizationError(
             "Missing QASM transpilation: visualization is only supported "
@@ -23,14 +23,26 @@ async def handle_remote_app(circuit: QuantumProgram, dispaly_url: bool = False)
         circuit_page_uri(circuit_id=circuit_dataid.id, circuit_version=circuit.version),
     )
 
-    if dispaly_url:
+    if display_url:
         print(f"Opening: {app_url}")  # noqa: T201
 
     webbrowser.open_new_tab(app_url)
 
 
-async def _show_interactive(self: QuantumProgram, dispaly_url: bool = False) -> None:
-    await handle_remote_app(self, dispaly_url)
+async def _show_interactive(self: QuantumProgram, display_url: bool = True) -> None:
+    """
+    Displays the interactive representation of the quantum program in the Classiq IDE.
+
+    Args:
+        self:
+            The serialized quantum program to be displayed.
+        display_url:
+            Whether to print the url
+
+    Links:
+        [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
+    """
+    await handle_remote_app(self, display_url)
 
 
 QuantumProgram.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]

classiq/applications/combinatorial_helpers/encoding_utils.py

@@ -39,6 +39,7 @@ def is_var_span_power_of_2(var: _GeneralVarData) -> bool:
 
 ENCODED_SUFFIX = "_encoded"
 ONE_HOT_SUFFIX = "_one_hot"
+CONSTRAINT_SUFFIX = "_constraint"
 
 
 def is_obj_encoded(var: _ComponentBase) -> bool:

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -85,7 +85,9 @@ class ModelEncoder:
                 encoding_expr = self._get_encoding_expr(var_data, encoding_vars)
 
                 self._add_expr_constraint(
-                    constraint_name=var_data.name + encoding_utils.ENCODED_SUFFIX,
+                    constraint_name=var_data.name
+                    + encoding_utils.ENCODED_SUFFIX
+                    + encoding_utils.CONSTRAINT_SUFFIX,
                     expr=EqualityExpression(args=[var_data, encoding_expr]),
                 )
 

classiq/execution/jobs.py

@@ -8,7 +8,7 @@ from classiq.interface.exceptions import (
     ClassiqError,
 )
 from classiq.interface.execution.jobs import ExecutionJobDetailsV1
-from classiq.interface.executor.execution_request import ExecutionJobDetails
+from classiq.interface.executor.execution_request import ExecutionJobDetails, JobCost
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
     EstimationResult,
@@ -92,6 +92,13 @@ class ExecutionJob:
         else:
             return f"{class_name}(name={self.name!r}, id={self.id!r})"
 
+    def cost(self, *, verbose: bool = False) -> Union[str, JobCost]:
+        if self._details.cost is None:
+            self._details.cost = JobCost()
+        if verbose:
+            return self._details.cost
+        return f"{self._details.cost.total_cost} {self._details.cost.currency_code}"
+
     @classmethod
     async def from_id_async(cls, id: str) -> "ExecutionJob":
         details = await ApiWrapper.call_get_execution_job_details(JobID(job_id=id))

classiq/executor.py

@@ -46,7 +46,7 @@ def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     Returns:
         ExecutionJob: The result of the execution.
 
-    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/executor/)
+    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/execution/)
     """
     return async_utils.run(execute_async(quantum_program))
 

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.56.1'
+SEMVER_VERSION = '0.58.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from collections.abc import Iterable
 from typing import Any, Optional, Union
 
@@ -21,7 +22,7 @@ from classiq.interface.backend.quantum_backend_providers import (
     ProviderTypeVendor,
     ProviderVendor,
 )
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.hardware import Provider
 
 
@@ -117,8 +118,8 @@ class AliceBobBackendPreferences(BackendPreferences):
     average_nb_photons: Optional[float] = pydantic.Field(
         default=None, description="Average number of photons"
     )
-    api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
-        ..., description="AliceBob API key"
+    api_key: Optional[pydantic_backend.PydanticAliceBobApiKeyType] = pydantic.Field(
+        default=None, description="AliceBob API key"
     )
 
     @property
@@ -131,6 +132,17 @@ class AliceBobBackendPreferences(BackendPreferences):
         }
         return {k: v for k, v in parameters.items() if v is not None}
 
+    @pydantic.field_validator("api_key", mode="after")
+    @classmethod
+    def _validate_api_key(cls, api_key: Optional[str]) -> Optional[str]:
+        if api_key is not None:
+            warnings.warn(
+                "API key is no longer required for Alice&Bob backends.",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        return api_key
+
 
 class ClassiqBackendPreferences(BackendPreferences):
     """
@@ -230,6 +242,7 @@ class IBMBackendPreferences(BackendPreferences):
         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.
+        run_through_classiq (bool): Run through Classiq's credentials. Defaults to `False`.
 
     See examples in the [IBM Quantum Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ibm-backends/?h=).
     """
@@ -250,6 +263,10 @@ class IBMBackendPreferences(BackendPreferences):
         default=None,
         description="QCTRL API key to access QCTRL optimization abilities",
     )
+    run_through_classiq: bool = pydantic.Field(
+        default=False,
+        description="Run through Classiq's credentials",
+    )
 
 
 class AzureCredential(BaseSettings):
@@ -341,6 +358,7 @@ class IonqBackendPreferences(BackendPreferences):
         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`.
+        run_through_classiq (bool): Running through Classiq's credentials while using user's allocated budget.
 
     See examples in the [IonQ Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ionq-backends/?h=).
     """
@@ -348,13 +366,17 @@ class IonqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.IONQ = pydantic.Field(
         default=ProviderVendor.IONQ
     )
-    api_key: pydantic_backend.PydanticIonQApiKeyType = pydantic.Field(
-        ..., description="IonQ API key"
+    api_key: Optional[pydantic_backend.PydanticIonQApiKeyType] = pydantic.Field(
+        default=None, description="IonQ API key"
     )
     error_mitigation: bool = pydantic.Field(
         default=False,
         description="Error mitigation configuration.",
     )
+    run_through_classiq: bool = pydantic.Field(
+        default=False,
+        description="Running through Classiq's credentials while using user's allocated budget.",
+    )
 
 
 class GCPBackendPreferences(BackendPreferences):

classiq/interface/backend/pydantic_backend.py

@@ -7,7 +7,6 @@ AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGrou
 _IONQ_API_KEY_LENGTH: int = 32
 _ALICE_BOB_API_KEY_LENGTH: int = 72
 INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
-INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 INVALID_EMAIL_OQC: str = "aa@aa.aa"
 INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
 

classiq/interface/execution/jobs.py

@@ -1,8 +1,9 @@
 from datetime import datetime
 from typing import Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
+from classiq.interface.executor.execution_request import JobCost
 from classiq.interface.jobs import JobStatus
 
 
@@ -23,6 +24,8 @@ class ExecutionJobDetailsV1(BaseModel, extra="ignore"):
 
     error: Optional[str] = None
 
+    cost: Optional[JobCost] = Field(default=None)
+
 
 class ExecutionJobsQueryResultsV1(BaseModel, extra="ignore"):
     results: list[ExecutionJobDetailsV1]

classiq/interface/executor/execution_request.py

@@ -43,23 +43,37 @@ class QuantumProgramExecutionRequest(ExecutionRequest):
     execution_payload: QuantumCodeExecution
 
 
+class ProviderJobs(BaseModel):
+    provider_job_id: str = Field(default="DUMMY")
+    cost: float = Field(default=0)
+
+
+class JobCost(BaseModel):
+    total_cost: float = Field(default=0)
+    currency_code: str = Field(default="USD")
+    organization: Optional[str] = Field(default=None)
+    jobs: list[ProviderJobs] = Field(default=[])
+
+
 class ExecutionJobDetails(VersionedModel):
     id: str
 
-    name: Optional[str]
+    name: Optional[str] = Field(default=None)
     start_time: datetime
-    end_time: Optional[datetime]
+    end_time: Optional[datetime] = Field(default=None)
 
-    provider: Optional[str]
-    backend_name: Optional[str]
+    provider: Optional[str] = Field(default=None)
+    backend_name: Optional[str] = Field(default=None)
 
     status: JobStatus
 
-    num_shots: Optional[int]
+    num_shots: Optional[int] = Field(default=None)
     program_id: Optional[str] = Field(default=None)
 
     error: Optional[str] = Field(default=None)
 
+    cost: Optional[JobCost] = Field(default=None)
+
 
 class ExecutionJobsQueryResults(VersionedModel):
     results: list[ExecutionJobDetails]

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -16,9 +16,6 @@ DEFAULT_SUPPORTED_FUNC_NAMES: set[str] = {"CLShift", "CRShift", "min", "max"}
 DEFAULT_EXPRESSION_TYPE = "arithmetic"
 IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
 
-_REPEATED_VARIABLES_ERROR_MESSAGE: str = (
-    "Repeated variables in the beginning of an arithmetic expression are not allowed."
-)
 ValidKeyValuePairs: TypeAlias = dict[str, set[str]]
 
 SupportedNodesTypes = Union[
@@ -107,13 +104,25 @@ class ExpressionValidator(ast.NodeVisitor):
             raise ClassiqArithmeticError("Must call `validate` before getting ast_obj")
         return self._ast_obj
 
-    @staticmethod
-    def _check_repeated_variables(variables: tuple[Any, Any]) -> None:
+    def _check_repeated_variables(
+        self, variables: tuple[Any, Any], expr: ast.AST, error_suffix: str
+    ) -> None:
+        if (
+            isinstance(expr, ast.BinOp)
+            and isinstance(expr.op, ast.Pow)
+            and ast.Pow not in self.supported_nodes
+        ):
+            raise ClassiqValueError(
+                "Raising to a power (<var> ** <exp>) and multiplying a variable by "
+                "itself (<var> * <var>) are not supported"
+            )
         if (
             all(isinstance(var, ast.Name) for var in variables)
             and variables[0].id == variables[1].id
         ):
-            raise ClassiqValueError(_REPEATED_VARIABLES_ERROR_MESSAGE)
+            raise ClassiqValueError(
+                f"Expression {ast.unparse(expr)!r} is not supported ({error_suffix})"
+            )
 
     @staticmethod
     def _check_multiple_comparators(node: ast.Compare) -> None:
@@ -135,7 +144,11 @@ class ExpressionValidator(ast.NodeVisitor):
         )
 
     def validate_Compare(self, node: ast.Compare) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.comparators[0]))
+        self._check_repeated_variables(
+            (node.left, node.comparators[0]),
+            node,
+            "both sides of the comparison are identical",
+        )
         self._check_multiple_comparators(node)
 
     def visit_Compare(self, node: ast.Compare) -> None:
@@ -143,7 +156,9 @@ class ExpressionValidator(ast.NodeVisitor):
         self.generic_visit(node)
 
     def validate_BinOp(self, node: ast.BinOp) -> None:  # noqa: N802
-        self._check_repeated_variables((node.left, node.right))
+        self._check_repeated_variables(
+            (node.left, node.right), node, "both sides of the operation are identical"
+        )
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         self.validate_BinOp(node)
@@ -151,7 +166,11 @@ class ExpressionValidator(ast.NodeVisitor):
 
     def validate_Call(self, node: ast.Call) -> None:  # noqa: N802
         if len(node.args) >= 2:
-            self._check_repeated_variables((node.args[0], node.args[1]))
+            self._check_repeated_variables(
+                (node.args[0], node.args[1]),
+                node,
+                "the first two call arguments are identical",
+            )
         node_id = AstNodeRewrite().extract_node_id(node)
         if node_id not in self._supported_functions:
             raise ClassiqValueError(f"{node_id} not in supported functions")

classiq/interface/generator/functions/type_name.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
@@ -57,18 +58,15 @@ class TypeName(ClassicalType, QuantumType):
 
     @property
     def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
-        from classiq.qmod.model_state_container import QMODULE
-
         if self._assigned_fields is None:
-            qstruct_fields = QMODULE.qstruct_decls[self.name].fields
-            self._assigned_fields = {
-                field_name: field_type.model_copy()
-                for field_name, field_type in qstruct_fields.items()
-            }
-
+            raise ClassiqInternalError("Fields not set")
         return self._assigned_fields
 
-    def _set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
+    @property
+    def has_fields(self) -> bool:
+        return self._assigned_fields is not None
+
+    def set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
         self._assigned_fields = fields
 
 

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -1,5 +1,6 @@
 # This file was generated automatically - do not edit manually
 
+
 from enum import IntEnum
 
 

classiq/model_expansions/closure.py

@@ -21,6 +21,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -213,26 +214,43 @@ def _generate_arg_id(
     arg_name = arg_declaration.name
     if isinstance(arg_declaration, ClassicalParameterDeclaration):
         return {arg_name: evaluated_classical_param_to_str(arg_value)}
-    return {arg_name: _evaluated_arg_to_str(arg_value)}
+    if isinstance(arg_declaration, PortDeclaration):
+        return {arg_name: _evaluated_port_to_str(arg_value)}
+    if isinstance(arg_declaration, QuantumOperandDeclaration):
+        return {arg_name: _evaluated_operand_to_str(arg_value)}
 
 
-@singledispatch
 def _evaluated_arg_to_str(arg: Any) -> str:
     if isinstance(arg, str):
         return arg
     return str(uuid.uuid4())
 
 
-@_evaluated_arg_to_str.register
+@singledispatch
+def _evaluated_port_to_str(arg: Any) -> str:
+    return _evaluated_arg_to_str(arg)
+
+
+@_evaluated_port_to_str.register
 def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
     return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
 
 
-@_evaluated_arg_to_str.register
+@_evaluated_port_to_str.register
 def _evaluated_symbol_to_str(port: Symbol) -> str:
     return repr(port)
 
 
-@_evaluated_arg_to_str.register
-def _evaluated_operand_to_str(operand: FunctionClosure) -> str:
+@singledispatch
+def _evaluated_operand_to_str(arg: Any) -> str:
+    return _evaluated_arg_to_str(arg)
+
+
+@_evaluated_operand_to_str.register
+def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
     return operand.closure_id
+
+
+@_evaluated_operand_to_str.register
+def _evaluated_list_operands_to_str(operands: list) -> str:
+    return json.dumps([_evaluated_operand_to_str(ope) for ope in operands])

classiq/model_expansions/evaluators/parameter_types.py

@@ -35,7 +35,6 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     set_is_signed,
     set_length,
     set_size,
-    set_struct_fields,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 
@@ -198,7 +197,7 @@ def _evaluate_qstruct_in_quantum_symbol(
         field_name: evaluate_type_in_quantum_symbol(field_type, scope, param_name)
         for field_name, field_type in type_to_update.fields.items()
     }
-    set_struct_fields(type_to_update, new_fields)
+    type_to_update.set_fields(new_fields)
     return type_to_update
 
 

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,4 +1,3 @@
-from collections.abc import Mapping
 from typing import Optional
 
 from classiq.interface.exceptions import (
@@ -157,12 +156,6 @@ def set_element_type(
     quantum_array.element_type = element_type
 
 
-def set_struct_fields(
-    quantum_struct: TypeName, fields: Mapping[str, ConcreteQuantumType]
-) -> None:
-    quantum_struct._set_fields(fields)
-
-
 def set_length(quantum_array: QuantumBitvector, length: int) -> None:
     quantum_array.length = Expression(expr=str(length))
 

classiq/model_expansions/function_builder.py

@@ -26,6 +26,7 @@ from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.capturing.captured_var_manager import update_captured_vars
 from classiq.model_expansions.capturing.mangling_utils import demangle_name
@@ -82,6 +83,7 @@ class OperationBuilder:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
         self._functions_scope = functions_scope
+        self._current_source_ref: Optional[SourceReference] = None
 
     @property
     def current_operation(self) -> Closure:
@@ -99,6 +101,8 @@ class OperationBuilder:
         return self._operations[-1].blocks[self._blocks[-1]].statements
 
     def emit_statement(self, statement: QuantumStatement) -> None:
+        if self._current_source_ref is not None:
+            statement.source_ref = self._current_source_ref
         self._current_statements.append(statement)
 
     @property
@@ -131,6 +135,15 @@ class OperationBuilder:
         self._update_captured_vars()
         self._operations.pop()
 
+    @contextmanager
+    def source_ref_context(
+        self, source_ref: Optional[SourceReference]
+    ) -> Iterator[None]:
+        previous_source_ref = self._current_source_ref
+        self._current_source_ref = source_ref
+        yield
+        self._current_source_ref = previous_source_ref
+
     def _update_captured_vars(self) -> None:
         for block in self._operations[-1].blocks.values():
             block.captured_vars = update_captured_vars(block.captured_vars)

classiq/model_expansions/interpreter.py

@@ -6,8 +6,10 @@ from typing import Any, Optional, cast
 
 import numpy as np
 from numpy.random import permutation
+from pydantic import ValidationError
 
 from classiq.interface.exceptions import (
+    ClassiqError,
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
@@ -92,12 +94,6 @@ from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
-STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: tuple[type[QuantumStatement], ...] = (
-    QuantumFunctionCall,
-    VariableDeclarationStatement,
-    QuantumAssignmentOperation,
-)
-
 
 class Interpreter:
     def __init__(
@@ -168,6 +164,8 @@ class Interpreter:
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
                 raise e
+            if not isinstance(e, (ClassiqError, ValidationError)):
+                raise ClassiqInternalExpansionError(str(e)) from None
             prefix = ""
             if not isinstance(e, ClassiqExpansionError):
                 prefix = f"{type(e).__name__}: "
@@ -333,17 +331,14 @@ class Interpreter:
                 self.emit_statement(statement)
 
     def emit_statement(self, statement: QuantumStatement) -> None:
-        with (
+        source_ref = statement.source_ref
+        error_context = (
             self._error_manager.node_context(statement)
-            if statement.source_ref is not None
+            if source_ref is not None
             else nullcontext()
-        ):
+        )
+        with error_context, self._builder.source_ref_context(source_ref):
             self.emit(statement)
-        if isinstance(
-            statement,
-            STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION,
-        ):
-            self._builder.current_statement.source_ref = statement.source_ref
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context: