classiq 0.73.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

classiq/_internals/client.py

@@ -75,25 +75,23 @@ def _get_user_agent_header() -> Headers:
     python_version = (
         f"python({_get_python_execution_environment()})/{platform.python_version()}"
     )
-
-    sdk_env_value = os.getenv("SDK_ENV", "Default")
     os_platform = f"{os.name}/{platform.platform()}"
     frontend_version = f"{_FRONTEND_VARIANT}/{_VERSION}"
     interface_version = f"{_INTERFACE_VARIANT}/{_VERSION}"
-    sdk_env = f"{_SDK_ENV}/{sdk_env_value}"
+
     return {
         "User-Agent": _USERAGENT_SEPARATOR.join(
-            (
-                python_version,
-                os_platform,
-                frontend_version,
-                interface_version,
-                sdk_env,
-            )
+            (python_version, os_platform, frontend_version, interface_version)
         )
     }
 
 
+@functools.lru_cache
+def _get_sdk_env_header() -> Headers:
+    sdk_env_value = os.getenv("SDK_ENV", "Default")
+    return {_SDK_ENV: sdk_env_value}
+
+
 Ret = TypeVar("Ret")
 P = ParamSpec("P")
 
@@ -327,6 +325,7 @@ class Client:
         if self._session_id is not None:
             headers[self._SESSION_HEADER] = self._session_id
         headers.update(_get_user_agent_header())
+        headers.update(_get_sdk_env_header())
         return headers
 
     async def update_expired_access_token(self) -> None:

classiq/analyzer/show_interactive_hack.py

@@ -24,7 +24,7 @@ async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -
     )
 
     if display_url:
-        print(f"Opening: {app_url}")  # noqa: T201
+        print(f"Quantum program link: {app_url}")  # noqa: T201
 
     webbrowser.open_new_tab(app_url)
 

classiq/applications/qnn/qlayer.py

@@ -1,5 +1,6 @@
 import functools
 import inspect
+import os
 import typing
 from typing import Any, Callable, Optional, Union, overload
 
@@ -247,6 +248,14 @@ class QLayer(nn.Module):
     def _make_execute(
         self, quantum_program: SerializedQuantumProgram
     ) -> ExecuteFunction:
+        if os.environ.get("SDK_ENV") == "Studio":
+            try:
+                import classiq_studio_simulation
+
+                return classiq_studio_simulation.make_execute_qnn(quantum_program)
+            except ImportError:
+                pass
+
         session = ExecutionSession(quantum_program)
         self._session = session
 

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

classiq/interface/ast_node.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar
+from typing import Any, Optional, TypeVar
 from uuid import UUID
 
 import pydantic
@@ -23,7 +23,10 @@ class ASTNode(HashablePydanticBaseModel):
 def reset_lists(
     ast_node: ASTNodeType, statement_block_fields: list[str]
 ) -> ASTNodeType:
-    return ast_node.model_copy(update={field: [] for field in statement_block_fields})
+    update: dict[str, Any] = {field: [] for field in statement_block_fields}
+    if hasattr(ast_node, "uuid"):
+        update["uuid"] = ast_node.uuid
+    return ast_node.model_copy(update=update)
 
 
 class HashableASTNode(ASTNode, HashablePydanticBaseModel):

classiq/interface/compression_utils.py

@@ -0,0 +1,31 @@
+import base64
+from collections.abc import Sequence
+from typing import Union
+
+import zstandard as zstd
+from pydantic import BaseModel
+from pydantic_core import from_json, to_json
+
+
+def compress_pydantic(obj: Union[BaseModel, Sequence[BaseModel]]) -> bytes:
+    json_data = to_json(obj)
+    compressed_data = _compress(json_data, level=22)  # max compression level
+    return compressed_data
+
+
+def decompress(compressed_data: bytes) -> Union[dict, list[dict]]:
+    decompressed_data = _decompress(compressed_data)
+    return from_json(decompressed_data)
+
+
+def _compress(data: bytes, level: int) -> bytes:
+    compressor = zstd.ZstdCompressor(level=level)
+    compressed_data = compressor.compress(data)
+    b64_compressed_data = base64.b64encode(compressed_data)
+    return b64_compressed_data
+
+
+def _decompress(data: bytes) -> bytes:
+    compressed_data = base64.b64decode(data)
+    decompressor = zstd.ZstdDecompressor()
+    return decompressor.decompress(compressed_data)

