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

classiq/interface/generator/arith/uncomputation_methods.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class UncomputationMethods(StrEnum):

classiq/interface/generator/chemistry_function_params.py

@@ -4,6 +4,7 @@ from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     GroundStateProblem,
 )
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
@@ -11,8 +12,6 @@ from classiq.interface.generator.function_params import (
     FunctionParams,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class ChemistryFunctionParams(FunctionParams):
     gs_problem: CHEMISTRY_PROBLEMS_TYPE

classiq/interface/generator/circuit_code/circuit_code.py

@@ -2,6 +2,7 @@ from typing import Dict, Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqMissingOutputFormatError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.circuit_code.types_and_constants import (
     INSTRUCTION_SET_TO_FORMAT,
@@ -12,8 +13,6 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
 )
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 
-from classiq.exceptions import ClassiqMissingOutputFormatError
-
 
 class CircuitCodeInterface(pydantic.BaseModel):
     outputs: Dict[QuantumFormat, Code]

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -2,12 +2,11 @@ from typing import Dict, Tuple
 
 from typing_extensions import TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.hardware import Provider
 
-from classiq._internals.enum_utils import StrEnum
-
 Code: TypeAlias = str
 CodeAndSyntax: TypeAlias = Tuple[Code, QuantumInstructionSet]
 

classiq/interface/generator/commuting_pauli_exponentiation.py

@@ -2,6 +2,7 @@ import pydantic
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
@@ -10,8 +11,6 @@ from classiq.interface.generator.function_params import (
 )
 from classiq.interface.generator.parameters import ParameterFloatType
 
-from classiq.exceptions import ClassiqValueError
-
 
 class CommutingPauliExponentiation(FunctionParams):
     """

classiq/interface/generator/constant.py

@@ -1,6 +1,6 @@
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
 
 class Constant(ASTNode):

classiq/interface/generator/control_state.py

@@ -5,10 +5,9 @@ from typing import Any, Dict
 import pydantic
 from pydantic import BaseModel
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 
-from classiq.exceptions import ClassiqValueError
-
 _DEFAULT_CONTROL_NAME: str = "ctrl"
 _DEFAULT_NUM_CONTROL_QUBITS = 1
 _INVALID_CONTROL_STATE = "invalid_control_state"

classiq/interface/generator/custom_ansatz.py

@@ -2,6 +2,7 @@ from typing import Dict, Type
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.ansatz_library import (
     EntanglingLayersArgs,
     HypercubeArgs,
@@ -11,8 +12,6 @@ from classiq.interface.generator.ansatz_library import (
     TwoLocalArgs,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class CustomAnsatzType(StrEnum):
     TwoLocal = "TwoLocal"

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -24,6 +24,7 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseXor",
     "BitwiseNot",
     "BitwiseOr",
+    "LogicalXor",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,12 +1,11 @@
-from typing import TYPE_CHECKING, Dict
+from typing import Dict
 
-if TYPE_CHECKING:
-    from classiq.qmod.builtins.enums import FinanceFunctionType
+from classiq.interface.generator.types.builtin_enum_declarations import (
+    FinanceFunctionType,
+)
 
 
 def get_finance_function_dict() -> Dict[str, "FinanceFunctionType"]:
-    from classiq.qmod.builtins.enums import FinanceFunctionType
-
     return {
         "var": FinanceFunctionType.VAR,
         "expected shortfall": FinanceFunctionType.SHORTFALL,

classiq/interface/generator/expressions/evaluated_expression.py

@@ -6,6 +6,7 @@ from sympy import Expr
 from typing_extensions import get_args
 
 from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -13,8 +14,6 @@ from classiq.interface.generator.expressions.expression_types import (
 )
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 
-from classiq.exceptions import ClassiqValueError
-
 
 @dataclass(frozen=True)
 class EvaluatedExpression:

classiq/interface/generator/expressions/expression.py

@@ -6,6 +6,7 @@ import pydantic
 from pydantic import PrivateAttr
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
@@ -20,8 +21,6 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
 )
 from classiq.interface.generator.function_params import validate_expression_str
 
-from classiq.exceptions import ClassiqError
-
 
 class Expression(HashableASTNode):
     expr: str

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Set
+from typing import Final, FrozenSet, Set
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -18,3 +18,5 @@ SUPPORTED_FUNC_NAMES: Set[str] = (
 )
 BOOLEAN_LITERALS = {"True", "False"}
 FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
+RESERVED_EXPRESSIONS: FrozenSet[str] = frozenset({"i"})

classiq/interface/generator/expressions/non_symbolic_expr.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, NoReturn
 
-from classiq.exceptions import ClassiqArithmeticError
+from classiq.interface.exceptions import ClassiqArithmeticError
 
 
 class NonSymbolicExpr:

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,5 +1,8 @@
-from typing import Any, Callable, Mapping, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Mapping, Union
 
+from sympy import Integer
+
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -9,109 +12,89 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 
-from classiq.exceptions import ClassiqValueError
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
-SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
-QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
+SLICE_OUT_OF_BOUNDS_MSG = "Slice indices out of bounds"
+SUBSCRIPT_OUT_OF_BOUNDS_MSG = "Subscript index out of bounds"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+ILLEGAL_SLICE_BOUNDS_MSG = (
+    "The quantum array slice start value ({}) must be lower than its stop value ({})."
+)
 
 
 class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def __init__(
         self,
         handle: HandleBinding,
-        element_proxy: Callable[[HandleBinding], QmodSizedProxy],
+        element_type: "QuantumType",
         element_size: int,
         length: int,
     ) -> None:
         super().__init__(handle, element_size * length)
         self._length = length
-        self._element_proxy = element_proxy
+        self._element_type = element_type
         self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int]) -> "QmodSizedProxy":
-        if self._index is not None:
-            raise TypeError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
 
-        new_index: Optional[int] = None
+    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
+        if isinstance(index, Integer):
+            index = int(index)
+        if index < 0 or index >= self._length:
+            raise ClassiqValueError(SUBSCRIPT_OUT_OF_BOUNDS_MSG)
 
-        if isinstance(key, slice):
-            if key.step is not None:
-                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-            new_slice = self._get_new_slice(key.start, key.stop)
-        else:
-            new_slice = self._get_new_slice(key, key + 1)
-            new_index = new_slice[0]
+        return self._element_type.get_proxy(
+            SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            )
+        )
 
-        if (self._slice is not None and new_slice[1] > self._slice[1]) or new_slice[
-            1
-        ] > self._size:
+    def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
+        if slice_.step is not None:
+            raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if isinstance(slice_.start, Integer):
+            slice_ = slice(int(slice_.start), slice_.stop)
+        if isinstance(slice_.stop, Integer):
+            slice_ = slice(slice_.start, int(slice_.stop))
+        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
+            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
+        if slice_.start >= slice_.stop:
+            raise ClassiqValueError(
+                ILLEGAL_SLICE_BOUNDS_MSG.format(slice_.start, slice_.stop)
+            )
+        if slice_.start < 0 or slice_.stop > self._length:
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 
-        new_handle = self._get_new_handle(new_index, new_slice)
-        if new_index is not None:
-            return self._element_proxy(new_handle)
         return QmodQArrayProxy(
-            new_handle,
-            self._element_proxy,
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(slice_.start)),
+                end=Expression(expr=str(slice_.stop)),
+            ),
+            self._element_type,
             self._element_size,
-            self._length,
+            slice_.stop - slice_.start,
         )
 
-    def _get_new_slice(self, start: int, end: int) -> Tuple[int, int]:
-        if self._slice is not None:
-            return self._slice[0] + start, self._slice[0] + end
-        return start, end
-
     @property
     def type_name(self) -> str:
         return "Quantum array"
 
-    @property
-    def _index(self) -> Optional[int]:
-        if not isinstance(self._handle, SubscriptHandleBinding):
-            return None
-        return self._handle.index.to_int_value()
-
-    @property
-    def _slice(self) -> Optional[Tuple[int, int]]:
-        if not isinstance(self._handle, SlicedHandleBinding):
-            return None
-        return self._handle.start.to_int_value(), self._handle.end.to_int_value()
-
-    def _get_new_handle(
-        self, new_index: Optional[int], new_slice: Tuple[int, int]
-    ) -> HandleBinding:
-        if new_index is not None:
-            return SubscriptHandleBinding(
-                name=self.handle.name,
-                index=Expression(expr=str(new_index)),
-            )
-        return SlicedHandleBinding(
-            name=self.handle.name,
-            start=Expression(expr=str(new_slice[0])),
-            end=Expression(expr=str(new_slice[1])),
-        )
-
     @property
     def len(self) -> int:
         return self._length
 
     @property
     def fields(self) -> Mapping[str, Any]:
-        return {
-            "len": self.len,
-        }
+        return {**super().fields, "len": self.len}
 
     @property
     def size(self) -> int:
-        if (slice_ := self._slice) is not None:
-            length = slice_[1] - slice_[0]
-        elif self._index is not None:
-            length = 1
-        else:
-            length = self._length
-        return length * self._element_size
-
-    def __str__(self) -> str:
-        return str(self.handle)
+        return self.len * self._element_size

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -2,11 +2,10 @@ from typing import Any, Mapping
 
 from sympy import Symbol
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.model.handle_binding import HandleBinding
 
-from classiq.exceptions import ClassiqValueError
-
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
     def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
@@ -42,10 +41,6 @@ class QmodQNumProxy(QmodQScalarProxy):
     def type_name(self) -> str:
         return "Quantum numeric"
 
-    @property
-    def size(self) -> int:
-        return self._size
-
     @property
     def fraction_digits(self) -> int:
         return self._fraction_digits
@@ -57,7 +52,7 @@ class QmodQNumProxy(QmodQScalarProxy):
     @property
     def fields(self) -> Mapping[str, Any]:
         return {
-            "size": self.size,
+            **super().fields,
             "is_signed": self.is_signed,
             "fraction_digits": self.fraction_digits,
         }

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING, Mapping
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+class QmodQStructProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        struct_name: str,
+        fields: Mapping[str, "QuantumType"],
+    ) -> None:
+        self._fields = {
+            name: type_.get_proxy(FieldHandleBinding(base_handle=handle, field=name))
+            for name, type_ in fields.items()
+        }
+        size = sum(proxy.size for proxy in self._fields.values())
+        super().__init__(handle, size)
+        self._struct_name = struct_name
+
+    @property
+    def type_name(self) -> str:
+        return self._struct_name
+
+    @property
+    def fields(self) -> Mapping[str, QmodSizedProxy]:
+        return {**super().fields, **self._fields}

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -30,4 +30,4 @@ class QmodSizedProxy:
 
     @property
     def fields(self) -> Mapping[str, Any]:
-        return {}
+        return {"size": self._size}

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -66,7 +66,8 @@ NUMERIC_CONSTANTS: List[str] = [
     "EulerGamma",
     "Catalan",
 ]
-CONSTANTS: List[str] = NUMERIC_CONSTANTS + ["true", "false"]
+BOOLEAN_CONSTANTS: List[str] = ["true", "false"]
+CONSTANTS: List[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
 
 DATA_TYPES: List[str] = ["Matrix"]
 LOGIC_OPERATORS: List[str] = [

classiq/interface/generator/function_params.py

@@ -19,6 +19,8 @@ import pydantic
 import sympy
 from pydantic.fields import ModelField
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     validate_expression,
 )
@@ -28,9 +30,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 FunctionParamsDiscriminator = str
 
 IOName = PydanticNonEmptyString

classiq/interface/generator/functions/builtins/core_library/__init__.py

@@ -3,12 +3,14 @@ from classiq.interface.generator.application_apis.combinatorial_optimization_dec
 from classiq.interface.generator.application_apis.finance_declarations import *  # noqa: F403
 from classiq.interface.generator.application_apis.qsvm_declarations import *  # noqa: F403
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
 from .atomic_quantum_functions import *  # noqa: F403
 from .exponentiation_functions import *  # noqa: F403
 
 CORE_LIB_DECLS = [
-    func for func in vars().values() if isinstance(func, QuantumFunctionDeclaration)
+    func
+    for func in vars().values()
+    if isinstance(func, NamedParamsQuantumFunctionDeclaration)
 ]