classiq 0.67.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -3,6 +3,7 @@ from typing import Any, Optional, Protocol, TypeVar
 
 import httpx
 import pydantic
+from pydantic.main import IncEx
 
 import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
@@ -72,11 +73,12 @@ class ApiWrapper:
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
         http_client: Optional[httpx.AsyncClient] = None,
+        exclude: Optional[IncEx] = None,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
-        body = json.loads(model.model_dump_json())
+        body = json.loads(model.model_dump_json(exclude=exclude))
         return await cls._call_task(
             http_method,
             url,
@@ -135,6 +137,7 @@ class ApiWrapper:
             url=routes.EXECUTION_SESSIONS_PREFIX,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
         return raw_result["id"]
 
@@ -164,6 +167,7 @@ class ApiWrapper:
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
 
     @classmethod

classiq/_internals/async_utils.py

@@ -58,7 +58,7 @@ def enable_jupyter_notebook() -> None:
 
 
 def _make_iterable_interval(
-    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]]
+    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]],
 ) -> Iterable[float]:
     if isinstance(interval_sec, Iterable):
         return map(float, interval_sec)

classiq/_internals/authentication/password_manager.py

@@ -117,7 +117,7 @@ class DummyPasswordManager(PasswordManager):
 
 class FilePasswordManager(PasswordManager):
     _CLASSIQ_CREDENTIALS_FILE_PATH: str = "{}/.classiq-credentials".format(
-        os.getenv("HOME")
+        os.getenv("CLASSIQ_DIR", os.getenv("HOME"))
     )
 
     def __init__(self) -> None:

classiq/_internals/client.py

@@ -89,7 +89,7 @@ P = ParamSpec("P")
 
 
 def try_again_on_failure(
-    func: Callable[P, Awaitable[Ret]]
+    func: Callable[P, Awaitable[Ret]],
 ) -> Callable[P, Awaitable[Ret]]:
     def check_approved_api_error(error_message: str) -> bool:
         for approved_api_error in APPROVED_API_ERROR_MESSAGES_FOR_RESTART:

classiq/execution/execution_session.py

@@ -1,4 +1,3 @@
-import json
 import random
 from types import TracebackType
 from typing import Callable, Optional, Union, cast
@@ -16,7 +15,10 @@ from classiq.interface.executor.result import (
 )
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
 
 from classiq._internals import async_utils
@@ -46,7 +48,9 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     return (
         program
         if isinstance(program, QuantumProgram)
-        else QuantumProgram.model_validate(json.loads(program))
+        else QuantumProgram.model_validate_json(
+            program, context={OMIT_DEBUG_INFO_FLAG: True}
+        )
     )
 
 

classiq/executor.py

@@ -10,7 +10,10 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
@@ -27,7 +30,9 @@ BackendPreferencesAndResult: TypeAlias = tuple[
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
 ) -> QuantumProgram:
-    return QuantumProgram.model_validate_json(quantum_program)
+    return QuantumProgram.model_validate_json(
+        quantum_program, context={OMIT_DEBUG_INFO_FLAG: True}
+    )
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:

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

classiq/interface/ast_node.py

@@ -20,7 +20,7 @@ class ASTNode(HashablePydanticBaseModel):
         return self
 
 
-def without_statement_blocks(
+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})

classiq/interface/chemistry/operator.py

@@ -69,7 +69,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
 
     @staticmethod
     def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
+        coeff: Union[sympy.Expr, ParameterComplexType],
     ) -> ParameterComplexType:
         if isinstance(coeff, str):
             validate_expression_str(coeff)

classiq/interface/debug_info/debug_info.py

@@ -89,6 +89,21 @@ class DebugInfoCollection(BaseModel):
         return self.blackbox_data.get(debug_info.name)
 
 
+def get_back_refs(
+    debug_info: FunctionDebugInfo, collected_debug_info: DebugInfoCollection
+) -> list[ConcreteQuantumStatement]:
+    back_refs: list[ConcreteQuantumStatement] = []
+    while (node := debug_info.node) is not None:
+        back_refs.insert(0, node)
+        if node.back_ref is None:
+            break
+        next_debug_info = collected_debug_info.get(node.back_ref)
+        if next_debug_info is None:
+            break
+        debug_info = next_debug_info
+    return back_refs
+
+
 def new_function_debug_info_by_node(
     node: ConcreteQuantumStatement,
 ) -> FunctionDebugInfo:

classiq/interface/generator/arith/arithmetic.py

@@ -1,4 +1,5 @@
-from typing import Any, Final, Optional
+import ast
+from typing import Any, Final, Optional, cast
 
 import networkx as nx
 import pydantic
@@ -95,6 +96,9 @@ def get_arithmetic_params(
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
+    expr_str, var_types = _substitute_quantum_subscripts(
+        expr_str, var_types, machine_precision
+    )
     return Arithmetic(
         expression=expr_str,
         definitions={
@@ -121,3 +125,94 @@ def compute_arithmetic_result_type(
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]
     )
+
+
+def aggregate_numeric_types(
+    numeric_types: list[QuantumNumeric],
+) -> RegisterArithmeticInfo:
+    if all(
+        numeric_type.size_in_bits == 1
+        and numeric_type.sign_value
+        and numeric_type.fraction_digits_value == 1
+        for numeric_type in numeric_types
+    ):
+        return RegisterArithmeticInfo(size=1, is_signed=True, fraction_places=1)
+    int_size = max(
+        numeric_type.size_in_bits
+        - int(numeric_type.sign_value)
+        - numeric_type.fraction_digits_value
+        for numeric_type in numeric_types
+    )
+    is_signed = any(numeric_type.sign_value for numeric_type in numeric_types)
+    frac_size = max(
+        numeric_type.fraction_digits_value for numeric_type in numeric_types
+    )
+    total_size = int_size + int(is_signed) + frac_size
+    return RegisterArithmeticInfo(
+        size=total_size, is_signed=is_signed, fraction_places=frac_size
+    )
+
+
+class _QuantumSubscriptRemover(ast.NodeTransformer):
+    def __init__(self, machine_precision: int) -> None:
+        self._machine_precision = machine_precision
+        self.substitutions_types: dict[str, QuantumNumeric] = {}
+
+    def visit_Call(self, node: ast.Call) -> ast.expr:
+        if not isinstance(node.func, ast.Name) or node.func.id != "Piecewise":
+            return node
+        items = [
+            cast(float, cast(ast.Num, cast(ast.Tuple, arg).elts[0]).value)
+            for arg in node.args
+        ]
+        numeric_types = [
+            compute_arithmetic_result_type(str(num), {}, self._machine_precision)
+            for num in items
+        ]
+        unified_numeric_type = register_info_to_quantum_type(
+            aggregate_numeric_types(numeric_types)
+        )
+        substitution_var_name = f"__lut__{len(self.substitutions_types)}__"
+        self.substitutions_types[substitution_var_name] = unified_numeric_type
+        return ast.Name(id=substitution_var_name)
+
+
+class _NameCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.names: set[str] = set()
+
+    def visit_Name(self, node: ast.Name) -> None:
+        self.names.add(node.id)
+
+
+def _substitute_quantum_subscripts(
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
+) -> tuple[str, dict[str, QuantumType]]:
+    """
+    Remove quantum lookup expressions ([1, 2, 3, 4][n]) from an arithmetic expression
+    for the purpose of calculating its numeric attributes.
+    Each quantum lookup expression is replaced by a numeric value with equivalent
+    numeric properties.
+
+    Args:
+        expr_str: arithmetic expression
+        var_types: quantum variable type mapping
+        machine_precision: global machine precision
+
+    Returns:
+        1. the reduced expression
+        2. updated type mapping
+    """
+    expr_ast = ast.parse(expr_str)
+    subscript_remover = _QuantumSubscriptRemover(machine_precision)
+    expr_ast = subscript_remover.visit(expr_ast)
+    var_types_substituted = var_types | subscript_remover.substitutions_types
+    expr_str_substituted = ast.unparse(expr_ast)
+    names_collector = _NameCollector()
+    names_collector.visit(ast.parse(expr_str_substituted))
+    var_types_substituted = {
+        var_name: var_type
+        for var_name, var_type in var_types_substituted.items()
+        if var_name in names_collector.names
+    }
+    return expr_str_substituted, var_types_substituted

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -91,7 +91,7 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[tuple[Node, str]]
+        in_edges: Collection[tuple[Node, str]],
     ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,

classiq/interface/generator/generated_circuit_data.py

@@ -11,6 +11,7 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.statement_block import StatementBlock
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_capture_name,
@@ -22,7 +23,7 @@ _logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
-CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
+CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -136,6 +137,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     parameters: list[OperationParameter] = list()
     port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
     release_by_inverse: bool = pydantic.Field(default=False)
+    back_refs: StatementBlock = pydantic.Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
@@ -167,7 +169,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @staticmethod
     def create_parameters_from_dict(
-        parameters: dict[str, str]
+        parameters: dict[str, str],
     ) -> list[OperationParameter]:
         return [
             OperationParameter(label=key, value=value)

classiq/interface/generator/quantum_program.py

@@ -1,9 +1,11 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import pydantic
+from pydantic import model_validator
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
 from classiq.interface.exceptions import (
@@ -36,6 +38,8 @@ from classiq.interface.ide.visual_model import CircuitMetrics
 RegisterName: TypeAlias = str
 InitialConditions: TypeAlias = dict[RegisterName, int]
 
+OMIT_DEBUG_INFO_FLAG = "omit_debug_info"
+
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
@@ -71,6 +75,19 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
+    @model_validator(mode="before")
+    @classmethod
+    def remove_debug_info(
+        cls, data: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
+        if (
+            isinstance(data, dict)
+            and info.context is not None
+            and info.context.get(OMIT_DEBUG_INFO_FLAG, False)
+        ):
+            data.pop("debug_info", None)
+        return data
+
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
         if circuit_code is not None:

classiq/interface/generator/types/enum_declaration.py

@@ -1,5 +1,6 @@
 from collections import Counter
 from enum import Enum, EnumMeta, IntEnum
+from typing import Any, Callable
 
 import pydantic
 
@@ -7,6 +8,33 @@ from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqValueError
 
 
+def rebuild_dynamic_enum(name: str, members: dict[str, int]) -> type[IntEnum]:
+    """
+    Rebuilds the dynamic enum from its name and members.
+    Returns a new enum type.
+    """
+    new_enum = IntEnum(name, members)  # type: ignore[misc]
+    setattr(new_enum, "__members_data__", members)  # noqa: B010
+    setattr(new_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+    return new_enum
+
+
+def dynamic_enum_reduce_ex(
+    obj: Any, protocol: int
+) -> tuple[Callable[..., type[IntEnum]], tuple[str, dict[str, int]]]:
+    """
+    Custom __reduce_ex__ for dynamic enums.
+    This function will be used when pickling an enum type or one of its members.
+    """
+    # Get the enum type and its member data.
+    enum_type = type(obj)
+    members = getattr(enum_type, "__members_data__", None)
+    if members is None:
+        raise ValueError("Dynamic enum is missing __members_data__ attribute")
+    # Return the callable and arguments needed to rebuild the enum type.
+    return rebuild_dynamic_enum, (enum_type.__name__, members)
+
+
 class EnumDeclaration(HashableASTNode):
     name: str
 
@@ -39,8 +67,11 @@ class EnumDeclaration(HashableASTNode):
 
         return members
 
-    def create_enum(self) -> IntEnum:
-        return IntEnum(self.name, self.members)
+    def create_enum(self) -> type[IntEnum]:
+        dynamic_enum = IntEnum(self.name, self.members)  # type: ignore[misc]
+        setattr(dynamic_enum, "__members_data__", self.members)  # noqa: B010
+        setattr(dynamic_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+        return dynamic_enum
 
 
 def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:

classiq/interface/model/classical_if.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class ClassicalIf(QuantumOperation):
     else_: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["then", "else_"])
+        return reset_lists(self, ["then", "else_"])

classiq/interface/model/control.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -46,4 +46,4 @@ class Control(QuantumExpressionOperation):
         )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body", "else_block"])
+        return reset_lists(self, ["body", "else_block"])

classiq/interface/model/invert.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -13,4 +13,4 @@ class Invert(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/power.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -15,4 +15,4 @@ class Power(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/quantum_function_call.py

@@ -7,6 +7,7 @@ from typing import (
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -45,6 +46,9 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return reset_lists(self, ["positional_args"])
+
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         if self._func_decl is None:

classiq/interface/model/repeat.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class Repeat(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/statement_block.py

@@ -27,8 +27,8 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Annotated[
     Union[
-        Allocate,
         QuantumFunctionCall,
+        Allocate,
         ArithmeticOperation,
         AmplitudeLoadingOperation,
         VariableDeclarationStatement,

classiq/interface/model/within_apply_operation.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -14,4 +14,4 @@ class WithinApply(QuantumOperation):
     action: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["compute", "action"])
+        return reset_lists(self, ["compute", "action"])