classiq/interface/debug_info/debug_info.py

@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field
 from classiq.interface.debug_info import back_ref_util
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
-    OperationLevel,
     StatementType,
 )
 from classiq.interface.model.block import Block
@@ -18,21 +17,15 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     statement_type: Union[StatementType, None] = None
-    is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
     release_by_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        return (
-            back_ref_util.is_allocate_or_free(self.node)
-            if self.node is not None
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return back_ref_util.is_allocate_or_free(self.node) if self.node else False
 
     def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
         new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
@@ -103,7 +96,5 @@ def new_function_debug_info_by_node(
 ) -> FunctionDebugInfo:
     return FunctionDebugInfo(
         name="",
-        parameters=dict(),
-        level=OperationLevel.QMOD_STATEMENT,
         node=node._as_back_ref(),
     )

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Union
 
 from sympy import Integer
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
@@ -51,9 +51,9 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
         start = int(slice_.start)
         stop = int(slice_.stop)
         if start >= stop:
-            raise ClassiqValueError("Array slice has non-positive length")
+            raise ClassiqIndexError("Array slice has non-positive length")
         if start < 0 or stop > self._length:
-            raise ClassiqValueError("Array slice is out of bounds")
+            raise ClassiqIndexError("Array slice is out of bounds")
         return ClassicalArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
@@ -67,11 +67,11 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
         index = int(index_)
         if index < 0:
-            raise ClassiqValueError(
+            raise ClassiqIndexError(
                 "Array index is out of bounds (negative indices are not supported)"
             )
         if index >= self._length:
-            raise ClassiqValueError("Array index is out of bounds")
+            raise ClassiqIndexError("Array index is out of bounds")
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
                 base_handle=self._handle, index=Expression(expr=str(index_))

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalType,
 )
-from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_name import Struct
 
 
 def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
@@ -26,7 +26,7 @@ def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
             element_type=proxy._element_type, size=proxy.length
         )
     elif isinstance(proxy, ClassicalStructProxy):
-        classical_type = TypeName(name=proxy._decl.name)
+        classical_type = Struct(name=proxy._decl.name)
     else:
         raise ClassiqInternalExpansionError(
             f"Unrecognized classical proxy {type(proxy).__name__}"

classiq/interface/generator/functions/classical_type.py

@@ -5,6 +5,7 @@ from pydantic import ConfigDict, PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -39,9 +40,22 @@ class ClassicalType(HashableASTNode):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    @property
+    def is_purely_declarative(self) -> bool:
+        return not self._is_generative
+
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalScalarProxy(handle, self)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def clear_flags(self) -> Self:
+        res = self.model_copy()
+        res._is_generative = False
+        return res
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -82,6 +96,14 @@ class ClassicalList(ClassicalType):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         raise NotImplementedError
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -108,6 +130,14 @@ class ClassicalArray(ClassicalType):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalArrayProxy(handle, self.element_type, self.size)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -115,12 +115,34 @@ class TypeName(ClassicalType, QuantumType):
 
     @property
     def expressions(self) -> list[Expression]:
-        return list(
-            chain.from_iterable(
-                field_type.expressions for field_type in self.fields.values()
+        if self.has_fields:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions for field_type in self.fields.values()
+                )
             )
+        if self.has_classical_struct_decl:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions
+                    for field_type in self.classical_struct_decl.variables.values()
+                )
+            )
+        return []
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        if self.is_enum:
+            return False
+        return super().is_purely_declarative and all(
+            field_type.is_purely_declarative
+            for field_type in self.classical_struct_decl.variables.values()
         )
 
+    @property
+    def is_enum(self) -> bool:
+        return not self.has_fields and not self.has_classical_struct_decl
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -40,6 +40,7 @@ IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 QASM_SEPARATOR = "_"
 SPLIT_MARKER: str = "part"
+ARITH_ENGINE_PREFIX = "arith_eng__"
 PART_SUFFIX_REGEX = re.compile(
     rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
 )
@@ -177,10 +178,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
     is_basis_gate: Optional[bool] = Field(default=None)
     is_inverse: bool = Field(default=False)
-    is_allocate_or_free: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
     uuid: Optional[UUID] = Field(default=None, exclude=True)
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
     release_by_inverse: bool = Field(default=False)
     back_refs: StatementBlock = Field(default_factory=list)
@@ -190,16 +189,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        """
-        temporary measure to handle the fact that in the current release we do not have
-        the backref, and therefore fallback to the old field of is_allocate_or_free
-        """
-        return (
-            is_allocate_or_free_by_backref(self.back_refs)
-            if bool(self.back_refs)
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return is_allocate_or_free_by_backref(self.back_refs)
 
     @property
     def name(self) -> str:
@@ -215,10 +206,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if isinstance(back_ref, QuantumFunctionCall):
             name = generate_original_function_name(back_ref.func_name)
             if part_match := PART_SUFFIX_REGEX.match(generated_name):
-                suffix = f" [{part_match.group(1)}]"
-            else:
-                suffix = ""
-            return f"{name}{suffix}"
+                name += f" [{part_match.group(1)}]"
+            return name.removeprefix(ARITH_ENGINE_PREFIX)
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -230,19 +219,16 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return self.back_refs[0] if self.back_refs else None
 
     @property
-    def level_(self) -> OperationLevel:
+    def level(self) -> OperationLevel:
         # Temp fix for currently "supported" statements
         if self.name in {StatementType.CONTROL, StatementType.POWER}:
             return OperationLevel.QMOD_STATEMENT
 
-        back_ref = self.first_back_ref
-        if back_ref is None:
-            # This is the expected behavior for the case where there's not back ref.
-            # We will use it once we can rely on the existence of the back ref in
-            # all expected cases (non-engine calls)
-            # return OperationLevel.ENGINE_FUNCTION_CALL
-            return self.level
-        if isinstance(back_ref, QuantumFunctionCall):
+        if self.first_back_ref is None:
+            # we use ENGINE_FUNCTION_CALL in case where there's not back ref
+            return OperationLevel.ENGINE_FUNCTION_CALL
+
+        if isinstance(self.first_back_ref, QuantumFunctionCall):
             return OperationLevel.QMOD_FUNCTION_CALL
         return OperationLevel.QMOD_STATEMENT
 

classiq/interface/generator/quantum_program.py

@@ -8,6 +8,7 @@ from pydantic import model_validator
 from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
+from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
@@ -72,6 +73,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
         default=None
     )
+    compressed_debug_info: Optional[bytes] = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
@@ -198,3 +200,15 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             if self.transpiled_circuit and self._can_use_transpiled_code
             else self
         )
+
+    def get_debug_info(self) -> Optional[list[FunctionDebugInfoInterface]]:
+        # Support legacy uncompressed debug info
+        if self.debug_info is not None:
+            return self.debug_info
+        if self.compressed_debug_info is None:
+            return None
+        decompressed_debug_info_dict_list = decompress(self.compressed_debug_info)
+        return [
+            FunctionDebugInfoInterface.model_validate(debug_info_dict)
+            for debug_info_dict in decompressed_debug_info_dict_list
+        ]

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,10 +1,10 @@
+from itertools import chain
 from typing import Optional
 
 import pydantic
 import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
-from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.parameters import ParameterType
 
 
@@ -12,15 +12,10 @@ class FunctionExecutionData(pydantic.BaseModel):
     power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
 
     @property
-    def power_var(self) -> Optional[str]:
+    def power_vars(self) -> Optional[list[str]]:
         if self.power_parameter is None:
             return None
-        power_vars = sympy.sympify(self.power_parameter).free_symbols
-        if len(power_vars) != 1:
-            raise ClassiqValueError(
-                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
-            )
-        return str(list(power_vars)[0])
+        return list(map(str, sympy.sympify(self.power_parameter).free_symbols))
 
 
 class ExecutionData(pydantic.BaseModel):
@@ -32,8 +27,10 @@ class ExecutionData(pydantic.BaseModel):
     def execution_parameters(
         self,
     ) -> set[PydanticExecutionParameter]:
-        return {
-            function_execution_data.power_var
-            for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_var is not None
-        }
+        return set(
+            chain.from_iterable(
+                function_execution_data.power_vars
+                for function_execution_data in self.function_execution.values()
+                if function_execution_data.power_vars is not None
+            )
+        )

classiq/interface/helpers/versioned_model.py

@@ -1,7 +1,19 @@
+from typing import Any
+
 import pydantic
 
 from classiq.interface._version import VERSION
+from classiq.interface.interface_version import INTERFACE_VERSION
 
 
 class VersionedModel(pydantic.BaseModel):
     version: str = pydantic.Field(default=VERSION)
+    interface_version: str = pydantic.Field(default="0")
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def set_interface_version(cls, values: dict[str, Any]) -> dict[str, Any]:
+        # We "override" the default value mechanism so that the schema does not depend on the version
+        if "interface_version" not in values:
+            values["interface_version"] = INTERFACE_VERSION
+        return values

classiq/interface/ide/visual_model.py

@@ -1,4 +1,5 @@
 from collections import Counter
+from functools import cached_property
 from typing import Any, Optional
 
 import pydantic
@@ -58,11 +59,11 @@ class OperationLinks(pydantic.BaseModel):
     inputs: list[OperationLink]
     outputs: list[OperationLink]
 
-    @property
+    @cached_property
     def input_width(self) -> int:
         return sum(len(link.qubits) for link in self.inputs)
 
-    @property
+    @cached_property
     def output_width(self) -> int:
         return sum(len(link.qubits) for link in self.outputs)
 
@@ -122,6 +123,7 @@ class Operation(pydantic.BaseModel):
         default=AtomicGate.UNKNOWN, description="Gate type"
     )
     is_daggered: bool = pydantic.Field(default=False)
+    expanded: bool = pydantic.Field(default=False)
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "9"
+INTERFACE_VERSION = "10"

classiq/interface/model/handle_binding.py

@@ -67,6 +67,9 @@ class HandleBinding(ASTNode):
     def is_constant(self) -> bool:
         return True
 
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -111,6 +114,9 @@ class NestedHandleBinding(HandleBinding):
     def is_constant(self) -> bool:
         return self.base_handle.is_constant()
 
+    def expressions(self) -> list[Expression]:
+        return self.base_handle.expressions()
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
@@ -191,6 +197,9 @@ class SubscriptHandleBinding(NestedHandleBinding):
             and self.index.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.index]
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -305,6 +314,9 @@ class SlicedHandleBinding(NestedHandleBinding):
             and self.end.is_constant()
         )
 
+    def expressions(self) -> list[Expression]:
+        return super().expressions() + [self.start, self.end]
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/model/quantum_lambda_function.py

@@ -52,6 +52,20 @@ class QuantumLambdaFunction(ASTNode):
     def set_op_decl(self, fd: AnonQuantumOperandDeclaration) -> None:
         self._func_decl = fd
 
+    @property
+    def named_func_decl(self) -> AnonQuantumOperandDeclaration:
+        named_params = [
+            param.rename(rename)
+            for param, rename in zip(
+                self.func_decl.positional_arg_declarations,
+                self.pos_rename_params,
+                strict=False,  # strict=False enables lambda keyword args
+            )
+        ]
+        return self.func_decl.model_copy(
+            update={"positional_arg_declarations": named_params}
+        )
+
 
 class OperandIdentifier(ASTNode):
     name: str

classiq/interface/model/statement_block.py

@@ -24,7 +24,12 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.model.within_apply_operation import (
+    Action,
+    Compute,
+    Uncompute,
+    WithinApply,
+)
 
 ConcreteQuantumStatement = Annotated[
     Union[
@@ -43,6 +48,9 @@ ConcreteQuantumStatement = Annotated[
         WithinApply,
         PhaseOperation,
         Block,
+        Compute,
+        Action,
+        Uncompute,
     ],
     Field(..., discriminator="kind"),
 ]

classiq/interface/model/within_apply_operation.py

@@ -15,3 +15,15 @@ class WithinApply(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["compute", "action"])
+
+
+class Compute(QuantumOperation):
+    kind: Literal["Compute"]
+
+
+class Action(QuantumOperation):
+    kind: Literal["Action"]
+
+
+class Uncompute(QuantumOperation):
+    kind: Literal["Uncompute"]